From 14abe1a4076c52a30e0391356b8b2bd2938aeb55 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Tue, 3 Apr 2018 19:02:49 -0500
Subject: [PATCH 01/56] Fixup 360 support

---
 premake5.lua                                  | 33 +++++++++++--------
 src/xenia/app/premake5.lua                    |  9 +++++
 src/xenia/base/platform_linux.h               |  1 +
 .../ppc/testing/ppc_testing_native_main.cc    |  2 +-
 src/xenia/gpu/gl4/premake5.lua                |  9 +++++
 src/xenia/gpu/vulkan/premake5.lua             | 18 ++++++++++
 xenia-build                                   | 22 ++++++-------
 7 files changed, 68 insertions(+), 26 deletions(-)

diff --git a/premake5.lua b/premake5.lua
index e28db9335..f68849e99 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -28,9 +28,11 @@ defines({
 })
 
 -- TODO(DrChat): Find a way to disable this on other architectures.
-filter("architecture:x86_64")
-  vectorextensions("AVX")
-filter({})
+if ARCH ~= "ppc64" then
+  filter("architecture:x86_64")
+    vectorextensions("AVX")
+  filter({})
+end
 
 characterset("Unicode")
 flags({
@@ -95,13 +97,6 @@ filter("platforms:Linux")
     "dl",
     "lz4",
     "rt",
-    "X11",
-    "xcb",
-    "X11-xcb",
-    "GL",
-    "vulkan",
-    "c++",
-    "c++abi"
   })
   linkoptions({
     "`pkg-config --libs gtk+-3.0`",
@@ -110,19 +105,31 @@ filter("platforms:Linux")
 filter({"platforms:Linux", "kind:*App"})
   linkgroups("On")
 
-filter({"platforms:Linux", "language:C++", "toolset:gcc"})
+filter({"platforms:Linux", "toolset:gcc"})
   buildoptions({
-    "--std=c++11",
+    "-std=c++14",
   })
   links({
   })
+  if ARCH == "ppc64" then
+    buildoptions({
+      "-m32",
+      "-mpowerpc64"
+    })
+    linkoptions({
+      "-m32",
+      "-mpowerpc64"
+    })
+  end
 
-filter({"platforms:Linux", "language:C++", "toolset:clang"})
+filter({"platforms:Linux", "toolset:clang"})
   buildoptions({
     "-std=c++14",
     "-stdlib=libstdc++",
   })
   links({
+    "c++",
+    "c++abi"
   })
   disablewarnings({
     "deprecated-register"
diff --git a/src/xenia/app/premake5.lua b/src/xenia/app/premake5.lua
index a999512c4..4f5498b99 100644
--- a/src/xenia/app/premake5.lua
+++ b/src/xenia/app/premake5.lua
@@ -60,6 +60,15 @@ project("xenia-app")
     project_root,
   })
 
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+
   filter("platforms:Windows")
     links({
       "xenia-apu-xaudio2",
diff --git a/src/xenia/base/platform_linux.h b/src/xenia/base/platform_linux.h
index 345be94ab..ac64879e5 100644
--- a/src/xenia/base/platform_linux.h
+++ b/src/xenia/base/platform_linux.h
@@ -13,6 +13,7 @@
 // NOTE: if you're including this file it means you are explicitly depending
 // on Linux headers. Including this file outside of linux platform specific
 // source code will break portability
+#include <cstddef>
 
 #include "xenia/base/platform.h"
 
diff --git a/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc b/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc
index 28ba3887b..25934f252 100644
--- a/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc
+++ b/src/xenia/cpu/ppc/testing/ppc_testing_native_main.cc
@@ -189,7 +189,7 @@ class TestRunner {
 
   ~TestRunner() {
     memory::DeallocFixed(memory_, memory_size_,
-                         memory::DeallocationType::kDecommitRelease);
+                         memory::DeallocationType::kRelease);
 
     memory::AlignedFree(context_);
   }
diff --git a/src/xenia/gpu/gl4/premake5.lua b/src/xenia/gpu/gl4/premake5.lua
index 6c61b285a..041ef8b2d 100644
--- a/src/xenia/gpu/gl4/premake5.lua
+++ b/src/xenia/gpu/gl4/premake5.lua
@@ -68,6 +68,15 @@ project("xenia-gpu-gl4-trace-viewer")
     "../../base/main_"..platform_suffix..".cc",
   })
 
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+
   filter("platforms:Windows")
     links({
       "xenia-apu-xaudio2",
diff --git a/src/xenia/gpu/vulkan/premake5.lua b/src/xenia/gpu/vulkan/premake5.lua
index 3e41ca44d..146ac2bd7 100644
--- a/src/xenia/gpu/vulkan/premake5.lua
+++ b/src/xenia/gpu/vulkan/premake5.lua
@@ -71,6 +71,15 @@ project("xenia-gpu-vulkan-trace-viewer")
     "../../base/main_"..platform_suffix..".cc",
   })
 
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+
   filter("platforms:Windows")
     links({
       "xenia-apu-xaudio2",
@@ -131,6 +140,15 @@ project("xenia-gpu-vulkan-trace-dump")
     "../../base/main_"..platform_suffix..".cc",
   })
 
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+
   filter("platforms:Windows")
     -- Only create the .user file if it doesn't already exist.
     local user_file = project_root.."/build/xenia-gpu-vulkan-trace-dump.vcxproj.user"
diff --git a/xenia-build b/xenia-build
index 0882231a0..167259edf 100755
--- a/xenia-build
+++ b/xenia-build
@@ -310,7 +310,7 @@ def get_clang_format_binary():
     sys.exit(1)
 
 
-def run_premake(target_os, action):
+def run_premake(target_os, action, cc=None):
     """Runs premake on the main project with the given format.
 
     Args:
@@ -322,7 +322,7 @@ def run_premake(target_os, action):
         os.path.join('tools', 'build', 'premake'),
         '--file=premake5.lua',
         '--os=%s' % target_os,
-        '--cc=clang',
+        '--cc=%s' % ('clang' if not cc else cc),
         '--test-suite-mode=combined',
         '--verbose',
         action,
@@ -344,7 +344,7 @@ def run_premake_clean():
         return run_premake('linux', 'clean')
 
 
-def run_platform_premake():
+def run_platform_premake(cc=None):
     """Runs all gyp configurations.
     """
     if sys.platform == 'darwin':
@@ -356,7 +356,7 @@ def run_platform_premake():
 
         return run_premake('windows', 'vs' + vs_version)
     else:
-        ret = run_premake('linux', 'gmake')
+        ret = run_premake('linux', 'gmake', cc)
         ret = ret != 0 and run_premake('linux', 'codelite') or ret
         return ret
 
@@ -546,12 +546,14 @@ class PremakeCommand(Command):
             name='premake',
             help_short='Runs premake to update all projects.',
             *args, **kwargs)
+        self.parser.add_argument(
+            '--cc', default='clang', help='Compiler toolchain passed to premake')
 
     def execute(self, args, pass_args, cwd):
         # Update premake. If no binary found, it will be built from source.
         print('Running premake...')
         print('')
-        if run_platform_premake() == 0:
+        if run_platform_premake(args['cc']) == 0:
             print('Success!')
 
         return 0
@@ -564,6 +566,8 @@ class BaseBuildCommand(Command):
         super(BaseBuildCommand, self).__init__(
             subparsers,
             *args, **kwargs)
+        self.parser.add_argument(
+            '--cc', default='clang', help='Compiler toolchain passed to premake')
         self.parser.add_argument(
             '--config', choices=['checked', 'debug', 'release'], default='debug',
             type=str.lower, help='Chooses the build configuration.')
@@ -582,7 +586,7 @@ class BaseBuildCommand(Command):
     def execute(self, args, pass_args, cwd):
         if not args['no_premake']:
             print('- running premake...')
-            run_platform_premake()
+            run_platform_premake(args['cc'])
             print('')
 
         threads = args['j']
@@ -613,12 +617,6 @@ class BaseBuildCommand(Command):
             print('ERROR: don\'t know how to build on this platform.')
             result = 1
         else:
-            # TODO(benvanik): allow gcc?
-            if 'CXX' not in os.environ:
-                os.environ['CXX'] = 'clang++-3.8'
-            if 'CC' not in os.environ:
-                os.environ['CC'] = 'clang-3.8'
-
             result = subprocess.call([
                 'make',
                 '-j' if threads is 0 else '-j%d' % threads,

From 9653c0bafc586ecdc64a5aa8821bdfebeef45d3b Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Tue, 3 Apr 2018 19:08:30 -0500
Subject: [PATCH 02/56] [GPU] Allow dynamic building of GPU packets

---
 src/xenia/gpu/xenos.h                       | 25 +++++++++------------
 src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc |  4 ++--
 2 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/src/xenia/gpu/xenos.h b/src/xenia/gpu/xenos.h
index e0dd8e35c..d6a24a856 100644
--- a/src/xenia/gpu/xenos.h
+++ b/src/xenia/gpu/xenos.h
@@ -601,20 +601,18 @@ enum Type3Opcode {
 };
 // clang-format on
 
-template <uint16_t index, uint16_t count, bool one_reg = false>
-constexpr inline uint32_t MakePacketType0() {
+inline uint32_t MakePacketType0(uint16_t index, uint16_t count,
+                                bool one_reg = false) {
   // ttcccccc cccccccc oiiiiiii iiiiiiii
-  static_assert(index <= 0x7FFF, "index must be <= 0x7FFF");
-  static_assert(count >= 1 && count <= 0x4000,
-                "count must be >= 1 and <= 0x4000");
+  assert(index <= 0x7FFF);
+  assert(count >= 1 && count <= 0x4000);
   return (0u << 30) | (((count - 1) & 0x3FFF) << 16) | (index & 0x7FFF);
 }
 
-template <uint16_t index_1, uint16_t index_2>
-constexpr inline uint32_t MakePacketType1() {
+inline uint32_t MakePacketType1(uint16_t index_1, uint16_t index_2) {
   // tt?????? ??222222 22222111 11111111
-  static_assert(index_1 <= 0x7FF, "index_1 must be <= 0x7FF");
-  static_assert(index_2 <= 0x7FF, "index_2 must be <= 0x7FF");
+  assert(index_1 <= 0x7FF);
+  assert(index_2 <= 0x7FF);
   return (1u << 30) | ((index_2 & 0x7FF) << 11) | (index_1 & 0x7FF);
 }
 
@@ -623,12 +621,11 @@ constexpr inline uint32_t MakePacketType2() {
   return (2u << 30);
 }
 
-template <Type3Opcode opcode, uint16_t count, bool predicate = false>
-constexpr inline uint32_t MakePacketType3() {
+inline uint32_t MakePacketType3(Type3Opcode opcode, uint16_t count,
+                                bool predicate = false) {
   // ttcccccc cccccccc ?ooooooo ???????p
-  static_assert(opcode <= 0x7F, "opcode must be <= 0x7F");
-  static_assert(count >= 1 && count <= 0x4000,
-                "count must be >= 1 and <= 0x4000");
+  assert(opcode <= 0x7F);
+  assert(count >= 1 && count <= 0x4000);
   return (3u << 30) | (((count - 1) & 0x3FFF) << 16) | ((opcode & 0x7F) << 8) |
          (predicate ? 1 : 0);
 }
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
index 560cec820..d2675f125 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
@@ -374,7 +374,7 @@ void VdSwap(lpvoid_t buffer_ptr,  // ptr into primary ringbuffer
 
   // Write in the texture fetch.
   dwords[offset++] =
-      xenos::MakePacketType0<gpu::XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0, 6>();
+      xenos::MakePacketType0(gpu::XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0, 6);
   dwords[offset++] = fetch.dword_0;
   dwords[offset++] = fetch.dword_1;
   dwords[offset++] = fetch.dword_2;
@@ -382,7 +382,7 @@ void VdSwap(lpvoid_t buffer_ptr,  // ptr into primary ringbuffer
   dwords[offset++] = fetch.dword_4;
   dwords[offset++] = fetch.dword_5;
 
-  dwords[offset++] = xenos::MakePacketType3<xenos::PM4_XE_SWAP, 4>();
+  dwords[offset++] = xenos::MakePacketType3(xenos::PM4_XE_SWAP, 4);
   dwords[offset++] = 'SWAP';
   dwords[offset++] = (*frontbuffer_ptr) & 0x1FFFFFFF;
 

From ed48242f4f08b7608e3db39f6379f857026054f8 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Tue, 3 Apr 2018 19:21:17 -0500
Subject: [PATCH 03/56] Fix Travis

---
 premake5.lua | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/premake5.lua b/premake5.lua
index f68849e99..5412aad33 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -105,12 +105,14 @@ filter("platforms:Linux")
 filter({"platforms:Linux", "kind:*App"})
   linkgroups("On")
 
-filter({"platforms:Linux", "toolset:gcc"})
+filter({"platforms:Linux", "language:C++", "toolset:gcc"})
   buildoptions({
     "-std=c++14",
   })
   links({
   })
+
+filter({"platforms:Linux", "toolset:gcc"})
   if ARCH == "ppc64" then
     buildoptions({
       "-m32",
@@ -122,7 +124,7 @@ filter({"platforms:Linux", "toolset:gcc"})
     })
   end
 
-filter({"platforms:Linux", "toolset:clang"})
+filter({"platforms:Linux", "language:C++", "toolset:clang"})
   buildoptions({
     "-std=c++14",
     "-stdlib=libstdc++",

From 5a831fa27395484279257d1e90a5b0aa22bf5723 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Tue, 3 Apr 2018 19:55:55 -0500
Subject: [PATCH 04/56] Fix UI programs on linux

---
 src/xenia/hid/premake5.lua       | 10 ++++++++++
 src/xenia/ui/gl/premake5.lua     |  9 +++++++++
 src/xenia/ui/vulkan/premake5.lua | 10 ++++++++++
 3 files changed, 29 insertions(+)

diff --git a/src/xenia/hid/premake5.lua b/src/xenia/hid/premake5.lua
index 69ea6c197..dbe4f7b81 100644
--- a/src/xenia/hid/premake5.lua
+++ b/src/xenia/hid/premake5.lua
@@ -32,6 +32,16 @@ project("xenia-hid-demo")
     "xenia-ui",
     "xenia-ui-gl",
   })
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+  filter()
+
   flags({
     "WinMain",  -- Use WinMain instead of main.
   })
diff --git a/src/xenia/ui/gl/premake5.lua b/src/xenia/ui/gl/premake5.lua
index 430640c70..c562290a8 100644
--- a/src/xenia/ui/gl/premake5.lua
+++ b/src/xenia/ui/gl/premake5.lua
@@ -34,6 +34,15 @@ project("xenia-ui-window-gl-demo")
     "xenia-ui",
     "xenia-ui-gl",
   })
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+  filter()
   flags({
     "WinMain",  -- Use WinMain instead of main.
   })
diff --git a/src/xenia/ui/vulkan/premake5.lua b/src/xenia/ui/vulkan/premake5.lua
index 71824e5ec..ab31e3b90 100644
--- a/src/xenia/ui/vulkan/premake5.lua
+++ b/src/xenia/ui/vulkan/premake5.lua
@@ -37,6 +37,16 @@ project("xenia-ui-window-vulkan-demo")
     "xenia-ui-spirv",
     "xenia-ui-vulkan",
   })
+  filter("platforms:Linux")
+    links({
+      "X11",
+      "xcb",
+      "X11-xcb",
+      "GL",
+      "vulkan",
+    })
+  filter()
+  
   flags({
     "WinMain",  -- Use WinMain instead of main.
   })

From 1d4fa80eac35feb4419fde28a394e0b26fd35cc0 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sun, 8 Apr 2018 15:50:10 -0500
Subject: [PATCH 05/56] [GPU] Fixup ringbuffer log2_size (which specifies size
 in qwords) Save microengine init packets

---
 src/xenia/gpu/command_processor.cc          | 8 ++++++--
 src/xenia/gpu/command_processor.h           | 3 +++
 src/xenia/gpu/graphics_system.cc            | 4 ++--
 src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc | 6 ------
 4 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/xenia/gpu/command_processor.cc b/src/xenia/gpu/command_processor.cc
index d957f432c..960cc8294 100644
--- a/src/xenia/gpu/command_processor.cc
+++ b/src/xenia/gpu/command_processor.cc
@@ -236,7 +236,7 @@ void CommandProcessor::ShutdownContext() { context_.reset(); }
 void CommandProcessor::InitializeRingBuffer(uint32_t ptr, uint32_t log2_size) {
   read_ptr_index_ = 0;
   primary_buffer_ptr_ = ptr;
-  primary_buffer_size_ = uint32_t(std::pow(2u, log2_size));
+  primary_buffer_size_ = 1 << log2_size;
 }
 
 void CommandProcessor::EnableReadPointerWriteBack(uint32_t ptr,
@@ -695,7 +695,11 @@ bool CommandProcessor::ExecutePacketType3_ME_INIT(RingBuffer* reader,
                                                   uint32_t packet,
                                                   uint32_t count) {
   // initialize CP's micro-engine
-  reader->AdvanceRead(count * sizeof(uint32_t));
+  me_bin_.clear();
+  for (uint32_t i = 0; i < count; i++) {
+    me_bin_.push_back(reader->ReadAndSwap<uint32_t>());
+  }
+
   return true;
 }
 
diff --git a/src/xenia/gpu/command_processor.h b/src/xenia/gpu/command_processor.h
index a418dd683..7cfedb0f9 100644
--- a/src/xenia/gpu/command_processor.h
+++ b/src/xenia/gpu/command_processor.h
@@ -215,6 +215,9 @@ class CommandProcessor {
   std::function<void()> swap_request_handler_;
   std::queue<std::function<void()>> pending_fns_;
 
+  // MicroEngine binary from PM4_ME_INIT
+  std::vector<uint32_t> me_bin_;
+
   uint32_t counter_ = 0;
 
   uint32_t primary_buffer_ptr_ = 0;
diff --git a/src/xenia/gpu/graphics_system.cc b/src/xenia/gpu/graphics_system.cc
index 56443db3a..7728e8eee 100644
--- a/src/xenia/gpu/graphics_system.cc
+++ b/src/xenia/gpu/graphics_system.cc
@@ -170,7 +170,7 @@ uint32_t GraphicsSystem::ReadRegister(uint32_t addr) {
   uint32_t r = (addr & 0xFFFF) / 4;
 
   switch (r) {
-    case 0x0F00:  // ?
+    case 0x0F00:  // RB_EDRAM_TIMING
       return 0x08100748;
     case 0x0F01:  // RB_BC_CONTROL
       return 0x0000200E;
@@ -211,7 +211,7 @@ void GraphicsSystem::WriteRegister(uint32_t addr, uint32_t value) {
 }
 
 void GraphicsSystem::InitializeRingBuffer(uint32_t ptr, uint32_t log2_size) {
-  command_processor_->InitializeRingBuffer(ptr, (log2_size | 0x2) + 1);
+  command_processor_->InitializeRingBuffer(ptr, log2_size + 0x3);
 }
 
 void GraphicsSystem::EnableReadPointerWriteBack(uint32_t ptr,
diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
index d2675f125..3491b272d 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
@@ -205,12 +205,6 @@ DECLARE_XBOXKRNL_EXPORT(VdSetGraphicsInterruptCallback, ExportTag::kVideo);
 void VdInitializeRingBuffer(lpvoid_t ptr, int_t log2_size) {
   // r3 = result of MmGetPhysicalAddress
   // r4 = log2(size)
-  // r4 is or'd with 0x802 and then stuffed into CP_RB_CNTL
-  // according to AMD docs, this corresponds with RB_BUFSZ, which is log2
-  // actual size.
-  // 0x8 is RB_BLKSZ, or number of words gpu will read before updating the
-  // host read pointer.
-  // So being or'd with 0x2 makes the ring buffer size always a multiple of 4.
   // Buffer pointers are from MmAllocatePhysicalMemory with WRITE_COMBINE.
   auto graphics_system = kernel_state()->emulator()->graphics_system();
   graphics_system->InitializeRingBuffer(ptr, log2_size);

From e6524aa497703cf002e17849660f201dda3b9b06 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sun, 8 Apr 2018 18:02:39 -0500
Subject: [PATCH 06/56] [GPU] Disassemble memexport exports

---
 src/xenia/gpu/shader.h                    |  4 +++
 src/xenia/gpu/shader_translator.cc        | 36 +++++++++++++++++++----
 src/xenia/gpu/shader_translator_disasm.cc |  7 +++++
 3 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/src/xenia/gpu/shader.h b/src/xenia/gpu/shader.h
index 7e0cd3ab2..252ee3078 100644
--- a/src/xenia/gpu/shader.h
+++ b/src/xenia/gpu/shader.h
@@ -31,6 +31,10 @@ enum class InstructionStorageTarget {
   kPosition,
   // Result is stored to the point size export (gl_PointSize).
   kPointSize,
+  // Result is stored as memexport destination address.
+  kExportAddress,
+  // Result is stored to memexport destination data.
+  kExportData,
   // Result is stored to a color target export indexed by storage_index [0-3].
   kColorTarget,
   // Result is stored to the depth export (gl_FragDepth).
diff --git a/src/xenia/gpu/shader_translator.cc b/src/xenia/gpu/shader_translator.cc
index 4634ef34d..1f3e13dbc 100644
--- a/src/xenia/gpu/shader_translator.cc
+++ b/src/xenia/gpu/shader_translator.cc
@@ -1147,14 +1147,15 @@ void ShaderTranslator::ParseAluVectorInstruction(
   } else if (is_vertex_shader()) {
     switch (dest_num) {
       case 32:
+        i.result.storage_target = InstructionStorageTarget::kExportAddress;
+        break;
       case 33:
       case 34:
       case 35:
       case 36:
       case 37:
-        // TODO: Memexport registers
-        i.result.storage_target = InstructionStorageTarget::kNone;
-        i.result.storage_index = 0;
+        i.result.storage_index = dest_num - 33;
+        i.result.storage_target = InstructionStorageTarget::kExportData;
         break;
       case 62:
         i.result.storage_target = InstructionStorageTarget::kPosition;
@@ -1198,14 +1199,15 @@ void ShaderTranslator::ParseAluVectorInstruction(
         i.result.storage_index = 3;
         break;
       case 32:
+        i.result.storage_target = InstructionStorageTarget::kExportAddress;
+        break;
       case 33:
       case 34:
       case 35:
       case 36:
       case 37:
-        // TODO: Memexport registers
-        i.result.storage_target = InstructionStorageTarget::kNone;
-        i.result.storage_index = 0;
+        i.result.storage_index = dest_num - 33;
+        i.result.storage_target = InstructionStorageTarget::kExportData;
         break;
       case 61:
         i.result.storage_target = InstructionStorageTarget::kDepth;
@@ -1303,6 +1305,17 @@ void ShaderTranslator::ParseAluScalarInstruction(
             : InstructionStorageAddressingMode::kStatic;
   } else if (is_vertex_shader()) {
     switch (dest_num) {
+      case 32:
+        i.result.storage_target = InstructionStorageTarget::kExportAddress;
+        break;
+      case 33:
+      case 34:
+      case 35:
+      case 36:
+      case 37:
+        i.result.storage_index = dest_num - 33;
+        i.result.storage_target = InstructionStorageTarget::kExportData;
+        break;
       case 62:
         i.result.storage_target = InstructionStorageTarget::kPosition;
         break;
@@ -1344,6 +1357,17 @@ void ShaderTranslator::ParseAluScalarInstruction(
         i.result.storage_target = InstructionStorageTarget::kColorTarget;
         i.result.storage_index = 3;
         break;
+      case 32:
+        i.result.storage_target = InstructionStorageTarget::kExportAddress;
+        break;
+      case 33:
+      case 34:
+      case 35:
+      case 36:
+      case 37:
+        i.result.storage_index = dest_num - 33;
+        i.result.storage_target = InstructionStorageTarget::kExportData;
+        break;
       case 61:
         i.result.storage_target = InstructionStorageTarget::kDepth;
         break;
diff --git a/src/xenia/gpu/shader_translator_disasm.cc b/src/xenia/gpu/shader_translator_disasm.cc
index b36267fb4..6a2007eaa 100644
--- a/src/xenia/gpu/shader_translator_disasm.cc
+++ b/src/xenia/gpu/shader_translator_disasm.cc
@@ -38,6 +38,13 @@ void DisassembleResultOperand(const InstructionResult& result,
     case InstructionStorageTarget::kPointSize:
       out->Append("oPts");
       break;
+    case InstructionStorageTarget::kExportAddress:
+      out->Append("eA");
+      break;
+    case InstructionStorageTarget::kExportData:
+      out->Append("eM");
+      uses_storage_index = true;
+      break;
     case InstructionStorageTarget::kColorTarget:
       out->AppendFormat("oC");
       uses_storage_index = true;

From 6794b4975c94bee4192265438c861dcff3e2167d Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:06:45 -0500
Subject: [PATCH 07/56] [SPIR-V] Use texture sample calls with constant offset

---
 src/xenia/gpu/spirv_shader_translator.cc | 124 +++++++++++++----------
 src/xenia/gpu/spirv_shader_translator.h  |   2 +-
 2 files changed, 69 insertions(+), 57 deletions(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 376d04f17..ec2f845d7 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -67,6 +67,7 @@ void SpirvShaderTranslator::StartTranslation() {
   vec2_int_type_ = b.makeVectorType(int_type_, 2);
   vec2_uint_type_ = b.makeVectorType(uint_type_, 2);
   vec2_float_type_ = b.makeVectorType(float_type_, 2);
+  vec3_int_type_ = b.makeVectorType(int_type_, 3);
   vec3_float_type_ = b.makeVectorType(float_type_, 3);
   vec4_float_type_ = b.makeVectorType(float_type_, 4);
   vec4_int_type_ = b.makeVectorType(int_type_, 4);
@@ -1786,68 +1787,56 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction(
                               tex_[dim_idx], std::vector<Id>({texture_index}));
       auto texture = b.createLoad(texture_ptr);
 
-      spv::Id size = 0;
-      if (instr.attributes.offset_x || instr.attributes.offset_y) {
-        auto image =
-            b.createUnaryOp(spv::OpImage, b.getImageType(texture), texture);
-
-        spv::Builder::TextureParameters params;
-        std::memset(&params, 0, sizeof(params));
-        params.sampler = image;
-        params.lod = b.makeIntConstant(0);
-        size = b.createTextureQueryCall(spv::Op::OpImageQuerySizeLod, params,
-                                        false);
-
-        if (instr.dimension == TextureDimension::k1D) {
-          size = b.createUnaryOp(spv::Op::OpConvertSToF, float_type_, size);
-        } else if (instr.dimension == TextureDimension::k2D) {
-          size =
-              b.createUnaryOp(spv::Op::OpConvertSToF, vec2_float_type_, size);
-        } else if (instr.dimension == TextureDimension::k3D) {
-          size =
-              b.createUnaryOp(spv::Op::OpConvertSToF, vec3_float_type_, size);
-        } else if (instr.dimension == TextureDimension::kCube) {
-          size =
-              b.createUnaryOp(spv::Op::OpConvertSToF, vec4_float_type_, size);
-        }
-      }
-
-      if (instr.dimension == TextureDimension::k1D) {
-        src = b.createCompositeExtract(src, float_type_, 0);
-        if (instr.attributes.offset_x) {
-          auto offset = b.makeFloatConstant(instr.attributes.offset_x + 0.5f);
-          offset = b.createBinOp(spv::Op::OpFDiv, float_type_, offset, size);
-          src = b.createBinOp(spv::Op::OpFAdd, float_type_, src, offset);
-        }
-
-        // https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx
-        // "Because the runtime does not support 1D textures, the compiler will
-        //  use a 2D texture with the knowledge that the y-coordinate is
-        //  unimportant."
-        src = b.createCompositeConstruct(
-            vec2_float_type_,
-            std::vector<Id>({src, b.makeFloatConstant(0.0f)}));
-      } else if (instr.dimension == TextureDimension::k2D) {
-        src = b.createRvalueSwizzle(spv::NoPrecision, vec2_float_type_, src,
-                                    std::vector<uint32_t>({0, 1}));
-        if (instr.attributes.offset_x || instr.attributes.offset_y) {
-          auto offset = b.makeCompositeConstant(
-              vec2_float_type_,
-              std::vector<Id>(
-                  {b.makeFloatConstant(instr.attributes.offset_x + 0.5f),
-                   b.makeFloatConstant(instr.attributes.offset_y + 0.5f)}));
-          offset =
-              b.createBinOp(spv::Op::OpFDiv, vec2_float_type_, offset, size);
-          src = b.createBinOp(spv::Op::OpFAdd, vec2_float_type_, src, offset);
-        }
-      }
-
       spv::Builder::TextureParameters params = {0};
       params.coords = src;
       params.sampler = texture;
       if (instr.attributes.use_register_lod) {
         params.lod = b.createLoad(lod_);
       }
+      if (instr.attributes.offset_x || instr.attributes.offset_y ||
+          instr.attributes.offset_z) {
+        float offset_x = instr.attributes.offset_x;
+        float offset_y = instr.attributes.offset_y;
+        float offset_z = instr.attributes.offset_z;
+
+        // Round numbers away from zero. No effect if offset is 0.
+        offset_x += instr.attributes.offset_x < 0 ? -0.5f : 0.5f;
+        offset_y += instr.attributes.offset_y < 0 ? -0.5f : 0.5f;
+        offset_z += instr.attributes.offset_z < 0 ? -0.5f : 0.5f;
+
+        Id offset = 0;
+        switch (instr.dimension) {
+          case TextureDimension::k1D: {
+            // https://msdn.microsoft.com/en-us/library/windows/desktop/bb944006.aspx
+            // "Because the runtime does not support 1D textures, the compiler
+            // will use a 2D texture with the knowledge that the y-coordinate is
+            // unimportant."
+            offset = b.makeCompositeConstant(
+                vec2_int_type_,
+                {b.makeIntConstant(int(offset_x)), b.makeIntConstant(0)});
+          } break;
+          case TextureDimension::k2D: {
+            offset = b.makeCompositeConstant(
+                vec2_int_type_, {b.makeIntConstant(int(offset_x)),
+                                 b.makeIntConstant(int(offset_y))});
+          } break;
+          case TextureDimension::k3D: {
+            offset = b.makeCompositeConstant(
+                vec3_int_type_, {b.makeIntConstant(int(offset_x)),
+                                 b.makeIntConstant(int(offset_y)),
+                                 b.makeIntConstant(int(offset_z))});
+          } break;
+          case TextureDimension::kCube: {
+            // FIXME(DrChat): Is this the correct dimension? I forget
+            offset = b.makeCompositeConstant(
+                vec3_int_type_, {b.makeIntConstant(int(offset_x)),
+                                 b.makeIntConstant(int(offset_y)),
+                                 b.makeIntConstant(int(offset_z))});
+          } break;
+        }
+
+        params.offset = offset;
+      }
 
       dest =
           b.createTextureCall(spv::NoPrecision, vec4_float_type_, false, false,
@@ -1908,6 +1897,28 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction(
       }
     } break;
 
+    case FetchOpcode::kGetTextureComputedLod: {
+      // TODO(DrChat): Verify if this implementation is correct.
+      // This is only valid in pixel shaders.
+      assert_true(is_pixel_shader());
+
+      auto texture_index =
+          b.makeUintConstant(tex_binding_map_[instr.operands[1].storage_index]);
+      auto texture_ptr =
+          b.createAccessChain(spv::StorageClass::StorageClassUniformConstant,
+                              tex_[dim_idx], std::vector<Id>({texture_index}));
+      auto texture = b.createLoad(texture_ptr);
+
+      spv::Builder::TextureParameters params = {};
+      params.sampler = texture;
+      params.coords = src;
+      auto lod =
+          b.createTextureQueryCall(spv::Op::OpImageQueryLod, params, false);
+
+      dest = b.createCompositeExtract(lod, float_type_, 1);
+      dest = b.smearScalar(spv::NoPrecision, dest, vec4_float_type_);
+    } break;
+
     case FetchOpcode::kSetTextureLod: {
       // <lod register> = src1.x (MIP level)
       // ... immediately after
@@ -3268,6 +3279,7 @@ void SpirvShaderTranslator::StoreToResult(Id source_value_id,
       storage_offsets.push_back(0);
       storage_array = false;
       break;
+    default:
     case InstructionStorageTarget::kNone:
       assert_unhandled_case(result.storage_target);
       break;
diff --git a/src/xenia/gpu/spirv_shader_translator.h b/src/xenia/gpu/spirv_shader_translator.h
index ec822e8e2..b55f9a55a 100644
--- a/src/xenia/gpu/spirv_shader_translator.h
+++ b/src/xenia/gpu/spirv_shader_translator.h
@@ -132,7 +132,7 @@ class SpirvShaderTranslator : public ShaderTranslator {
 
   // Types.
   spv::Id float_type_ = 0, bool_type_ = 0, int_type_ = 0, uint_type_ = 0;
-  spv::Id vec2_int_type_ = 0, vec2_uint_type_ = 0;
+  spv::Id vec2_int_type_ = 0, vec2_uint_type_ = 0, vec3_int_type_ = 0;
   spv::Id vec2_float_type_ = 0, vec3_float_type_ = 0, vec4_float_type_ = 0;
   spv::Id vec4_int_type_ = 0, vec4_uint_type_ = 0;
   spv::Id vec2_bool_type_ = 0, vec3_bool_type_ = 0, vec4_bool_type_ = 0;

From abdc0ff05a94c26edc66381e01924383911db957 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:07:14 -0500
Subject: [PATCH 08/56] [GPU] Document first parameter of eA (export address)

---
 src/xenia/gpu/shader.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/xenia/gpu/shader.h b/src/xenia/gpu/shader.h
index 252ee3078..ebea8b9f3 100644
--- a/src/xenia/gpu/shader.h
+++ b/src/xenia/gpu/shader.h
@@ -32,6 +32,7 @@ enum class InstructionStorageTarget {
   // Result is stored to the point size export (gl_PointSize).
   kPointSize,
   // Result is stored as memexport destination address.
+  // [physical >> 2, ??, ??, ??]
   kExportAddress,
   // Result is stored to memexport destination data.
   kExportData,

From 399e1fac2a58b694c9b050b7d32d2e162acdc4e7 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:09:21 -0500
Subject: [PATCH 09/56] [Vulkan] Gracefully fail on copy if a target format is
 unsupported

---
 src/xenia/gpu/vulkan/texture_cache.cc            |  8 +++-----
 src/xenia/gpu/vulkan/texture_cache.h             |  1 +
 src/xenia/gpu/vulkan/vulkan_command_processor.cc | 12 +++++++++++-
 3 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index 558e796ba..9d433f6f1 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -277,7 +277,6 @@ TextureCache::Texture* TextureCache::AllocateTexture(
             static_cast<VkFormatFeatureFlagBits>(required_flags &
                                                  ~props.optimalTilingFeatures))
             .c_str());
-    assert_always();
   }
 
   if (texture_info.dimension != Dimension::kCube &&
@@ -331,6 +330,7 @@ TextureCache::Texture* TextureCache::AllocateTexture(
   texture->alloc = alloc;
   texture->alloc_info = vma_info;
   texture->framebuffer = nullptr;
+  texture->usage_flags = image_info.usage;
   texture->access_watch_handle = 0;
   texture->texture_info = texture_info;
   return texture;
@@ -410,8 +410,7 @@ TextureCache::Texture* TextureCache::DemandResolveTexture(
   // No texture at this location. Make a new one.
   auto texture = AllocateTexture(texture_info, required_flags);
   if (!texture) {
-    // Failed to allocate texture (out of memory?)
-    assert_always();
+    // Failed to allocate texture (out of memory)
     XELOGE("Vulkan Texture Cache: Failed to allocate texture!");
     return nullptr;
   }
@@ -463,8 +462,7 @@ TextureCache::Texture* TextureCache::Demand(const TextureInfo& texture_info,
   // Create a new texture and cache it.
   auto texture = AllocateTexture(texture_info);
   if (!texture) {
-    // Failed to allocate texture (out of memory?)
-    assert_always();
+    // Failed to allocate texture (out of memory)
     XELOGE("Vulkan Texture Cache: Failed to allocate texture!");
     return nullptr;
   }
diff --git a/src/xenia/gpu/vulkan/texture_cache.h b/src/xenia/gpu/vulkan/texture_cache.h
index af1e10447..6be4a6660 100644
--- a/src/xenia/gpu/vulkan/texture_cache.h
+++ b/src/xenia/gpu/vulkan/texture_cache.h
@@ -47,6 +47,7 @@ class TextureCache {
     VmaAllocation alloc;
     VmaAllocationInfo alloc_info;
     VkFramebuffer framebuffer;  // Blit target frame buffer.
+    VkImageUsageFlags usage_flags;
 
     uintptr_t access_watch_handle;
     bool pending_invalidation;
diff --git a/src/xenia/gpu/vulkan/vulkan_command_processor.cc b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
index 235aa81ff..b4020bea8 100644
--- a/src/xenia/gpu/vulkan/vulkan_command_processor.cc
+++ b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
@@ -1024,7 +1024,17 @@ bool VulkanCommandProcessor::IssueCopy() {
                               std::max(1u, dest_logical_height), &texture_info);
 
   auto texture = texture_cache_->DemandResolveTexture(texture_info);
-  assert_not_null(texture);
+  if (!texture) {
+    // Out of memory.
+    return false;
+  }
+
+  if (!(texture->usage_flags & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))) {
+    // Resolve image doesn't support drawing, and we don't support conversion.
+    return false;
+  }
+
   texture->in_flight_fence = current_batch_fence_;
 
   // For debugging purposes only (trace viewer)

From 39083acdcb97747cae4b0ac52e4792776301a8c8 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:09:56 -0500
Subject: [PATCH 10/56] [Vulkan] Bump up maximum number of vertex buffers

---
 src/xenia/gpu/vulkan/buffer_cache.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/vulkan/buffer_cache.cc b/src/xenia/gpu/vulkan/buffer_cache.cc
index f975ec09f..c4a85d347 100644
--- a/src/xenia/gpu/vulkan/buffer_cache.cc
+++ b/src/xenia/gpu/vulkan/buffer_cache.cc
@@ -147,10 +147,10 @@ VkResult xe::gpu::vulkan::BufferCache::CreateVertexDescriptorPool() {
   std::vector<VkDescriptorPoolSize> pool_sizes;
   pool_sizes.push_back({
       VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-      65536,
+      32 * 16384,
   });
   vertex_descriptor_pool_ =
-      std::make_unique<ui::vulkan::DescriptorPool>(*device_, 65536, pool_sizes);
+      std::make_unique<ui::vulkan::DescriptorPool>(*device_, 32 * 16384, pool_sizes);
 
   // 32 storage buffers available to vertex shader.
   // TODO(DrChat): In the future, this could hold memexport staging data.

From f02f192f2bcd613edfb84a5e195571becad302cc Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:10:50 -0500
Subject: [PATCH 11/56] [Xboxkrnl] Document a couple parameters in
 VdInitializeEngines

---
 src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
index 3491b272d..92f9ac2d3 100644
--- a/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
+++ b/src/xenia/kernel/xboxkrnl/xboxkrnl_video.cc
@@ -160,13 +160,13 @@ DECLARE_XBOXKRNL_EXPORT(VdSetDisplayModeOverride,
                         ExportTag::kVideo | ExportTag::kStub);
 
 dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback,
-                                   lpvoid_t arg, lpunknown_t unk2_ptr,
-                                   lpunknown_t unk3_ptr) {
+                                   lpvoid_t arg, lpdword_t pfp_ptr,
+                                   lpdword_t me_ptr) {
   // r3 = 0x4F810000
   // r4 = function ptr (cleanup callback?)
   // r5 = function arg
-  // r6 = register init cmds(?)
-  // r7 = gpu init cmds(?)
+  // r6 = PFP Microcode
+  // r7 = ME Microcode
   return 1;
 }
 DECLARE_XBOXKRNL_EXPORT(VdInitializeEngines,

From 0f0d600a5b3e19bc2a3a6c79f05d815744c15bb7 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 13 Apr 2018 21:45:47 -0500
Subject: [PATCH 12/56] Fix Travis

---
 src/xenia/gpu/glsl_shader_translator.cc | 1 +
 src/xenia/gpu/vulkan/buffer_cache.cc    | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/glsl_shader_translator.cc b/src/xenia/gpu/glsl_shader_translator.cc
index 2f89ab3df..32d26c1a2 100644
--- a/src/xenia/gpu/glsl_shader_translator.cc
+++ b/src/xenia/gpu/glsl_shader_translator.cc
@@ -959,6 +959,7 @@ void GlslShaderTranslator::EmitStoreResult(const InstructionResult& result,
     case InstructionStorageTarget::kDepth:
       EmitSourceDepth("gl_FragDepth");
       break;
+    default:
     case InstructionStorageTarget::kNone:
       return;
   }
diff --git a/src/xenia/gpu/vulkan/buffer_cache.cc b/src/xenia/gpu/vulkan/buffer_cache.cc
index c4a85d347..60a2219d7 100644
--- a/src/xenia/gpu/vulkan/buffer_cache.cc
+++ b/src/xenia/gpu/vulkan/buffer_cache.cc
@@ -149,8 +149,8 @@ VkResult xe::gpu::vulkan::BufferCache::CreateVertexDescriptorPool() {
       VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
       32 * 16384,
   });
-  vertex_descriptor_pool_ =
-      std::make_unique<ui::vulkan::DescriptorPool>(*device_, 32 * 16384, pool_sizes);
+  vertex_descriptor_pool_ = std::make_unique<ui::vulkan::DescriptorPool>(
+      *device_, 32 * 16384, pool_sizes);
 
   // 32 storage buffers available to vertex shader.
   // TODO(DrChat): In the future, this could hold memexport staging data.

From 303539af22a59f7cb867924451da444efc8ce5c7 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sat, 14 Apr 2018 15:32:18 -0500
Subject: [PATCH 13/56] [SPIR-V] Fix incorrect dst implementation (incorrect
 extraction indices)

---
 src/xenia/gpu/spirv_shader_translator.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index ec2f845d7..a4aa4245b 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -2221,8 +2221,8 @@ void SpirvShaderTranslator::ProcessVectorAluInstruction(
       auto src1_y = b.createCompositeExtract(sources[1], float_type_, 1);
       auto dst_y = b.createBinOp(spv::Op::OpFMul, float_type_, src0_y, src1_y);
 
-      auto src0_z = b.createCompositeExtract(sources[0], float_type_, 3);
-      auto src1_w = b.createCompositeExtract(sources[1], float_type_, 4);
+      auto src0_z = b.createCompositeExtract(sources[0], float_type_, 2);
+      auto src1_w = b.createCompositeExtract(sources[1], float_type_, 3);
       dest = b.createCompositeConstruct(
           vec4_float_type_,
           std::vector<Id>({b.makeFloatConstant(1.f), dst_y, src0_z, src1_w}));

From d914791afea408f9e000e3fc5b4b83f218a67772 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sat, 14 Apr 2018 15:39:48 -0500
Subject: [PATCH 14/56] [SPIR-V] Fix SetTextureLOD

---
 src/xenia/gpu/spirv_shader_translator.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index a4aa4245b..6fd80c26e 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -1923,7 +1923,7 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction(
       // <lod register> = src1.x (MIP level)
       // ... immediately after
       // tfetch UseRegisterLOD=true
-      b.createStore(b.createCompositeExtract(src, float_type_, 0), lod_);
+      b.createStore(src, lod_);
     } break;
 
     default:

From f8319ec12fffac03f2ea3d87f436f5b9e9e3c9a2 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sat, 14 Apr 2018 17:33:24 -0500
Subject: [PATCH 15/56] [Base] Support sign-extension in bitfield

---
 src/xenia/base/bit_field.h                    | 24 ++++++++++++-------
 .../gpu/vulkan/vulkan_command_processor.cc    | 11 ++-------
 2 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/xenia/base/bit_field.h b/src/xenia/base/bit_field.h
index 034f43d9e..98a8bfbf8 100644
--- a/src/xenia/base/bit_field.h
+++ b/src/xenia/base/bit_field.h
@@ -19,20 +19,28 @@ namespace xe {
 // Bitfield, where position starts at the LSB.
 template <typename T, size_t position, size_t n_bits>
 struct bf {
-  bf() = default;
-  inline operator T() const { return value(); }
-
-  inline T value() const {
-    return static_cast<T>((storage & mask()) >> position);
-  }
-
   // For enum values, we strip them down to an underlying type.
   typedef
       typename std::conditional<std::is_enum<T>::value, std::underlying_type<T>,
                                 std::remove_reference<T>>::type::type
           value_type;
+
+  bf() = default;
+  inline operator T() const { return value(); }
+
+  inline T value() const {
+    auto value = (storage & mask()) >> position;
+    if (std::is_signed<value_type>::value) {
+      // If the value is signed, sign-extend it.
+      value_type sign_mask = value_type(1) << (n_bits - 1);
+      value = (sign_mask ^ value) - sign_mask;
+    }
+
+    return static_cast<T>(value);
+  }
+
   inline value_type mask() const {
-    return (((value_type)~0) >> (8 * sizeof(value_type) - n_bits)) << position;
+    return ((value_type(1) << n_bits) - 1) << position;
   }
 
   value_type storage;
diff --git a/src/xenia/gpu/vulkan/vulkan_command_processor.cc b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
index b4020bea8..52f5ba7fc 100644
--- a/src/xenia/gpu/vulkan/vulkan_command_processor.cc
+++ b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
@@ -912,15 +912,8 @@ bool VulkanCommandProcessor::IssueCopy() {
   // vtx_window_offset_enable
   assert_true(regs[XE_GPU_REG_PA_SU_SC_MODE_CNTL].u32 & 0x00010000);
   uint32_t window_offset = regs[XE_GPU_REG_PA_SC_WINDOW_OFFSET].u32;
-  int16_t window_offset_x = window_offset & 0x7FFF;
-  int16_t window_offset_y = (window_offset >> 16) & 0x7FFF;
-  // Sign-extension
-  if (window_offset_x & 0x4000) {
-    window_offset_x |= 0x8000;
-  }
-  if (window_offset_y & 0x4000) {
-    window_offset_y |= 0x8000;
-  }
+  int32_t window_offset_x = window_regs->window_offset.window_x_offset;
+  int32_t window_offset_y = window_regs->window_offset.window_y_offset;
 
   uint32_t dest_texel_size = uint32_t(GetTexelSize(copy_dest_format));
 

From 6ca771d26f2b377357d5c8ab26e31574f4c5c3a5 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Sat, 14 Apr 2018 17:51:57 -0500
Subject: [PATCH 16/56] [Vulkan] Handle window scissor window_offset_disable

---
 src/xenia/gpu/vulkan/pipeline_cache.cc | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index 4d5594276..cc7f8a627 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -593,8 +593,11 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
     int32_t ws_y = (regs.pa_sc_window_scissor_tl >> 16) & 0x7FFF;
     int32_t ws_w = (regs.pa_sc_window_scissor_br & 0x7FFF) - ws_x;
     int32_t ws_h = ((regs.pa_sc_window_scissor_br >> 16) & 0x7FFF) - ws_y;
-    ws_x += window_offset_x;
-    ws_y += window_offset_y;
+    if (!(regs.pa_sc_window_scissor_tl & 0x80000000)) {
+      // ! WINDOW_OFFSET_DISABLE
+      ws_x += window_offset_x;
+      ws_y += window_offset_y;
+    }
 
     int32_t adj_x = ws_x - std::max(ws_x, 0);
     int32_t adj_y = ws_y - std::max(ws_y, 0);

From 25f93a171c37881cb45c660f5713159f3fc3268e Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 11:08:24 -0500
Subject: [PATCH 17/56] [Vulkan] Support optional vertex window offset

---
 src/xenia/gpu/vulkan/pipeline_cache.cc | 35 +++++++++++++-------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index cc7f8a627..b71b70c9d 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -569,17 +569,13 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
   // http://ftp.tku.edu.tw/NetBSD/NetBSD-current/xsrc/external/mit/xf86-video-ati/dist/src/r600_reg_auto_r6xx.h
   // See r200UpdateWindow:
   // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c
-  int16_t window_offset_x = 0;
-  int16_t window_offset_y = 0;
-  if ((regs.pa_su_sc_mode_cntl >> 16) & 1) {
-    window_offset_x = regs.pa_sc_window_offset & 0x7FFF;
-    window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF;
-    if (window_offset_x & 0x4000) {
-      window_offset_x |= 0x8000;
-    }
-    if (window_offset_y & 0x4000) {
-      window_offset_y |= 0x8000;
-    }
+  int16_t window_offset_x = regs.pa_sc_window_offset & 0x7FFF;
+  int16_t window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF;
+  if (window_offset_x & 0x4000) {
+    window_offset_x |= 0x8000;
+  }
+  if (window_offset_y & 0x4000) {
+    window_offset_y |= 0x8000;
   }
 
   // VK_DYNAMIC_STATE_SCISSOR
@@ -660,6 +656,11 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
               vport_zscale_enable == vport_xoffset_enable ==
               vport_yoffset_enable == vport_zoffset_enable);
 
+  int16_t vtx_window_offset_x =
+      (regs.pa_su_sc_mode_cntl >> 16) & 1 ? window_offset_x : 0;
+  int16_t vtx_window_offset_y =
+      (regs.pa_su_sc_mode_cntl >> 16) & 1 ? window_offset_y : 0;
+
   float vpw, vph, vpx, vpy;
   if (vport_xscale_enable) {
     float vox = vport_xoffset_enable ? regs.pa_cl_vport_xoffset : 0;
@@ -670,13 +671,13 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
     window_width_scalar = window_height_scalar = 1;
     vpw = 2 * window_width_scalar * vsx;
     vph = -2 * window_height_scalar * vsy;
-    vpx = window_width_scalar * vox - vpw / 2 + window_offset_x;
-    vpy = window_height_scalar * voy - vph / 2 + window_offset_y;
+    vpx = window_width_scalar * vox - vpw / 2 + vtx_window_offset_x;
+    vpy = window_height_scalar * voy - vph / 2 + vtx_window_offset_y;
   } else {
     vpw = 2 * 2560.0f * window_width_scalar;
     vph = 2 * 2560.0f * window_height_scalar;
-    vpx = -2560.0f * window_width_scalar + window_offset_x;
-    vpy = -2560.0f * window_height_scalar + window_offset_y;
+    vpx = -2560.0f * window_width_scalar + vtx_window_offset_x;
+    vpy = -2560.0f * window_height_scalar + vtx_window_offset_y;
   }
 
   if (viewport_state_dirty) {
@@ -769,10 +770,10 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
                 program_cntl.vs_export_mode == 7);
     assert_false(program_cntl.gen_index_vtx);
 
-    SpirvPushConstants push_constants;
+    SpirvPushConstants push_constants = {};
 
     // Done in VS, no need to flush state.
-    if ((regs.pa_cl_vte_cntl & (1 << 0)) > 0) {
+    if (vport_xscale_enable) {
       push_constants.window_scale[0] = 1.0f;
       push_constants.window_scale[1] = -1.0f;
     } else {

From b90465e2e59277403b0ad400ec143dcd3a474a20 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 12:54:50 -0500
Subject: [PATCH 18/56] [Vulkan] Halve the viewport dimensions when viewport
 scaling is disabled (10240 -> 5120) The negative part of the viewport is
 unused, so hijack the 2 unused parameters of the window scale to use as an
 offset

---
 src/xenia/gpu/spirv_shader_translator.cc | 10 +++++++++-
 src/xenia/gpu/vulkan/pipeline_cache.cc   | 16 ++++++++++------
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 6fd80c26e..384190124 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -532,8 +532,16 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() {
     // pos.xy *= window_scale.xy
     auto p_scaled =
         b.createBinOp(spv::Op::OpFMul, vec4_float_type_, p, window_scale);
+
+    // Apply window offset
+    // pos.xy += window_scale.zw
+    auto window_offset = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_,
+                                    {window_scale, window_scale, 2, 3, 0, 1});
+    auto p_offset = b.createBinOp(spv::Op::OpFAdd, vec4_float_type_, p_scaled,
+                                  window_offset);
+
     p = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_,
-                   {p, p_scaled, 4, 5, 2, 3});
+                   {p, p_offset, 4, 5, 2, 3});
 
     b.createStore(p, pos_);
   } else {
diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index b71b70c9d..b1eeec71e 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -674,10 +674,11 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
     vpx = window_width_scalar * vox - vpw / 2 + vtx_window_offset_x;
     vpy = window_height_scalar * voy - vph / 2 + vtx_window_offset_y;
   } else {
-    vpw = 2 * 2560.0f * window_width_scalar;
-    vph = 2 * 2560.0f * window_height_scalar;
-    vpx = -2560.0f * window_width_scalar + vtx_window_offset_x;
-    vpy = -2560.0f * window_height_scalar + vtx_window_offset_y;
+    // TODO(DrChat): This should be the width/height of the target picture
+    vpw = 2560.0f * window_width_scalar;
+    vph = 2560.0f * window_height_scalar;
+    vpx = vtx_window_offset_x;
+    vpy = vtx_window_offset_y;
   }
 
   if (viewport_state_dirty) {
@@ -776,12 +777,15 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
     if (vport_xscale_enable) {
       push_constants.window_scale[0] = 1.0f;
       push_constants.window_scale[1] = -1.0f;
+      push_constants.window_scale[2] = 0.f;
+      push_constants.window_scale[3] = 0.f;
     } else {
+      // 1 / unscaled viewport w/h
       push_constants.window_scale[0] = 1.0f / 2560.0f;
       push_constants.window_scale[1] = 1.0f / 2560.0f;
+      push_constants.window_scale[2] = -1.f;
+      push_constants.window_scale[3] = -1.f;
     }
-    push_constants.window_scale[2] = vpw;
-    push_constants.window_scale[3] = vph;
 
     // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
     // VTX_XY_FMT = true: the incoming XY have already been multiplied by 1/W0.

From 18d9efc93b20645c94f8193dc69affee4de719b8 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 13:02:05 -0500
Subject: [PATCH 19/56] [Vulkan] Bump down BufferCache alignment

---
 src/xenia/gpu/vulkan/buffer_cache.cc | 5 +++--
 src/xenia/gpu/vulkan/render_cache.cc | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/xenia/gpu/vulkan/buffer_cache.cc b/src/xenia/gpu/vulkan/buffer_cache.cc
index 60a2219d7..23e93e67a 100644
--- a/src/xenia/gpu/vulkan/buffer_cache.cc
+++ b/src/xenia/gpu/vulkan/buffer_cache.cc
@@ -104,7 +104,7 @@ BufferCache::BufferCache(RegisterFile* register_file, Memory* memory,
       device_,
       VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
           VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
-      capacity, 4096);
+      capacity, 256);
 }
 
 BufferCache::~BufferCache() { Shutdown(); }
@@ -287,7 +287,8 @@ VkResult BufferCache::CreateConstantDescriptorSet() {
 
   return VK_SUCCESS;
 }
-void xe::gpu::vulkan::BufferCache::FreeConstantDescriptorSet() {
+
+void BufferCache::FreeConstantDescriptorSet() {
   if (constant_descriptor_set_) {
     vkFreeDescriptorSets(*device_, constant_descriptor_pool_, 1,
                          &constant_descriptor_set_);
diff --git a/src/xenia/gpu/vulkan/render_cache.cc b/src/xenia/gpu/vulkan/render_cache.cc
index 1991ee2b4..4f9072adb 100644
--- a/src/xenia/gpu/vulkan/render_cache.cc
+++ b/src/xenia/gpu/vulkan/render_cache.cc
@@ -201,7 +201,7 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
 
   device->DbgSetObjectName(
       reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-      xe::format_string("%.8X pitch %.8X(%d)", key.tile_offset, key.tile_width,
+      xe::format_string("RT %.8X %.8X(%d)", key.tile_offset, key.tile_width,
                         key.tile_width));
 
   VkMemoryRequirements memory_requirements;

From 27c840fa9135c9057602ed47820b27d34caedade Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 15:44:52 -0500
Subject: [PATCH 20/56] [Vulkan] Fixup window offset calculation

---
 src/xenia/gpu/spirv_shader_translator.cc | 16 ++++++++--------
 src/xenia/gpu/vulkan/pipeline_cache.cc   | 17 ++++++-----------
 2 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 384190124..0387ad5fe 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -528,20 +528,20 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() {
     // Reinsert w
     p = b.createCompositeInsert(p_w, p, vec4_float_type_, 3);
 
-    // Apply window scaling
-    // pos.xy *= window_scale.xy
-    auto p_scaled =
-        b.createBinOp(spv::Op::OpFMul, vec4_float_type_, p, window_scale);
-
     // Apply window offset
     // pos.xy += window_scale.zw
     auto window_offset = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_,
                                     {window_scale, window_scale, 2, 3, 0, 1});
-    auto p_offset = b.createBinOp(spv::Op::OpFAdd, vec4_float_type_, p_scaled,
-                                  window_offset);
+    auto p_offset =
+        b.createBinOp(spv::Op::OpFAdd, vec4_float_type_, p, window_offset);
+
+    // Apply window scaling
+    // pos.xy *= window_scale.xy
+    auto p_scaled = b.createBinOp(spv::Op::OpFMul, vec4_float_type_, p_offset,
+                                  window_scale);
 
     p = b.createOp(spv::Op::OpVectorShuffle, vec4_float_type_,
-                   {p, p_offset, 4, 5, 2, 3});
+                   {p, p_scaled, 4, 5, 2, 3});
 
     b.createStore(p, pos_);
   } else {
diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index b1eeec71e..e7c18f066 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -682,15 +682,10 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
   }
 
   if (viewport_state_dirty) {
-    // float texel_offset_x = regs.pa_su_sc_vtx_cntl & 0x01 ? 0.5f : 0.f;
-    // float texel_offset_y = regs.pa_su_sc_vtx_cntl & 0x01 ? 0.5f : 0.f;
-    float texel_offset_x = 0.f;
-    float texel_offset_y = 0.f;
-
     VkViewport viewport_rect;
     std::memset(&viewport_rect, 0, sizeof(VkViewport));
-    viewport_rect.x = vpx + texel_offset_x;
-    viewport_rect.y = vpy + texel_offset_y;
+    viewport_rect.x = vpx;
+    viewport_rect.y = vpy;
     viewport_rect.width = vpw;
     viewport_rect.height = vph;
 
@@ -781,10 +776,10 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
       push_constants.window_scale[3] = 0.f;
     } else {
       // 1 / unscaled viewport w/h
-      push_constants.window_scale[0] = 1.0f / 2560.0f;
-      push_constants.window_scale[1] = 1.0f / 2560.0f;
-      push_constants.window_scale[2] = -1.f;
-      push_constants.window_scale[3] = -1.f;
+      push_constants.window_scale[0] = 1.0f / (1280.f * window_width_scalar);
+      push_constants.window_scale[1] = 1.0f / (1280.f * window_height_scalar);
+      push_constants.window_scale[2] = (-1280.f * window_width_scalar) + 0.5f;
+      push_constants.window_scale[3] = (-1280.f * window_height_scalar) + 0.5f;
     }
 
     // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf

From 521b9eb5c52076df1a1c3bbff7888dc821ccbdd4 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 18:27:23 -0500
Subject: [PATCH 21/56] [Vulkan] Fix window scale and offset calculation

---
 src/xenia/gpu/vulkan/pipeline_cache.cc | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/xenia/gpu/vulkan/pipeline_cache.cc b/src/xenia/gpu/vulkan/pipeline_cache.cc
index e7c18f066..e4ba55ba7 100644
--- a/src/xenia/gpu/vulkan/pipeline_cache.cc
+++ b/src/xenia/gpu/vulkan/pipeline_cache.cc
@@ -675,8 +675,8 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
     vpy = window_height_scalar * voy - vph / 2 + vtx_window_offset_y;
   } else {
     // TODO(DrChat): This should be the width/height of the target picture
-    vpw = 2560.0f * window_width_scalar;
-    vph = 2560.0f * window_height_scalar;
+    vpw = 2560.0f;
+    vph = 2560.0f;
     vpx = vtx_window_offset_x;
     vpy = vtx_window_offset_y;
   }
@@ -776,10 +776,10 @@ bool PipelineCache::SetDynamicState(VkCommandBuffer command_buffer,
       push_constants.window_scale[3] = 0.f;
     } else {
       // 1 / unscaled viewport w/h
-      push_constants.window_scale[0] = 1.0f / (1280.f * window_width_scalar);
-      push_constants.window_scale[1] = 1.0f / (1280.f * window_height_scalar);
-      push_constants.window_scale[2] = (-1280.f * window_width_scalar) + 0.5f;
-      push_constants.window_scale[3] = (-1280.f * window_height_scalar) + 0.5f;
+      push_constants.window_scale[0] = window_width_scalar / 1280.f;
+      push_constants.window_scale[1] = window_height_scalar / 1280.f;
+      push_constants.window_scale[2] = (-1280.f / window_width_scalar) + 0.5f;
+      push_constants.window_scale[3] = (-1280.f / window_height_scalar) + 0.5f;
     }
 
     // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf

From 0cff91692ea0cea151ea6532e8c7d645da67aac8 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 16 Apr 2018 22:08:03 -0500
Subject: [PATCH 22/56] [Vulkan] Propagate errors in the render cache

---
 src/xenia/gpu/vulkan/render_cache.cc | 140 ++++++++++++++++++---------
 src/xenia/gpu/vulkan/render_cache.h  |   7 +-
 2 files changed, 98 insertions(+), 49 deletions(-)

diff --git a/src/xenia/gpu/vulkan/render_cache.cc b/src/xenia/gpu/vulkan/render_cache.cc
index 4f9072adb..2b7d20a7b 100644
--- a/src/xenia/gpu/vulkan/render_cache.cc
+++ b/src/xenia/gpu/vulkan/render_cache.cc
@@ -87,6 +87,8 @@ class CachedFramebuffer {
   CachedTileView* color_attachments[4] = {nullptr};
   // Reference to depth/stencil attachment, if used.
   CachedTileView* depth_stencil_attachment = nullptr;
+  // Associated render pass
+  VkRenderPass render_pass = nullptr;
 
   CachedFramebuffer(VkDevice device, VkRenderPass render_pass,
                     uint32_t surface_width, uint32_t surface_height,
@@ -94,6 +96,8 @@ class CachedFramebuffer {
                     CachedTileView* target_depth_stencil_attachment);
   ~CachedFramebuffer();
 
+  VkResult Initialize();
+
   bool IsCompatible(const RenderConfiguration& desired_config) const;
 
  private:
@@ -117,6 +121,8 @@ class CachedRenderPass {
   CachedRenderPass(VkDevice device, const RenderConfiguration& desired_config);
   ~CachedRenderPass();
 
+  VkResult Initialize();
+
   bool IsCompatible(const RenderConfiguration& desired_config) const;
 
  private:
@@ -124,10 +130,21 @@ class CachedRenderPass {
 };
 
 CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
-                               VkCommandBuffer command_buffer,
                                VkDeviceMemory edram_memory,
                                TileViewKey view_key)
-    : device_(*device), key(std::move(view_key)) {
+    : device_(device), key(std::move(view_key)) {}
+
+CachedTileView::~CachedTileView() {
+  VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view, nullptr);
+  VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_depth, nullptr);
+  VK_SAFE_DESTROY(vkDestroyImageView, *device_, image_view_stencil, nullptr);
+  VK_SAFE_DESTROY(vkDestroyImage, *device_, image, nullptr);
+  VK_SAFE_DESTROY(vkFreeMemory, *device_, memory, nullptr);
+}
+
+VkResult CachedTileView::Initialize(VkCommandBuffer command_buffer) {
+  VkResult status = VK_SUCCESS;
+
   // Map format to Vulkan.
   VkFormat vulkan_format = VK_FORMAT_UNDEFINED;
   uint32_t bpp = 4;
@@ -196,22 +213,26 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
   image_info.queueFamilyIndexCount = 0;
   image_info.pQueueFamilyIndices = nullptr;
   image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
-  auto err = vkCreateImage(device_, &image_info, nullptr, &image);
-  CheckResult(err, "vkCreateImage");
+  status = vkCreateImage(*device_, &image_info, nullptr, &image);
+  if (status != VK_SUCCESS) {
+    return status;
+  }
 
-  device->DbgSetObjectName(
+  device_->DbgSetObjectName(
       reinterpret_cast<uint64_t>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
       xe::format_string("RT %.8X %.8X(%d)", key.tile_offset, key.tile_width,
                         key.tile_width));
 
   VkMemoryRequirements memory_requirements;
-  vkGetImageMemoryRequirements(*device, image, &memory_requirements);
+  vkGetImageMemoryRequirements(*device_, image, &memory_requirements);
 
   // Bind to a newly allocated chunk.
   // TODO: Alias from a really big buffer?
-  memory = device->AllocateMemory(memory_requirements, 0);
-  err = vkBindImageMemory(device_, image, memory, 0);
-  CheckResult(err, "vkBindImageMemory");
+  memory = device_->AllocateMemory(memory_requirements, 0);
+  status = vkBindImageMemory(*device_, image, memory, 0);
+  if (status != VK_SUCCESS) {
+    return status;
+  }
 
   // Create the image view we'll use to attach it to a framebuffer.
   VkImageViewCreateInfo image_view_info;
@@ -235,20 +256,26 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
     image_view_info.subresourceRange.aspectMask =
         VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
   }
-  err = vkCreateImageView(device_, &image_view_info, nullptr, &image_view);
-  CheckResult(err, "vkCreateImageView");
+  status = vkCreateImageView(*device_, &image_view_info, nullptr, &image_view);
+  if (status != VK_SUCCESS) {
+    return status;
+  }
 
   // Create separate depth/stencil views.
   if (key.color_or_depth == 0) {
     image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-    err = vkCreateImageView(device_, &image_view_info, nullptr,
-                            &image_view_depth);
-    CheckResult(err, "vkCreateImageView");
+    status = vkCreateImageView(*device_, &image_view_info, nullptr,
+                               &image_view_depth);
+    if (status != VK_SUCCESS) {
+      return status;
+    }
 
     image_view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
-    err = vkCreateImageView(device_, &image_view_info, nullptr,
-                            &image_view_stencil);
-    CheckResult(err, "vkCreateImageView");
+    status = vkCreateImageView(*device_, &image_view_info, nullptr,
+                               &image_view_stencil);
+    if (status != VK_SUCCESS) {
+      return status;
+    }
   }
 
   // TODO(benvanik): transition to general layout?
@@ -279,12 +306,7 @@ CachedTileView::CachedTileView(ui::vulkan::VulkanDevice* device,
                        0, 0, nullptr, 0, nullptr, 1, &image_barrier);
 
   image_layout = image_barrier.newLayout;
-}
-
-CachedTileView::~CachedTileView() {
-  vkDestroyImageView(device_, image_view, nullptr);
-  vkDestroyImage(device_, image, nullptr);
-  vkFreeMemory(device_, memory, nullptr);
+  return VK_SUCCESS;
 }
 
 CachedFramebuffer::CachedFramebuffer(
@@ -294,11 +316,18 @@ CachedFramebuffer::CachedFramebuffer(
     : device_(device),
       width(surface_width),
       height(surface_height),
-      depth_stencil_attachment(target_depth_stencil_attachment) {
+      depth_stencil_attachment(target_depth_stencil_attachment),
+      render_pass(render_pass) {
   for (int i = 0; i < 4; ++i) {
     color_attachments[i] = target_color_attachments[i];
   }
+}
 
+CachedFramebuffer::~CachedFramebuffer() {
+  VK_SAFE_DESTROY(vkDestroyFramebuffer, device_, handle, nullptr);
+}
+
+VkResult CachedFramebuffer::Initialize() {
   // Create framebuffer.
   VkImageView image_views[5] = {nullptr};
   int image_view_count = 0;
@@ -320,12 +349,7 @@ CachedFramebuffer::CachedFramebuffer(
   framebuffer_info.width = width;
   framebuffer_info.height = height;
   framebuffer_info.layers = 1;
-  auto err = vkCreateFramebuffer(device_, &framebuffer_info, nullptr, &handle);
-  CheckResult(err, "vkCreateFramebuffer");
-}
-
-CachedFramebuffer::~CachedFramebuffer() {
-  vkDestroyFramebuffer(device_, handle, nullptr);
+  return vkCreateFramebuffer(device_, &framebuffer_info, nullptr, &handle);
 }
 
 bool CachedFramebuffer::IsCompatible(
@@ -372,10 +396,21 @@ CachedRenderPass::CachedRenderPass(VkDevice device,
                                    const RenderConfiguration& desired_config)
     : device_(device) {
   std::memcpy(&config, &desired_config, sizeof(config));
+}
 
+CachedRenderPass::~CachedRenderPass() {
+  for (auto framebuffer : cached_framebuffers) {
+    delete framebuffer;
+  }
+  cached_framebuffers.clear();
+
+  VK_SAFE_DESTROY(vkDestroyRenderPass, device_, handle, nullptr);
+}
+
+VkResult CachedRenderPass::Initialize() {
   VkSampleCountFlagBits sample_count;
   if (FLAGS_vulkan_native_msaa) {
-    switch (desired_config.surface_msaa) {
+    switch (config.surface_msaa) {
       case MsaaSamples::k1X:
         sample_count = VK_SAMPLE_COUNT_1_BIT;
         break;
@@ -386,7 +421,7 @@ CachedRenderPass::CachedRenderPass(VkDevice device,
         sample_count = VK_SAMPLE_COUNT_4_BIT;
         break;
       default:
-        assert_unhandled_case(desired_config.surface_msaa);
+        assert_unhandled_case(config.surface_msaa);
         break;
     }
   } else {
@@ -480,17 +515,7 @@ CachedRenderPass::CachedRenderPass(VkDevice device,
 
   render_pass_info.dependencyCount = 1;
   render_pass_info.pDependencies = dependencies;
-  auto err = vkCreateRenderPass(device_, &render_pass_info, nullptr, &handle);
-  CheckResult(err, "vkCreateRenderPass");
-}
-
-CachedRenderPass::~CachedRenderPass() {
-  for (auto framebuffer : cached_framebuffers) {
-    delete framebuffer;
-  }
-  cached_framebuffers.clear();
-
-  vkDestroyRenderPass(device_, handle, nullptr);
+  return vkCreateRenderPass(device_, &render_pass_info, nullptr, &handle);
 }
 
 bool CachedRenderPass::IsCompatible(
@@ -837,6 +862,14 @@ bool RenderCache::ConfigureRenderPass(VkCommandBuffer command_buffer,
   // If no render pass was found in the cache create a new one.
   if (!render_pass) {
     render_pass = new CachedRenderPass(*device_, *config);
+    VkResult status = render_pass->Initialize();
+    if (status != VK_SUCCESS) {
+      XELOGE("%s: Failed to create render pass, status %s", __func__,
+             ui::vulkan::to_string(status));
+      delete render_pass;
+      return false;
+    }
+
     cached_render_passes_.push_back(render_pass);
   }
 
@@ -908,6 +941,14 @@ bool RenderCache::ConfigureRenderPass(VkCommandBuffer command_buffer,
     framebuffer = new CachedFramebuffer(
         *device_, render_pass->handle, surface_pitch_px, surface_height_px,
         target_color_attachments, target_depth_stencil_attachment);
+    VkResult status = framebuffer->Initialize();
+    if (status != VK_SUCCESS) {
+      XELOGE("%s: Failed to create framebuffer, status %s", __func__,
+             ui::vulkan::to_string(status));
+      delete framebuffer;
+      return false;
+    }
+
     render_pass->cached_framebuffers.push_back(framebuffer);
   }
 
@@ -964,10 +1005,17 @@ CachedTileView* RenderCache::FindOrCreateTileView(
   }
 
   // Create a new tile and add to the cache.
-  tile_view =
-      new CachedTileView(device_, command_buffer, edram_memory_, view_key);
-  cached_tile_views_.push_back(tile_view);
+  tile_view = new CachedTileView(device_, edram_memory_, view_key);
+  VkResult status = tile_view->Initialize(command_buffer);
+  if (status != VK_SUCCESS) {
+    XELOGE("%s: Failed to create tile view, status %s", __func__,
+           ui::vulkan::to_string(status));
 
+    delete tile_view;
+    return nullptr;
+  }
+
+  cached_tile_views_.push_back(tile_view);
   return tile_view;
 }
 
diff --git a/src/xenia/gpu/vulkan/render_cache.h b/src/xenia/gpu/vulkan/render_cache.h
index a015dc8ca..3b43a5f98 100644
--- a/src/xenia/gpu/vulkan/render_cache.h
+++ b/src/xenia/gpu/vulkan/render_cache.h
@@ -68,11 +68,12 @@ class CachedTileView {
   // (if a depth view) Image view of stencil aspect
   VkImageView image_view_stencil = nullptr;
 
-  CachedTileView(ui::vulkan::VulkanDevice* device,
-                 VkCommandBuffer command_buffer, VkDeviceMemory edram_memory,
+  CachedTileView(ui::vulkan::VulkanDevice* device, VkDeviceMemory edram_memory,
                  TileViewKey view_key);
   ~CachedTileView();
 
+  VkResult Initialize(VkCommandBuffer command_buffer);
+
   bool IsEqual(const TileViewKey& other_key) const {
     auto a = reinterpret_cast<const uint64_t*>(&key);
     auto b = reinterpret_cast<const uint64_t*>(&other_key);
@@ -88,7 +89,7 @@ class CachedTileView {
   }
 
  private:
-  VkDevice device_ = nullptr;
+  ui::vulkan::VulkanDevice* device_ = nullptr;
 };
 
 // Parsed render configuration from the current render state.

From 2b66a1b68fca2be2a6827f69f9774f7b88287c5a Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Tue, 17 Apr 2018 15:35:24 -0500
Subject: [PATCH 23/56] [Vulkan] Emulate Xenos behavior with copy dest at a
 negative offset It appears the Xenos starts copying pixel data at the first
 encountered visible destination pixel, rather than texture mapping the source
 texture onto the destination polygon

---
 .../gpu/vulkan/vulkan_command_processor.cc    | 57 ++++++++++++-------
 1 file changed, 36 insertions(+), 21 deletions(-)

diff --git a/src/xenia/gpu/vulkan/vulkan_command_processor.cc b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
index 52f5ba7fc..2dbed49b5 100644
--- a/src/xenia/gpu/vulkan/vulkan_command_processor.cc
+++ b/src/xenia/gpu/vulkan/vulkan_command_processor.cc
@@ -1179,35 +1179,50 @@ bool VulkanCommandProcessor::IssueCopy() {
           resolve_extent,
       };
 
-      // By offsetting the destination texture by the window offset, we've
-      // already handled it and need to subtract the window offset from the
-      // destination rectangle.
       VkRect2D dst_rect = {
-          {resolve_offset.x + window_offset_x,
-           resolve_offset.y + window_offset_y},
+          {resolve_offset.x, resolve_offset.y},
           resolve_extent,
       };
 
+      // If the destination rectangle lies outside the window, make it start
+      // inside. The Xenos does not copy pixel data at any offset in screen
+      // coordinates.
+      int32_t dst_adj_x =
+          std::max(dst_rect.offset.x, -window_offset_x) - dst_rect.offset.x;
+      int32_t dst_adj_y =
+          std::max(dst_rect.offset.y, -window_offset_y) - dst_rect.offset.y;
+
+      if (uint32_t(dst_adj_x) > dst_rect.extent.width ||
+          uint32_t(dst_adj_y) > dst_rect.extent.height) {
+        // No-op?
+        break;
+      }
+
+      dst_rect.offset.x += dst_adj_x;
+      dst_rect.offset.y += dst_adj_y;
+      dst_rect.extent.width -= dst_adj_x;
+      dst_rect.extent.height -= dst_adj_y;
+      src_rect.extent.width -= dst_adj_x;
+      src_rect.extent.height -= dst_adj_y;
+
       VkViewport viewport = {
-          float(-window_offset_x),
-          float(-window_offset_y),
-          float(copy_dest_pitch),
-          float(copy_dest_height),
-          0.f,
-          1.f,
+          0.f, 0.f, float(copy_dest_pitch), float(copy_dest_height), 0.f, 1.f,
       };
 
+      uint32_t scissor_tl_x = window_regs->window_scissor_tl.tl_x;
+      uint32_t scissor_br_x = window_regs->window_scissor_br.br_x;
+      uint32_t scissor_tl_y = window_regs->window_scissor_tl.tl_y;
+      uint32_t scissor_br_y = window_regs->window_scissor_br.br_y;
+
+      // Clamp the values to destination dimensions.
+      scissor_tl_x = std::min(scissor_tl_x, copy_dest_pitch);
+      scissor_br_x = std::min(scissor_br_x, copy_dest_pitch);
+      scissor_tl_y = std::min(scissor_tl_y, copy_dest_height);
+      scissor_br_y = std::min(scissor_br_y, copy_dest_height);
+
       VkRect2D scissor = {
-          {
-              int32_t(window_regs->window_scissor_tl.tl_x.value()),
-              int32_t(window_regs->window_scissor_tl.tl_y.value()),
-          },
-          {
-              window_regs->window_scissor_br.br_x.value() -
-                  window_regs->window_scissor_tl.tl_x.value(),
-              window_regs->window_scissor_br.br_y.value() -
-                  window_regs->window_scissor_tl.tl_y.value(),
-          },
+          {int32_t(scissor_tl_x), int32_t(scissor_tl_y)},
+          {scissor_br_x - scissor_tl_x, scissor_br_y - scissor_tl_y},
       };
 
       blitter_->BlitTexture2D(

From 86f387ed42655ca66686b4f3a48cc88b1aa262ce Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Fri, 20 Apr 2018 15:24:42 -0500
Subject: [PATCH 24/56] [SPIR-V] Fix 1D texture fetches. Fixes #1124

---
 src/xenia/gpu/spirv_shader_translator.cc | 12 ++++++++++++
 src/xenia/gpu/spirv_shader_translator.h  |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 0387ad5fe..8375e51c6 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -1795,6 +1795,12 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction(
                               tex_[dim_idx], std::vector<Id>({texture_index}));
       auto texture = b.createLoad(texture_ptr);
 
+      if (instr.dimension == TextureDimension::k1D) {
+        // Upgrade 1D src coordinate into 2D
+        src = b.createCompositeConstruct(vec2_float_type_,
+                                         {src, b.makeFloatConstant(0.f)});
+      }
+
       spv::Builder::TextureParameters params = {0};
       params.coords = src;
       params.sampler = texture;
@@ -1917,6 +1923,12 @@ void SpirvShaderTranslator::ProcessTextureFetchInstruction(
                               tex_[dim_idx], std::vector<Id>({texture_index}));
       auto texture = b.createLoad(texture_ptr);
 
+      if (instr.dimension == TextureDimension::k1D) {
+        // Upgrade 1D src coordinate into 2D
+        src = b.createCompositeConstruct(vec2_float_type_,
+                                         {src, b.makeFloatConstant(0.f)});
+      }
+
       spv::Builder::TextureParameters params = {};
       params.sampler = texture;
       params.coords = src;
diff --git a/src/xenia/gpu/spirv_shader_translator.h b/src/xenia/gpu/spirv_shader_translator.h
index b55f9a55a..3a7ead2f8 100644
--- a/src/xenia/gpu/spirv_shader_translator.h
+++ b/src/xenia/gpu/spirv_shader_translator.h
@@ -29,7 +29,7 @@ namespace gpu {
 // supported size).
 struct SpirvPushConstants {
   // Accessible to vertex shader only:
-  float window_scale[4];  // scale x/y, viewport width/height (pixels)
+  float window_scale[4];  // scale x/y, offset x/y (pixels)
   float vtx_fmt[4];
 
   // Accessible to geometry shader only:

From b6dc70ea5ab2445acb155880e754d8c2072754aa Mon Sep 17 00:00:00 2001
From: Sandy Carter <bwrsandman@gmail.com>
Date: Fri, 9 Mar 2018 00:17:59 -0500
Subject: [PATCH 25/56] [Base Tests] Move base tests to their own subdir

---
 src/xenia/base/premake5.lua                 |  9 +--------
 src/xenia/base/{ => testing}/memory_test.cc |  0
 src/xenia/base/testing/premake5.lua         | 11 +++++++++++
 3 files changed, 12 insertions(+), 8 deletions(-)
 rename src/xenia/base/{ => testing}/memory_test.cc (100%)
 create mode 100644 src/xenia/base/testing/premake5.lua

diff --git a/src/xenia/base/premake5.lua b/src/xenia/base/premake5.lua
index 29a0799ca..960a6500c 100644
--- a/src/xenia/base/premake5.lua
+++ b/src/xenia/base/premake5.lua
@@ -16,11 +16,4 @@ project("xenia-base")
     "debug_visualizers.natvis",
   })
 
-test_suite("xenia-base-tests", project_root, ".", {
-  includedirs = {
-    project_root.."/third_party/gflags/src",
-  },
-  links = {
-    "xenia-base",
-  },
-})
+include("testing")
diff --git a/src/xenia/base/memory_test.cc b/src/xenia/base/testing/memory_test.cc
similarity index 100%
rename from src/xenia/base/memory_test.cc
rename to src/xenia/base/testing/memory_test.cc
diff --git a/src/xenia/base/testing/premake5.lua b/src/xenia/base/testing/premake5.lua
new file mode 100644
index 000000000..e432d7ec4
--- /dev/null
+++ b/src/xenia/base/testing/premake5.lua
@@ -0,0 +1,11 @@
+project_root = "../../../.."
+include(project_root.."/tools/build")
+
+test_suite("xenia-base-tests", project_root, ".", {
+  includedirs = {
+    project_root.."/third_party/gflags/src",
+  },
+  links = {
+    "xenia-base",
+  },
+})

From 1681ebfdcb770c75fa1d578edb5a56d3d667b68b Mon Sep 17 00:00:00 2001
From: Sandy Carter <bwrsandman@gmail.com>
Date: Fri, 9 Mar 2018 02:34:50 -0500
Subject: [PATCH 26/56] [Base Tests] Add tests for all cases in memory.cc

---
 .travis.yml                           |   2 +-
 src/xenia/base/testing/memory_test.cc | 404 +++++++++++++++++++++++++-
 2 files changed, 404 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 430b2f08a..87823fa70 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -59,7 +59,7 @@ script:
   # Run linter.
   - if [[ $LINT == true ]]; then ./xenia-build lint --all; fi
   
-  # Build and run our simple hello world test.
+  # Build and run base tests
   - if [[ $BUILD == true ]]; then ./xenia-build build --config=$CONFIG --target=xenia-base-tests; fi
   - if [[ $BUILD == true ]]; then ./build/bin/Linux/$CONFIG/xenia-base-tests; fi
   # Build and run ppc tests
diff --git a/src/xenia/base/testing/memory_test.cc b/src/xenia/base/testing/memory_test.cc
index 427f132a3..5433dc118 100644
--- a/src/xenia/base/testing/memory_test.cc
+++ b/src/xenia/base/testing/memory_test.cc
@@ -11,7 +11,409 @@
 
 #include "third_party/catch/include/catch.hpp"
 
+namespace xe {
+namespace base {
+namespace test {
+
+TEST_CASE("copy_128_aligned", "Copy and Swap") {
+  alignas(128) uint8_t src[256], dest[256];
+  for (uint8_t i = 0; i < 255; ++i) {
+    src[i] = 255 - i;
+  }
+  std::memset(dest, 0, sizeof(dest));
+  copy_128_aligned(dest, src, 1);
+  REQUIRE(std::memcmp(dest, src, 128));
+  REQUIRE(dest[128] == 0);
+
+  std::memset(dest, 0, sizeof(dest));
+  copy_128_aligned(dest, src, 2);
+  REQUIRE(std::memcmp(dest, src, 256));
+
+  std::memset(dest, 0, sizeof(dest));
+  copy_128_aligned(dest, src + 1, 1);
+  REQUIRE(std::memcmp(dest, src + 1, 128));
+}
+
 TEST_CASE("copy_and_swap_16_aligned", "Copy and Swap") {
-  // TODO(benvanik): tests.
+  alignas(16) uint16_t a = 0x1111, b = 0xABCD;
+  copy_and_swap_16_aligned(&a, &b, 1);
+  REQUIRE(a == 0xCDAB);
+  REQUIRE(b == 0xABCD);
+
+  alignas(16) uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000};
+  alignas(16) uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF};
+  copy_and_swap_16_aligned(c, d, 1);
+  REQUIRE(c[0] == 0x2301);
+  REQUIRE(c[1] == 0x0000);
+  REQUIRE(c[2] == 0x0000);
+  REQUIRE(c[3] == 0x0000);
+
+  copy_and_swap_16_aligned(c, d, 3);
+  REQUIRE(c[0] == 0x2301);
+  REQUIRE(c[1] == 0x6745);
+  REQUIRE(c[2] == 0xAB89);
+  REQUIRE(c[3] == 0x0000);
+
+  copy_and_swap_16_aligned(c, d, 4);
+  REQUIRE(c[0] == 0x2301);
+  REQUIRE(c[1] == 0x6745);
+  REQUIRE(c[2] == 0xAB89);
+  REQUIRE(c[3] == 0xEFCD);
+
+  alignas(16) uint64_t e;
+  copy_and_swap_16_aligned(&e, d, 4);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  alignas(16) char f[85] = {0x00};
+  alignas(16) char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_16_aligned(f, g, 42);
+  REQUIRE(std::strcmp(f,
+                      "hTsii  s a58b ty eolgns rtni.g..I 't susppsodet  oebl "
+                      "noeg rhtnas atdnra dlagimnne.t") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_16_aligned(f, g + 16, 34);
+  REQUIRE(std::strcmp(f,
+                      " eolgns rtni.g..I 't susppsodet  oebl "
+                      "noeg rhtnas atdnra dlagimnne.t") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_16_aligned(f, g + 32, 26);
+  REQUIRE(std::strcmp(f,
+                      "I 't susppsodet  oebl "
+                      "noeg rhtnas atdnra dlagimnne.t") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_16_aligned(f, g + 64, 10);
+  REQUIRE(std::strcmp(f, "s atdnra dlagimnne.t") == 0);
+}
+
+TEST_CASE("copy_and_swap_16_unaligned", "Copy and Swap") {
+  uint16_t a = 0x1111, b = 0xABCD;
+  copy_and_swap_16_unaligned(&a, &b, 1);
+  REQUIRE(a == 0xCDAB);
+  REQUIRE(b == 0xABCD);
+
+  uint16_t c[] = {0x0000, 0x0000, 0x0000, 0x0000};
+  uint16_t d[] = {0x0123, 0x4567, 0x89AB, 0xCDEF};
+  copy_and_swap_16_unaligned(c, d, 1);
+  REQUIRE(c[0] == 0x2301);
+  REQUIRE(c[1] == 0x0000);
+  REQUIRE(c[2] == 0x0000);
+  REQUIRE(c[3] == 0x0000);
+
+  copy_and_swap_16_unaligned(c, d, 4);
+  REQUIRE(c[0] == 0x2301);
+  REQUIRE(c[1] == 0x6745);
+  REQUIRE(c[2] == 0xAB89);
+  REQUIRE(c[3] == 0xEFCD);
+
+  uint64_t e;
+  copy_and_swap_16_unaligned(&e, d, 4);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  char f[85] = {0x00};
+  char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_16_unaligned(f, g, 42);
+  REQUIRE(std::strcmp(f,
+                      "hTsii  s a58b ty eolgns rtni.g..I 't susppsodet  oebl "
+                      "noeg rhtnas atdnra dlagimnne.t") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_16_unaligned(f, g + 1, 41);
+  REQUIRE(std::strcmp(f,
+                      "ih ssia 8  5ybetl no gtsirgn.. .tIs's puopes dotb  "
+                      "eolgnret ah ntsnaaddra ilngemtn") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_16_unaligned(f, g + 2, 41);
+  REQUIRE(std::strcmp(f,
+                      "sii  s a58b ty eolgns rtni.g..I 't susppsodet  oebl "
+                      "noeg rhtnas atdnra dlagimnne.t") == 0);
+}
+
+TEST_CASE("copy_and_swap_32_aligned", "Copy and Swap") {
+  alignas(32) uint32_t a = 0x11111111, b = 0x89ABCDEF;
+  copy_and_swap_32_aligned(&a, &b, 1);
+  REQUIRE(a == 0xEFCDAB89);
+  REQUIRE(b == 0x89ABCDEF);
+
+  alignas(32) uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000};
+  alignas(32) uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199};
+  copy_and_swap_32_aligned(c, d, 1);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0x00000000);
+  REQUIRE(c[2] == 0x00000000);
+  REQUIRE(c[3] == 0x00000000);
+
+  copy_and_swap_32_aligned(c, d, 3);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0xEFCDAB89);
+  REQUIRE(c[2] == 0xEDEE87E8);
+  REQUIRE(c[3] == 0x00000000);
+
+  copy_and_swap_32_aligned(c, d, 4);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0xEFCDAB89);
+  REQUIRE(c[2] == 0xEDEE87E8);
+  REQUIRE(c[3] == 0x994151D8);
+
+  alignas(32) uint64_t e;
+  copy_and_swap_32_aligned(&e, d, 2);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  alignas(32) char f[85] = {0x00};
+  alignas(32) char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_32_aligned(f, g, 21);
+  REQUIRE(std::strcmp(f,
+                      "sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb "
+                      "onol  regnahtats radnla dmngi.tne") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_aligned(f, g + 16, 17);
+  REQUIRE(std::strcmp(f,
+                      "ol es gnnirt...g'tI us ssoppt deeb "
+                      "onol  regnahtats radnla dmngi.tne") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_aligned(f, g + 32, 13);
+  REQUIRE(std::strcmp(f,
+                      "'tI us ssoppt deeb "
+                      "onol  regnahtats radnla dmngi.tne") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_aligned(f, g + 64, 5);
+  REQUIRE(std::strcmp(f, "ats radnla dmngi.tne") == 0);
+}
+
+TEST_CASE("copy_and_swap_32_unaligned", "Copy and Swap") {
+  uint32_t a = 0x11111111, b = 0x89ABCDEF;
+  copy_and_swap_32_unaligned(&a, &b, 1);
+  REQUIRE(a == 0xEFCDAB89);
+  REQUIRE(b == 0x89ABCDEF);
+
+  uint32_t c[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000};
+  uint32_t d[] = {0x01234567, 0x89ABCDEF, 0xE887EEED, 0xD8514199};
+  copy_and_swap_32_unaligned(c, d, 1);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0x00000000);
+  REQUIRE(c[2] == 0x00000000);
+  REQUIRE(c[3] == 0x00000000);
+
+  copy_and_swap_32_unaligned(c, d, 3);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0xEFCDAB89);
+  REQUIRE(c[2] == 0xEDEE87E8);
+  REQUIRE(c[3] == 0x00000000);
+
+  copy_and_swap_32_unaligned(c, d, 4);
+  REQUIRE(c[0] == 0x67452301);
+  REQUIRE(c[1] == 0xEFCDAB89);
+  REQUIRE(c[2] == 0xEDEE87E8);
+  REQUIRE(c[3] == 0x994151D8);
+
+  uint64_t e;
+  copy_and_swap_32_unaligned(&e, d, 2);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  char f[85] = {0x00};
+  char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_32_unaligned(f, g, 21);
+  REQUIRE(std::strcmp(f,
+                      "sihT si 58 atyb ol es gnnirt...g'tI us ssoppt deeb "
+                      "onol  regnahtats radnla dmngi.tne") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_unaligned(f, g + 1, 20);
+  REQUIRE(std::strcmp(f,
+                      " siha si 58 etybnol ts ggnir ...s'tIpus esopot d eb "
+                      "gnolt re nahnatsdradila emng") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_unaligned(f, g + 2, 20);
+  REQUIRE(std::strcmp(f,
+                      "i si a sb 58 etygnolrts .gniI .. s'tppusdeso ot l "
+                      "ebegnoht rs nadnat dragilanemn") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_unaligned(f, g + 3, 20);
+  REQUIRE(std::strcmp(f,
+                      "si s8 a yb 5l et gnoirts..gntI .s s'oppu desb otol "
+                      "eregnaht ts nadnaa drngiltnem") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_32_unaligned(f, g + 4, 20);
+  REQUIRE(std::strcmp(f,
+                      " si 58 atyb ol es gnnirt...g'tI us ssoppt deeb onol  "
+                      "regnahtats radnla dmngi.tne") == 0);
+}
+
+TEST_CASE("copy_and_swap_64_aligned", "Copy and Swap") {
+  alignas(64) uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF;
+  copy_and_swap_64_aligned(&a, &b, 1);
+  REQUIRE(a == 0xEFCDAB8967452301);
+  REQUIRE(b == 0x0123456789ABCDEF);
+
+  alignas(64) uint64_t c[] = {0x0000000000000000, 0x0000000000000000,
+                              0x0000000000000000, 0x0000000000000000};
+  alignas(64) uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199,
+                              0x21D4745A1D4A7706, 0xA4174FED675766E3};
+  copy_and_swap_64_aligned(c, d, 1);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x0000000000000000);
+  REQUIRE(c[2] == 0x0000000000000000);
+  REQUIRE(c[3] == 0x0000000000000000);
+
+  copy_and_swap_64_aligned(c, d, 3);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x994151D8EDEE87E8);
+  REQUIRE(c[2] == 0x06774A1D5A74D421);
+  REQUIRE(c[3] == 0x0000000000000000);
+
+  copy_and_swap_64_aligned(c, d, 4);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x994151D8EDEE87E8);
+  REQUIRE(c[2] == 0x06774A1D5A74D421);
+  REQUIRE(c[3] == 0xE3665767ED4F17A4);
+
+  alignas(64) uint64_t e;
+  copy_and_swap_64_aligned(&e, d, 1);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  alignas(64) char f[85] = {0x00};
+  alignas(64) char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_64_aligned(f, g, 10);
+  REQUIRE(std::strcmp(f,
+                      " si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb "
+                      "onaht regradnats mngila d") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_aligned(f, g + 16, 8);
+  REQUIRE(std::strcmp(f,
+                      "s gnol e...gnirtus s'tI t desoppnol eb "
+                      "onaht regradnats mngila d") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_aligned(f, g + 32, 6);
+  REQUIRE(std::strcmp(f,
+                      "us s'tI t desoppnol eb "
+                      "onaht regradnats mngila d") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_aligned(f, g + 64, 2);
+  REQUIRE(std::strcmp(f, "radnats mngila d") == 0);
+}
+
+TEST_CASE("copy_and_swap_64_unaligned", "Copy and Swap") {
+  uint64_t a = 0x1111111111111111, b = 0x0123456789ABCDEF;
+  copy_and_swap_64_unaligned(&a, &b, 1);
+  REQUIRE(a == 0xEFCDAB8967452301);
+  REQUIRE(b == 0x0123456789ABCDEF);
+
+  uint64_t c[] = {0x0000000000000000, 0x0000000000000000, 0x0000000000000000,
+                  0x0000000000000000};
+  uint64_t d[] = {0x0123456789ABCDEF, 0xE887EEEDD8514199, 0x21D4745A1D4A7706,
+                  0xA4174FED675766E3};
+  copy_and_swap_64_unaligned(c, d, 1);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x0000000000000000);
+  REQUIRE(c[2] == 0x0000000000000000);
+  REQUIRE(c[3] == 0x0000000000000000);
+
+  copy_and_swap_64_unaligned(c, d, 3);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x994151D8EDEE87E8);
+  REQUIRE(c[2] == 0x06774A1D5A74D421);
+  REQUIRE(c[3] == 0x0000000000000000);
+
+  copy_and_swap_64_unaligned(c, d, 4);
+  REQUIRE(c[0] == 0xEFCDAB8967452301);
+  REQUIRE(c[1] == 0x994151D8EDEE87E8);
+  REQUIRE(c[2] == 0x06774A1D5A74D421);
+  REQUIRE(c[3] == 0xE3665767ED4F17A4);
+
+  uint64_t e;
+  copy_and_swap_64_unaligned(&e, d, 1);
+  REQUIRE(e == 0xEFCDAB8967452301);
+
+  char f[85] = {0x00};
+  char g[] =
+      "This is a 85 byte long string... "
+      "It's supposed to be longer than standard alignment.";
+  copy_and_swap_64_unaligned(f, g, 10);
+  REQUIRE(std::strcmp(f,
+                      " si sihTtyb 58 as gnol e...gnirtus s'tI t desoppnol eb "
+                      "onaht regradnats mngila d") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 1, 10);
+  REQUIRE(std::strcmp(f,
+                      "a si sihetyb 58 ts gnol  ...gnirpus s'tIot desopgnol "
+                      "eb  naht redradnatsemngila ") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 2, 10);
+  REQUIRE(std::strcmp(f,
+                      " a si si etyb 58rts gnolI ...gnippus s't ot desoegnol "
+                      "ebs naht r dradnatnemngila") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 3, 10);
+  REQUIRE(std::strcmp(f,
+                      "8 a si sl etyb 5irts gnotI ...gnoppus s'b ot desregnol "
+                      "ets naht a dradnatnemngil") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 4, 10);
+  REQUIRE(std::strcmp(f,
+                      "58 a si ol etyb nirts gn'tI ...gsoppus seb ot de "
+                      "regnol ats nahtla dradn.tnemngi") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 5, 9);
+  REQUIRE(std::strcmp(f,
+                      " 58 a sinol etybgnirts gs'tI ...esoppus  eb ot dt "
+                      "regnolnats nahila drad") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 6, 9);
+  REQUIRE(std::strcmp(f,
+                      "b 58 a sgnol ety.gnirts  s'tI ..desoppusl eb ot ht "
+                      "regnodnats nagila dra") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 7, 9);
+  REQUIRE(std::strcmp(f,
+                      "yb 58 a  gnol et..gnirtss s'tI . desoppuol eb otaht "
+                      "regnadnats nngila dr") == 0);
+
+  std::memset(f, 0, sizeof(f));
+  copy_and_swap_64_unaligned(f, g + 8, 9);
+  REQUIRE(std::strcmp(f,
+                      "tyb 58 as gnol e...gnirtus s'tI t desoppnol eb onaht "
+                      "regradnats mngila d") == 0);
+}
+
+TEST_CASE("copy_and_swap_16_in_32_aligned", "Copy and Swap") {
+  // TODO(bwrsandman): test once properly understood.
   REQUIRE(true == true);
 }
+
+TEST_CASE("copy_and_swap_16_in_32_unaligned", "Copy and Swap") {
+  // TODO(bwrsandman): test once properly understood.
+  REQUIRE(true == true);
+}
+
+}  // namespace test
+}  // namespace base
+}  // namespace xe

From 24e7bb529389897d9da6caa77f1121ad921f3a80 Mon Sep 17 00:00:00 2001
From: Sandy Carter <bwrsandman@gmail.com>
Date: Fri, 9 Mar 2018 23:16:03 -0800
Subject: [PATCH 27/56] [Memory] Fix alignment to 16 bytes

Fix segmentation fault happening on linux when `src` or `dst` is not aligned to
16 bytes.
Assert against use of `src_ptr` and `dest_ptr` which are not unaligned to 16
bits.
---
 src/xenia/base/memory.cc | 37 ++++++++++++++-----------------------
 1 file changed, 14 insertions(+), 23 deletions(-)

diff --git a/src/xenia/base/memory.cc b/src/xenia/base/memory.cc
index bdc0ea7f1..1f9d654a1 100644
--- a/src/xenia/base/memory.cc
+++ b/src/xenia/base/memory.cc
@@ -26,7 +26,9 @@ void copy_128_aligned(void* dest, const void* src, size_t count) {
 #if XE_ARCH_AMD64
 void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
-  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x1);
+  assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
+  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
+
   auto dest = reinterpret_cast<uint16_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint16_t*>(src_ptr);
   __m128i shufmask =
@@ -34,12 +36,7 @@ void copy_and_swap_16_aligned(void* dest_ptr, const void* src_ptr,
                    0x04, 0x05, 0x02, 0x03, 0x00, 0x01);
 
   size_t i = 0;
-  size_t unaligned_words = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 2;
-  for (; unaligned_words > 0 && i < count; unaligned_words--, i++) {
-    // Copy up to 16 byte alignment.
-    dest[i] = byte_swap(src[i]);
-  }
-  for (; i + 8 <= count; i += 8) {
+  for (i = 0; i + 8 <= count; i += 8) {
     __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
     __m128i output = _mm_shuffle_epi8(input, shufmask);
     _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);
@@ -70,20 +67,17 @@ void copy_and_swap_16_unaligned(void* dest_ptr, const void* src_ptr,
 
 void copy_and_swap_32_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
-  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x3);
+  assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
+  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
+
   auto dest = reinterpret_cast<uint32_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint32_t*>(src_ptr);
   __m128i shufmask =
       _mm_set_epi8(0x0C, 0x0D, 0x0E, 0x0F, 0x08, 0x09, 0x0A, 0x0B, 0x04, 0x05,
                    0x06, 0x07, 0x00, 0x01, 0x02, 0x03);
 
-  size_t i = 0;
-  size_t unaligned_dwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 4;
-  for (; unaligned_dwords > 0 && i < count; unaligned_dwords--, i++) {
-    // Copy up to 16 byte alignment.
-    dest[i] = byte_swap(src[i]);
-  }
-  for (; i + 4 <= count; i += 4) {
+  size_t i;
+  for (i = 0; i + 4 <= count; i += 4) {
     __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
     __m128i output = _mm_shuffle_epi8(input, shufmask);
     _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);
@@ -114,20 +108,17 @@ void copy_and_swap_32_unaligned(void* dest_ptr, const void* src_ptr,
 
 void copy_and_swap_64_aligned(void* dest_ptr, const void* src_ptr,
                               size_t count) {
-  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0x7);
+  assert_zero(reinterpret_cast<uintptr_t>(dest_ptr) & 0xF);
+  assert_zero(reinterpret_cast<uintptr_t>(src_ptr) & 0xF);
+
   auto dest = reinterpret_cast<uint64_t*>(dest_ptr);
   auto src = reinterpret_cast<const uint64_t*>(src_ptr);
   __m128i shufmask =
       _mm_set_epi8(0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01,
                    0x02, 0x03, 0x04, 0x05, 0x06, 0x07);
 
-  size_t i = 0;
-  size_t unaligned_qwords = (reinterpret_cast<uintptr_t>(src_ptr) & 0xF) / 8;
-  for (; unaligned_qwords > 0 && i < count; unaligned_qwords--, i++) {
-    // Copy up to 16 byte alignment.
-    dest[i] = byte_swap(src[i]);
-  }
-  for (; i + 2 <= count; i += 2) {
+  size_t i;
+  for (i = 0; i + 2 <= count; i += 2) {
     __m128i input = _mm_load_si128(reinterpret_cast<const __m128i*>(&src[i]));
     __m128i output = _mm_shuffle_epi8(input, shufmask);
     _mm_store_si128(reinterpret_cast<__m128i*>(&dest[i]), output);

From efc36e50be201225a419bd30e2f549985e6bef9f Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Sat, 28 Apr 2018 20:15:16 -0500
Subject: [PATCH 28/56] Use the same python as the currently executing python
 to run scripts

---
 xenia-build | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/xenia-build b/xenia-build
index 167259edf..080d97d1b 100755
--- a/xenia-build
+++ b/xenia-build
@@ -318,7 +318,7 @@ def run_premake(target_os, action, cc=None):
       action: action to preform.
     """
     ret = subprocess.call([
-        'python',
+        sys.executable,
         os.path.join('tools', 'build', 'premake'),
         '--file=premake5.lua',
         '--os=%s' % target_os,
@@ -973,7 +973,7 @@ class GpuTestCommand(BaseBuildCommand):
         # Run tests.
         any_failed = False
         result = shell_call([
-            'python',
+            sys.executable,
             os.path.join(self_path, 'tools', 'gpu-trace-diff'),
             '--executable=' + test_executables[0],
             '--trace_path=' + os.path.join(reference_trace_root, 'traces'),
@@ -1118,7 +1118,7 @@ class LintCommand(Command):
                         file_path,
                         ], throw_on_error=False, stdout_path=difftemp)
                     shell_call([
-                        'python',
+                        sys.executable,
                         'tools/diff.py',
                         file_path,
                         difftemp,
@@ -1141,7 +1141,7 @@ class LintCommand(Command):
             print('- git-clang-format --diff')
             if os.path.exists(difftemp): os.remove(difftemp)
             ret = shell_call([
-                'python',
+                sys.executable,
                 'third_party/clang-format/git-clang-format',
                 '--binary=%s' % (clang_format_binary),
                 '--commit=%s' % ('origin/master' if args['origin'] else 'HEAD'),
@@ -1157,7 +1157,7 @@ class LintCommand(Command):
                 any_errors = True
                 print('')
                 shell_call([
-                    'python',
+                    sys.executable,
                     'third_party/clang-format/git-clang-format',
                     '--binary=%s' % (clang_format_binary),
                     '--commit=%s' % ('origin/master' if args['origin'] else 'HEAD'),
@@ -1213,7 +1213,7 @@ class FormatCommand(Command):
         else:
             print('- git-clang-format')
             shell_call([
-                'python',
+                sys.executable,
                 'third_party/clang-format/git-clang-format',
                 '--binary=%s' % (clang_format_binary),
                 '--commit=%s' % ('origin/master' if args['origin'] else 'HEAD'),
@@ -1239,7 +1239,7 @@ class StyleCommand(Command):
                      if not file_path.endswith('_test.cc')]
         print('- cpplint [%d files]' % (len(all_files)))
         ret = shell_call([
-            'python',
+            sys.executable,
             'third_party/google-styleguide/cpplint/cpplint.py',
             '--output=vs7',
             '--linelength=80',

From ef3577e45ca28a87bdf5510649367927c23508cb Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Sun, 29 Apr 2018 18:25:56 -0500
Subject: [PATCH 29/56] [Vulkan UI] Fix minor bug in specifying size of queue
 priorities array

---
 src/xenia/ui/vulkan/vulkan_device.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/xenia/ui/vulkan/vulkan_device.cc b/src/xenia/ui/vulkan/vulkan_device.cc
index d31ffc327..437f8568d 100644
--- a/src/xenia/ui/vulkan/vulkan_device.cc
+++ b/src/xenia/ui/vulkan/vulkan_device.cc
@@ -169,7 +169,7 @@ bool VulkanDevice::Initialize(DeviceInfo device_info) {
     queue_info.queueFamilyIndex = i;
     queue_info.queueCount = family_props.queueCount;
 
-    queue_priorities[i].resize(queue_count, 0.f);
+    queue_priorities[i].resize(family_props.queueCount, 0.f);
     if (i == ideal_queue_family_index) {
       // Prioritize the first queue on the primary queue family.
       queue_priorities[i][0] = 1.0f;

From 87bfad1f74f8904842c7d22aeaa319eee086dfaf Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Sun, 29 Apr 2018 18:26:36 -0500
Subject: [PATCH 30/56] [GPU] PM4_EVENT_WRITE_EXT destination is /not/ aligned
 (to 16 bytes)

---
 src/xenia/gpu/command_processor.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/command_processor.cc b/src/xenia/gpu/command_processor.cc
index 960cc8294..37f416646 100644
--- a/src/xenia/gpu/command_processor.cc
+++ b/src/xenia/gpu/command_processor.cc
@@ -1051,8 +1051,8 @@ bool CommandProcessor::ExecutePacketType3_EVENT_WRITE_EXT(RingBuffer* reader,
       1,          // max z
   };
   assert_true(endianness == Endian::k8in16);
-  xe::copy_and_swap_16_aligned(memory_->TranslatePhysical(address), extents,
-                               xe::countof(extents));
+  xe::copy_and_swap_16_unaligned(memory_->TranslatePhysical(address), extents,
+                                 xe::countof(extents));
   trace_writer_.WriteMemoryWrite(CpuToGpu(address), sizeof(extents));
   return true;
 }

From 62bee78edd105df21b3dac31fdbadce84be6608e Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Sun, 29 Apr 2018 18:43:31 -0500
Subject: [PATCH 31/56] [SPIR-V] Declare DepthReplacing if we replace depth

---
 src/xenia/gpu/spirv_shader_translator.cc | 7 +++++--
 src/xenia/gpu/spirv_shader_translator.h  | 2 ++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 8375e51c6..834f4ae06 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -483,8 +483,10 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() {
                                  mainFn, "main");
     b.addExecutionMode(mainFn, spv::ExecutionModeOriginUpperLeft);
 
-    // FIXME(DrChat): We need to declare the DepthReplacing execution mode if
-    // we write depth, and we must unconditionally write depth if declared!
+    // If we write a new depth value, we must declare this mode!
+    if (writes_depth_) {
+      b.addExecutionMode(mainFn, spv::ExecutionModeDepthReplacing);
+    }
 
     for (auto id : interface_ids_) {
       entry->addIdOperand(id);
@@ -3298,6 +3300,7 @@ void SpirvShaderTranslator::StoreToResult(Id source_value_id,
       storage_type = float_type_;
       storage_offsets.push_back(0);
       storage_array = false;
+      writes_depth_ = true;
       break;
     default:
     case InstructionStorageTarget::kNone:
diff --git a/src/xenia/gpu/spirv_shader_translator.h b/src/xenia/gpu/spirv_shader_translator.h
index 3a7ead2f8..caa288353 100644
--- a/src/xenia/gpu/spirv_shader_translator.h
+++ b/src/xenia/gpu/spirv_shader_translator.h
@@ -163,6 +163,8 @@ class SpirvShaderTranslator : public ShaderTranslator {
   spv::Id vtx_ = 0;  // Vertex buffer array (32 runtime arrays)
   std::unordered_map<uint32_t, uint32_t> vtx_binding_map_;
 
+  bool writes_depth_ = false;
+
   // SPIR-V IDs that are part of the in/out interface.
   std::vector<spv::Id> interface_ids_;
 

From f7c7cc54ed3c8e8d9e0d649421a919066b899dd9 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Mon, 30 Apr 2018 11:01:46 -0500
Subject: [PATCH 32/56] [GPU] TextureInfo::GetMaxMipLevels

---
 src/xenia/gpu/texture_info.cc | 5 +++++
 src/xenia/gpu/texture_info.h  | 2 ++
 2 files changed, 7 insertions(+)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 13cf23c81..655249304 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -204,6 +204,11 @@ void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height,
   input_length = size_cube.input_face_length * 6;
 }
 
+uint32_t TextureInfo::GetMaxMipLevels(uint32_t width, uint32_t height,
+                                      uint32_t depth) {
+  return 1 + xe::log2_floor(std::max({width, height, depth}));
+}
+
 bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
                                       uint32_t* out_offset_x,
                                       uint32_t* out_offset_y) {
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 3228a4768..821d5134b 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -304,6 +304,8 @@ struct TextureInfo {
                              uint32_t width, uint32_t height,
                              TextureInfo* out_info);
 
+  static uint32_t GetMaxMipLevels(uint32_t width, uint32_t height,
+                                  uint32_t depth);
   static bool GetPackedTileOffset(const TextureInfo& texture_info,
                                   uint32_t* out_offset_x,
                                   uint32_t* out_offset_y);

From a9b6e23a99e1239e6d892760f8e0d069c4d3a780 Mon Sep 17 00:00:00 2001
From: Christopher Cruzen <christopher.a.cruzen@gmail.com>
Date: Wed, 2 May 2018 22:31:48 -0500
Subject: [PATCH 33/56] Add Xephorium's Icon

---
 assets/icon/128x128.png                     | Bin 3536 -> 25830 bytes
 assets/icon/16x16.png                       | Bin 1396 -> 1204 bytes
 assets/icon/256x256.png                     | Bin 4429 -> 64340 bytes
 assets/icon/32x32.png                       | Bin 1065 -> 3126 bytes
 assets/icon/36x36.png                       | Bin 2767 -> 3739 bytes
 assets/icon/37x37.png                       | Bin 2776 -> 3922 bytes
 assets/icon/48x48.png                       | Bin 2923 -> 5873 bytes
 assets/icon/512x512.png                     | Bin 5797 -> 153321 bytes
 assets/icon/64x64.png                       | Bin 3131 -> 9255 bytes
 assets/icon/Icon.blend                      | Bin 0 -> 638756 bytes
 assets/icon/Rendering Instructions.txt      |  26 ++++++++++++++++++++
 assets/icon/icon.ico                        | Bin 273118 -> 153321 bytes
 assets/icon/original/128x128.png            | Bin 0 -> 3536 bytes
 assets/icon/original/16x16.png              | Bin 0 -> 1396 bytes
 assets/icon/original/256x256.png            | Bin 0 -> 4429 bytes
 assets/icon/original/32x32.png              | Bin 0 -> 1065 bytes
 assets/icon/original/36x36.png              | Bin 0 -> 2767 bytes
 assets/icon/original/37x37.png              | Bin 0 -> 2776 bytes
 assets/icon/original/48x48.png              | Bin 0 -> 2923 bytes
 assets/icon/original/512x512.png            | Bin 0 -> 5797 bytes
 assets/icon/original/64x64.png              | Bin 0 -> 3131 bytes
 assets/icon/{ => original}/Icon.psd         | Bin
 assets/icon/{ => original}/Icon_Complex.psd | Bin
 assets/icon/original/icon.ico               | Bin 0 -> 273118 bytes
 24 files changed, 26 insertions(+)
 create mode 100644 assets/icon/Icon.blend
 create mode 100644 assets/icon/Rendering Instructions.txt
 create mode 100644 assets/icon/original/128x128.png
 create mode 100644 assets/icon/original/16x16.png
 create mode 100644 assets/icon/original/256x256.png
 create mode 100644 assets/icon/original/32x32.png
 create mode 100644 assets/icon/original/36x36.png
 create mode 100644 assets/icon/original/37x37.png
 create mode 100644 assets/icon/original/48x48.png
 create mode 100644 assets/icon/original/512x512.png
 create mode 100644 assets/icon/original/64x64.png
 rename assets/icon/{ => original}/Icon.psd (100%)
 rename assets/icon/{ => original}/Icon_Complex.psd (100%)
 create mode 100644 assets/icon/original/icon.ico

diff --git a/assets/icon/128x128.png b/assets/icon/128x128.png
index 231718bb79a3b32bc3617adb79f3f792dbaa7f07..c266576e64ba655638b819863ac943dc39c1ddf6 100644
GIT binary patch
literal 25830
zcmV)*K#9MJP)<h;3K|Lk000e1NJLTq004jh004jp1^@s6!#-il00009a7bBm000XU
z000XU0RWnu7ytkORCGmHbVg}xWdK7uTvc;ra&uf*WpHS3a%pvKTu5(iWn55lZ)#;@
zbaPxYL?A(KX>DP2X>V>^LTqJjWMy(7P;zf-Wn*-6Tv%mpX<;BqV{dLQVr*q@WbVk2
z761SM7<5HgbVOlvWdJfTF*q+UH7_tSATlyKFf}?fHrpkKt^fc45OhUYbW~|=WdJZR
zIxsLgF)=zYG#PcAm;e9(33NqRbVhPvZDjy5HaP85-fjQ@01<RWSad^SZDn#{06`!v
zAVXnoWpZI<xV6Rr000YgMObuGV`Xk-08?XSZe`^mU6ud<026dYSaeclZe(S0RB3Hx
z05C8*FflGTIjN2dhyVZ}07*naRCod0y$5_9RhH*}>L~{YIa^M0&H<a?3^o}|4&BgX
zXgW{N&iv>9-!L=1JNw!H%uen!9q6Ws4GkuPi3S@3&H?8r%a$!UXJx(j_WL{aO2LwF
zz|iy_`>N_y-Kx5E&$%bxTY>#w2BSxh4tOP%7$rAVI<U>5Xj?$Zqv(8AYFo=zrHXQl
za)fd`wXfegm!KrqtXY#}`+p6nqyD4;gs1TW>6DI?BFaF@2+9yjFNzSZl1)*)OiDx~
z?D~FOJAjVYrHY8*aH{NNyP2{jwbk!KlsE(tUCYluJ@}I(0FW*uYBUSclPD7@LVQn(
zMz_vugr6(Ws8<musHE(n6jMH+tfXwB?5EWKsd0!u83F+5V%I$=7f`ODoKGpDh|P-&
zeAy5YMFkJuMfrsC4rMW=3_=hm`O3prmH<++T%%YceLCfO%EgpElnjax@KtGlL<~ZD
zDP<w$8Ok!sp|7%-_^Nau{S-n9@fy)Zl$$BHQ-)DA(!X-;rA@7Y2%?6vn(`dwRZ8(!
zkr2L89SZWLsEwxFOSzg7jdpg=Ed;SfsiFNuy~O($0`=T=2jwlw<CIS!gfHx2-2aT=
zD?tD$#E+uo4^eKUbfcVg+hXaN7NlobMt*zCYTwavI(4y}_63&RzJq0E=U94HwxwrM
zM?{cJ@;_nqwY64XQ*AXBC#>egajQCdi0v_}K61$F*d}UgESZRVp>1aavKC}s&Zay<
z5g~{;{-|))oqR4@4dOKn2U5OI`5L7&rEzHT<8&Y`JI}H@b+vXq`&frweXS$gjy(!N
zdI!tS%ePDro|cwoF%TZ`#z7FHG<|h(Y^McFBodUk#p~;>4x*^3JYf|_4%_jA`|VKa
zc006viybT5Vf7G7yjuF-8G{~HMtO<yZ<G=UK|Y2*3N-D7FSP+6zY7n%iz4LrrAV<m
zEzrnK%gwj;{RUf?!6U5efFV{;*vIk<I$K6YCdiIiS_~v}w-|`l))Ak&d-T#xX#hsx
zklMJ0sbl(`U`Hh$k6SHVqT=XLJG6VJ?JwSBd)I$zCw3J>43%fX9dui91o;zwLV22U
z5JHF^&(ALhqQ3ZYp2kx^ybwK=@?R*@?q%Mc7NqBQu>9Twto!H*)^qq6E9lwVvUBr5
zdWIYQG2TW9m+7E=y_`x!1dh%Wrgc2YzP3&sO}43{4agT(LPAIp1HTg-sE^lM72@LX
zo-!+k5XwGX0x@j2c%__(rw!5vKBoL#YWt=768!y7yQ!bEBFL9)|8vU2lundWK0iR7
zXLRgrT}NMFeJ_}5UHcEVoV+|sPfNEnt`?#tGfqZ)^g9~)@w!?o+p@uqfGo*-9j~jd
zc6J{_JfxvBq`^J1^V?b9kz*~lLr19xE)wby2PS<1uF^mVJkz;?>abrAcc?ge#P*kL
zvt6qe+n(hgS?yu@hE5yyQu9}oU&9G@pY~Osv*IZc@Hy}Am#0SkdHnbX$`pz`b)N}B
zd`@AJ^_Vcl`b?N)1wDEp%d;#UjHjhWc}M`Tc*$&7bM>(!cBFi_RUJEQ{ooKCyZ1m8
zAp7-}VDsqyy|!!9I_uQErz5zws?v6>`_xvx^O_wk6F0_R+@Zj3|LcFWZbec};L8xq
zlGkTjhi*NsQ|}_SJy0e)S{izVh(dh4DIvsR4K=joFzqN^xyW`e`OvC%Z$Dk}P|fYc
z4gQ+4972#^;R}T?oB%++Sp40T|4J#Mobs7Dy$4#)i8HM4`BSU|$jV4hw{(y$#5>X%
zhXEt5zN*5Gl$F|k6tg{>*4qAUo2=@{0ZVeO`_R!g`Ic{3e@3$iN18z3<5wI%)C*{f
zC8)b|^Ll&pkssTE?VBy9LnpiQNB?Zyiw03UY5RAT+VB6zUs%=QgK&rp%kA9V3VQdm
z?t_L~&mkkNL(g88k=G73l<u4$4o6U_N13dHa~#=QW;>TJv|S&)Yc+dIPlpi1WaL@=
z8_IJKfnpM07@V=jeI_jd`Q526YF5#H+sJ1$WfXL?UYFizBW}6R`kZ%><#+648L(#|
zKP+@?#c?~dW1DT7|F*4q{drqE=Xqzjhj(tXI%Ka*HI4QY2lm)bMz^&3E?5M)=n82m
z?h$~hIATDGVmicC(4~vB|7|OmSd8E2&A8Iqcj|;Lfj)skv1`jFI7=zMf;y`?e$<YY
z@3P&ims;`Ck8Bsus62X@dNIq&!NklIv89NNW8xNF1`e~%Bgb1Zx1CiVK4kHVW7KF9
zba{Kqm6XoiyLVr{Z{NPNGB?_MLX#6;7y*F%BA)Xz%3TzNV%vmRcCK}raIp>h+C$dw
z!s($lpN?FnD-^y9M}H{mYeB$a%(3H)tmFI3t@6-*OCaA{gE~0G&Na*J$bkb^G;D<B
z=jXeESh{hYeem29R)+{E?APCkEGs+PHZEI)eo$j$r(bFXox8eTA@0$0;9#q+skQwO
zo`@?nBV$N_G!R^1x$QbwR&K84VTFhYBBe6qI{d^c$)--H0Yk0*z~NR?S8vr2XcB^I
z14IN;md8>?Lj)@+2O)$us-OMgb4~ytK8?nXr%Au2Tuu=V+k~8=Vb=eKdu+hWYpgwT
zHX{S&j@piV5kQmCFZrK~0@$P904o|b&W2n#)%wFJI`<u5No@NnlrTAUgruf${NO$t
ze&H1Bg8YW(+o}a~ZSiZ*xt%}yqA8XIk~O+N{dgWkwZ{qv4z<Ff{wSK#9|FtApU`i_
z7|ZY4!w&D;YuzwA$6PkcCf;<Xop;4`HfX{`>qeX8a|p#tqloc#&>r~~<cG*cq3wj|
z$n4hJPV6nW_;LA$+6498Ad32P4gI<oB53|{ZC-kMCq5H7r+16SS|DE*m`uB$Qbtfj
z$!$WAnQi%f2U_*Py|(?`S1id$7F*6>H0ILjdC22-ojSvgJ6m46_LeR$o(Ke_ND0fM
zUKiN+;8A1kf=jQm{X4f?@#+<}Vc~o`3Wt#9FOY}t`2KwmR?;0pV?lb=v7<I{<QU6i
z<m!I4a0?ab1oLM<WdTSVGv#8-M=4BjzC-)=HtEV)HhAoKMti<xx!lKvOueRZUm~cc
zs>&*kAG4ze4`3PKL^^cPs^DC;SRHZB2N{S7L`C}n!|cF;a!b}q_iGc>rxPiUQXZs_
zr5qyX&JBDfg3ja-Ddb<mHNT{YYR~B2a_+eN=E9~R1uL^%N0hDJ)*TbD_s|j6txu74
zgeWpm%0w`cHK3jnTRn!?Zp)|3Y|SV0G5t1LHLl!oGp@4Rzw_soix^PD;`JJluyINp
zd;X)hUbk0%{bQ?75sgg3^JZRUm*0N3TMaVx#8@JPYpY|f^&>Wp9X@Qki?>+Ww#`n6
zhf0gB2CGDhs^H}JJNdU)I`to9kbR3X?_3eV86l~y_JMqHk{J})vHjbscP@_0kDmoW
z48CBB4IY1i^@b=q6re1^8Qk{gjhqk|X;qBEZEHWZ#qZ5Qk=tl9Z@$B(U30xFgaL>b
zM(aTM7V6CY)lY2ij$&_O2ApQlm<e{_WmnnIu@fu@?&Am-0Z>Ex((sR>(3Ni8Y+K<v
zC6r@(cRRN^7w`EQ_bBDu1C$TW1rdC10!WSgX*5X4A3|ySo{VzI;Bx^1@;L($(zV|}
z8+!gk8!_P`>)s2`pfqvGZZ(9Kh?So}H`uyvwJm&ij&(%28#if+wa3D!sjjk(tCriM
z_ujO_$YUvWLcEA%@aXeg_QN6^;oQczm6erNUb@3Jaow7Q^WE_iiJEiqUZ-&n=>VeC
zhbSLH1ft2ahPIJ)8n*=by8a@{Zzv<%x<rw=+))=<c0m{9e2rC!J<29dMcCT9?o5v7
z6Y(1|{vsPcZH5gPI^5cI=zwTY&?n>w40k(DP-oS`k8J)MuV5MMLsnNJm#ZA{MZ-qf
z<jb$NaTBLnyMh9)!|Mmu)w_xToH%~mwr}2O%jVCuEvuH<iNgn6UpSLCwpBL`7k5^d
zLd!1fW3ik(t3iYvU%l|N28)Pb4MjvCo#3pA;PVo|U>fi!WimyBt_8%}6<C)mZna+1
zud-}dD{7M^D=VzBe5dVMvcL|0y6{Y0rY)Y)^gtH&{$SYlB#=22<<JR%QLGmgF(l&&
z+gG;RK6(FbTY%hG)NksQ*V^=}W?5JK1!?#J<N(r$S2+Tk-?V0xE&kv=D_*}E#2;+>
zxU=3@$T|ZPvg>)1tjGAtme;$;0+3%%ORMRh()n-MzBisem4XPBxS4&{5yi7607k$3
z`oEwkRZBWR3kb09yIyy<^}6^Pw~sTxKsrzKqS|QZ$8g|mpEt+$F8}y!!>cWxs{`3+
z>eAS!U2%<#7&qSX+qHuLBJ(UsRIkQ%Y~AA577ZFqo&c_0A)O-{`4uNl*v2)V+6QmE
z?BYZE#JPeDMtqO)Q>_2=E39L`K{&><Jr%j0=ho8zl`4o}_kwq9&nu5vl1O74pys|z
z`4(K@i~<kQ{bX{VF@StIcK$o%PD-nO{U9gby3D%E3NOCeGIL~Vg*LsmGP`8oON;N&
zrJEHFA8j2N0kXks(VTtgapTVe(&qQ=+F|QfEV2Fg^E=|CX^&XQlo<&}Pz14Sx9(ol
z4iSfx$ojfE+qz+`z5a)%?6s$VXJy;Bx^w9Bw592_od=Jyakt%PBQC!V%LbN@coY@|
zib85%MaOgLlXzy1RpO$i5vp=BXaGy^%ECwRF+PG;E1i5%)8A)I03cr;s=F!wFD1X}
z%^LPm_Bu22dw_hgWJfwDYq9q$%61UYiCHEYIa1c-+{r>TbnVm6dXF6EQMF^(@NIeb
z8lG{QJ9X$8rQ5dH#?`B^&5v8R9zCobTD{!D{P(tjcUKno62N)$h3D+~M}KLXSFda^
z2~YD;ZB~=Xmnn`k;~Jaz^#`nQ*l4nnavBgW--Dc3N6?Mr$VzAMB-JS53%R}e!yN*v
z+P+b?YirMt=p9Ab1re-1Q%BJm5kN}mo6N)H;*|(!2~ci_OK-8Bm*0f5B)<Xq)%(h9
z%X7c6ov%M*2R5#8Uwj^#cn*%33<yGmkdNQI56V~`n)(4uvO2PH&K1Zpvt|7nM)!Jm
z33rC`WGhHSM@!}|{dj>r{p+9G@{i_Q1x})K3Atn|O}X=7n{ds|){b|>DG-iy;uOb-
zP;UEpuC1kS4wq~}u}oNgVQ-v8nO-M=JLU8l01>2Fb;+i-h(KI;3`KE+9cR+^Ga>*e
zjMh8y<)dyD@+MtnJ!gF#Tb)rx=gRw5iz{~fi;vrpW%J$JS9@rm9bC8E4(%+qEaYK(
zG<fF-5WU>8-TM*-#@%{=NMAJ`wALI%tv>t|2PNAN;SpT^$pWjasDS-<^WU#M|BSuz
z%#&8WbB8O1r?|~&pO&dwIBbkv_3(eP!I-M)yjwEKO9Hi3)mB0R$%^M6vz;HjW__kz
zX`^nt-#QH)WifODaezo1VDDNs;-ZR7q*_ADZHUMY+_n!mngbD3`9n_Q&uJ3?qhD0^
zUnsXzT2=b8MoqLHH{D}7ox8b=*UjsR&6m9Vq#a)LF29-p$fzQiQ}*dnccpeCD3hI?
z<wTQ-Cf=D?ei6DsHKy7D2t~*{S0I+Vb;CMavvRq8GH<S}Te-}tAc%7b@+6Kz$-C<Q
z?^=)kgHj2oAyQA^HC*w=Y+L#4BQ6r#_aA2C@BEhK5GPQMfoMc;E88w2f*204Oo*TY
zeI|ZzPisUV%IZz2hX@uz1g**o&NqWrO}Az>8h=b@_aO@Ea!W|--p@K;b(`gMD-4}5
zR8i=5C*j(|i|4kyAax|aM{iHE2-CVkx$LqTvCyMmkzIYy!#0_qOEww4=Nig(me`(M
zJ3T0LF7GY9XUdIVr|sXguCQ|{ogP{SMe1+`p6U=g5ogP%&vcE%zRtVRio@)9$yU<K
zD*U)aRSv<jZr6U@(g-BA0UD$aQzoaxbsN<h51$qX;AW7fXRu1y5T!K-<bJ`8_glv?
z=X<b)+*=E9`0V}YZQJ+ubI$g~)<TCzkA`&YUKh=<i|+iU6^$mqBBc<_t3fKh&y#Yo
zAo>j%Y8i}xGJNfIn2uj%$bnEVzw-f`HtQx2B&oN=yxg}y!=>qGqWAO|I?}Sc^sqx^
zyKo;@S?}=^EdwIZsF$m`8l7d+A0Dw<;us2;Ng-6kGo9d6k}T-TbxWzJ+ATm6XnIlJ
zh6|jMt(}qpQj{dB(&%rM_2*2x&brK)MHCN5kEj?HdxV6E@>ia;M8#2SH{yI7eCq=?
z^twB&|FkQt_k_vT8wbdUORup4LbU0`%Vic4zH`@V>4w$T2@@@gh?(vuWvwqU`Ho$>
z+OFcQR!vIwR}s3BDRlk)-?j^9T;YBQXW#sh^-)aXNG6V+4Bka!D28&^i7>XZnh);Y
zX_Yvf@(4G}^{lxGJIEl~Gw(I4*tyj*yZ5nNf?=)~a6W^qq?*bqtJ{emqoru1$6OSY
zBMO#41fSVerz8MwGK4$)BZbzrg!IAVtm}>USQd7+D}6k^YWEJ?{o?PeuDrzBkDYA8
z@BFrP8$8m3DmhSjJ6ysAq*7%us>4x_q6npL`uGET_gDX7TNZt2O2kyMMs6-d1!u^j
z!+IeSbgUTpt!&({5-3OEmWRG;V<%2aAz34t#Rfp^hp#+m??3TtJBXRtu{-k>P>{(I
zp^)D|zjY&h?Jz{J>7AEt&sqXYAI!0Rix8WbeTr^YU>@eve;EY9+&o0TNbg!`727si
z;^=|ax<PoAm-a0P;4@v9pGg2I#ZUJBHIx>0gRETZaN~WJKWK!@IaNrUIBL6||E*PR
zSY~Osfd}695GheZe3T<>NyV*kCrrB783IpM!VzA6$xBb$s#l+JLXeEy1s9P2y%))u
z`DE&f2$UPxy=S5I8$5)7%ue^`^T<CcD1cPhf1us<{lBo`=OF@Vqei$!|A}MA?5*Gb
z&X&%3i45dQJBTv7o4my|d;m%=4V^$Z#o(Ns`Va9zv}f%~JGyZt9T^YbixD2j9IoMB
z?T3xEfI*{s#|V=r5UbVeS2*VkD>wWV7m!tuU;xjB2wIgDs@(#qIv4>L%iQ~Wif+~d
zvM!im9WTC?JUHY#kBrgi1M}asBk#ZHb+da7uzr`{h#NT913z2l%(mirZ(0X3eA^Mi
z6~{P88uk0X{3qMB;uGGvx#GH?4%=T|X5D-DwF2V*?m?u(yLRnn{RR%QeS69=<My6Y
z3!%kJp5nkDl1}gb9%kOi(H>NC<O@SU47r^F+dqz9;ZXT5XV;a)5_WG`gRkM3_d^B_
zA|KUg{}KV6;Rf~e=kZ-7t~>dSAcESxyDZkBi{<ti2-Y-g(3c9jS`7iN`rXB?i2~`9
z{VDSxfZcwdR{pd~0FwJ4UmE4#P%fs3qMAWK0%yT(4_h{k7GemR;;q_j`(A$B5|yFf
zJiB*)D<r#DHhwL0>^8mdm>u1^&I-tc>4s?}qS=E}Xw%%+8Z=^g&9X?IOeX3*+9vrZ
zS8jJAWu3_Wkrz=je>$TN6rmUF-@DiL?k;WCwlC|)=nE#=J>UBw(Z^vZwy8M-@O>$9
zq3RxUS9cNVWI+Z>?AA?A<Z&{9_HAA7$tt<Zc9L@lV$m?ozzbMF?qGId5vl5>Zbtk2
zaL=l;otBF$IRgh;C<<_46HuyJx5AQDt?EVc)W*T36v9@yK&u2mW#gg?xcGlk^1J~j
z{mH%Jc563oqO&}>vn4V4_P+GE)ofeSP&2@f-JQJtZ1VV&T$x2;WB~~r{Ym%Efh#Ch
zU%F}ut0^pZ3eLrUF!gKq*)$S2Mo*c6qLgL(OH1q^9kCO4ZdcfU_ntiw2cZkO6PddM
zhYYiW`}f;kwCQu{D`<F$Hg+zYKEv*M_<Pm|_V36C=W)Dv8$MlOW#kJejZKqHL<r)5
zJq8T6LkADqKKb=iP{qWN-6)5(#2?zD8>ACFOVF1A#E^&5*Kz1rtKpuSS0If)$y~(x
zdOU@22|Cn?AciBYmJH{*;&ompx_6UpANJ>i&obflWN4KD-~bY2e?^%_5i4m1vEF3i
z%(~MuFiG6L#eaQl)j~Tq|8<Y|N0k%Ey}Z7ItYhyYbbxdwR`j(VXuY|T>2%Bqf<G%>
ze9Ed0?eiJC7vGHreZ?&6!d!rEg}tn3$Z#v)v7Ka%GEeg=*|OQKgYG?2$)k+A4g`3H
zj2LOh@TJR_ukh{{2^ny+i5JhbyT18dE9}!3<cG|$ntZ<%i$AfafA+7o^n-UmRNQ*>
zEh5l|_@hB024xU!S@ub@=GD_j2jB)W2XjyeHJe#1J^|C!?B)(Ae`(|jxC01Xpbk-x
zjvpYKK8>t`7}r#;Tgf17)rBp;jXZ;`>H@720Ms&w3;vGMiP8dcF2Bw4$a9Yz9C0RN
z?4SKxi|;FKUKg3JhUfL{<0;e1!I#MwgJ6`-{V93<WypS+GI`j<({8()h+Tmzd{X*y
zP>v)%ir22jby|tsJYt&((aJ>Z-M3%pbASliwad3baDrk8WFJKEMZ$R(PO^u7@Sm(l
zuU-spDSH9wVRg26!F+oX<R3vNQEK^iatEZ`4H&^_Md6L}j=PC0Zdtyl;e7{8n!)^s
zNtPrxVE=}dwi|AULS=Fc$!{VeP)tC%0=cA<R}-SHDJx;R`f<yHJ1BWX&sW&J9??^~
zepzd;t^q7Oz6l3tVG*<-07k!#JwUmU(&BuqaDcU&^$kpt4q-Hn1`u4g`lAO!KQ*1v
z6zY#3wgc-{5&Eyjq#++3C1?-7*Sz)zD_!`WcZTXK*KgFtmyxQ~(ZjOR4@6+%1bqh$
zu_K2L*dd5X^ZQ4jZTA~65Mt7l@6daA0>_C0I{Q!>zewna*tu}>H1Z4DhjN&QY4S<&
zmQA*D(MJstM2REKGaPl{WY_j#;1Iwz+r0E+*nKa%?7<(}xGS!=UMP{haG=%V|J}Q0
zsU29q(vI=2x#(6I{tR>r2uSlI^O66F-1b(n4n(6X<n|xx=X5>*A5~j7Sn^m49IHE|
z#P4BX%S9}P)Br6IOr<WI{Rc|#hFZ~%6ttN)S?<UQo=q$6ClQcN9$x!_BP_E=U#liD
zG6B+?f<(cQO{=Ypd2+iJ&$n_${fY9OO{=&PsE#S@KLB%2`S@YBZ)Exn88ya{Uo?2A
z&Aj${=MK<^6U#wz^`Cw85nHiv!56Lv9N4=Dt^T+T8aCYLC};#~go{vXA@Jf&>s@)(
z%XPysG<NdE&i=&#O1EyY&4_@Jmt19IFTL8*B**DfnT1-!VmC94Yv86Qu>1FKUS}~p
zemR=UfcQ{+Ab|LDNgz>V@aUrVEqC}hi$P?5j(gPOHm=*WvRS{TeuxW5mwOQcXcj1H
zjQ}pA;<qViFwG(8+S~H4{yMUsX;VUeiU54H!rt@I)Z4?F>TB_J?=N#FhO~OIcn8cx
zIW{66c+<Pf1T5RS(OG4Z5mm#>Xq2UEh7g!;PhS3@;UjG*=9c>fWO?xXqXbrFKlwXb
zvS6Mkc{aW07q!1@$9A%b>pl0-X9Dpc$#^-b_M?!B)e98W95ZRUd;R1Tk{44PVCck)
ztv5LVV)5!3ol8ei%)~*a<kUI>Xm!U9*}=8T2~t&BE@pF@EF<cQV3f3S<ipo2*0G!A
z6b*p@xDQ0g<O!?UunJwE)$ApO?-w(`H#b!Vn-Ku)Ur7JYlnE5Nw>e~-KhttA;Dt0o
zIhABqOYQC*&Z@Kmhvc^A!WE#n<k7JFqM;};qpV=Wc<VgkJnM?y&~^BE)_v4?>%o3c
zj%l`yT%U^l%RDM&6s-C1J=?J46LRhoX#Twz?f4nEcNX$c;bI|P**lfU!q*AqzVq^I
zV)~WM8~X+R5_?yIsOAC66xCMUl?f;8R@mE0ca*r3sw+xwBLO6B7b0L2UQSs<ihsm-
zAK7LifTVO80%M(-HB`j_IzhiGf%e4q4a_|}YMtP^c+kAQ#OTq*?^_*-skx&s^jty_
zM*tV7(S(>?+ZqR5V?PMj6%>Vw8%)Ax1ORpPp~8QoNNH$J0LYviMt>%3+Vk&G<SJG!
zw8PK;+7eJ@w#*pJHfi_rcWb$pPE3mIN_@K;r8}hurEvHt>jm}qCe+&(1!>@U7cv?~
zStT<3=$_rq9mFBDG|N`9Zx1oAuYlx@PT2jSybnjdQoiPr-TU&BkDl{r9`Alia3Ww%
zfGnE6IHlzD5fU_`sU7TmGZ{#7c8#6f$N~0X9&TQ?(2nlgV=<7`jzkg7D$)o}Kmgim
z5{!r-4L{2fC5R9x(z80BKh0tuEFwDy1zH4<fJ>w^lRAs6Aw63}BwW<4{K(zNC%uI5
zsgUZc5CD01A)HJAa{1m(X~F(ueFj_Z%o{8XIi%6gkh7z2JY)6S*IP~T24eerEem;-
znMWdsG<~Xwb*n_qo9K7A#goN3g@HSE?&5R(vgk~iLz>hX!2y2v88X~Gf2yz1ABP1l
zS@40){_U?kc`~Z|Wp71<CEK?69E09P1Kb}VyT1TWrTS?<7Rl&|AP&vm**uD_yRgek
ztrVB<4(2KpuUO<c5Au#`O@ufv5rd=14{+?jeu6>UKzuvvHfbi?e0MTc9SjLT%6B42
zvm7|7l14;8N-(V@jGR1J-dcCaG4u%oePbjB8VCUPpUKI;posl92dFAzDw(}fI#Nie
z-Lcgw-^1k#+g8G29q!2E%(D-WLt11($O>TLVPQU8lH$KpTR2Ea2qB?p)sH?Xc!gvF
zNee!@FPx|`>DpWDl36$Ugb#5Z=?CkUFSV!t<KOKl_5RqPg`|oR2fZKwO+$AiAde-w
zj^plCkVqDec&<|9`V1dq2@owp*J4vAP@2oJ;g6s@bnM&T*BYRQxKElL-c@3U*L*Wm
zNB{sJ07*naR4?~1de=#pS{htf_lY<F%77(sCS{Gf0FJ?&3(h6cMe3N37;jq{Y$gWe
z@QFZd|NQ7jvn}i@eF*j}gdmVPSA+8+d7`<tUthl6%Afs(9qv2WSM5?@M4UjQR{SU0
zcb`7zw362_X86jk=ZzuaEE_OpymiClxA@JM?ZB=bcJXyLJDZgrnSf|Y(6XQV&41Wo
zIL=oAlwEWPE94Kq`GwsJ2kXz=MR9=~_Qy?`j@;jB{SbN5<kbrux^}mzH{a<?-7I|J
zDOMfBJq#x)T{zeBNcb3e!=2J7y~C7J=AaG~unF~Pp*n<QO(jmC<(64A*cC*15i`M6
z4d$YyT=G#}wz|=Ul+KhrlxFe$Vf>a3&;sQ7OM^w}#q{VnZr>UuB(wsG|5p+TJROxx
zN>It-4{g$|cUyn_<>@GUa;tWNFs``cew4%GS|K5%Z2s=qy~}2kv0Kh8;IA5#GAZ<h
z$A05c!7eC*f=-CULk9^5zy5-anRY48uyB-0SsZrJG@tOg;Mw2VF6Kl??>PZ$S5|N|
zF(t&823+V{apVgJjrjNH)NEX3_0zAhK*=H;Nkbot^&4u54Xxs+A5{iXoB&*$!~V6s
zh$0!$0%C(kx=k8Aw~k!CI4((1wWfGSTTKDeZ!gh4TY0r4-?WX29wN#=fPY{vIRMMw
zewEnyL05S69A(X@1D)tNa0Ea4oadfm*6;ELJG(_g|HucntXW~N{{C@yONV_GSf4>d
zEDy`*l}CPxcW{k6iiAMf?wxxV*;q1#l^ha55@jJmaCi^8AQmc^s^iBZj*z-YT7T`H
z($q;fEuO(Nme6YhG^b+<ICu6Ei2$`g1ke(QV)@M?c0`Rd`~V&9|0`U&Nw)~x55RFz
zk?%vLx^Z;eSw1h^u+j%qu6)5Ai{{y$)l00B)iM@7^9W(m)i(XsyFB|REfePl_fTh4
zp>WP;hR(|Qcn;4Y<S|venz{U%`*$uttB);y_YF8$Pn&t;*NE)px^*xLMNmF~7ytc#
z*_7Mwwc%4|x~vv)YvmBl1JEK@()RtGX^bN})u@mwq>gbyMAEc^%*9%i#Y{|YIi)lp
z(}}p&k*|R{b@HnTHNv&F@rVE<6NXYGBbq^gS(1i*>dFmg)Ufm}-7QUFVD?os)yt8b
z+RsQKTQ}E!G$l;i45-)7bFPS)xZ4(fVC&v|!75OON|r8gCG)25{Xfj$>4=7_Y1naF
zv*=@+|MDMvA}5!f6DYv)xZ~aj{9eyI{-_;3c<vO+`LE8lE;z-;PMyI!uyzpU+eO#h
z=nkTVFa6$np$O(9??Yo8Up`_l0`+fL#0j+52+{EtSVDZ%5@t_Ky^?%EkPf7E!>Y(9
zgQz6|=(N}aQ779Q5rBji{I(S!@+2Y<M9q==Gi*#)-`%0%uK$hB>qoTjTZp0II*1_)
zn|btQ*ICd0gKfpD&-&Uw6RyO~D<3%5CZP1)%<G>!`)T(K`pwV5pTT$(@4W8;JO83d
zPH;U63+<7g|HMkS7oUT>qk9pVeEXTltv&vWzQacOyA&Xor`&Xhy+>-8;v(|P`iNJb
zM2K$EKi;SGQ3O%HY3t)OA{vQWMtZDMH-C=Ks*WOrL3al3!B%4<D0EgxX&?ZNezmCu
z#3W0a$fyK1dQ$Al8>{uUlFr(-jniN;(|XQ{-PcpZ9i+l2_b=iGnu{0nSwrLxV-57A
zlP>M{LkOS*Gifw;;=XjsF{W_8``nYPxN&X}qn8^wZoJ+9?eE#}k)u4CsACf#1UYn`
z{LQcI(`8F^=ySt9+Wh{Df3WKwVhv*mLF``Z42_<7wOcb07Z>iu0er;}emJ7}qxWwl
z44g#KIa=n&vB+|!Tw}R7hyr{sF}O0BsNVnHcr2<I4x+^RR^LZ@z;N_{Rq6Z@nGK>u
z+`zB*KRhIWmB=jdhGBzOFaE%4KYFvFj^@#$mH7+!R=R?I>o~GrH}@CRHnpEiV+T&T
z)I~rV>@f*(<dY1d#T(@9)5}*8{{3Xm%eI4+H)Lv^3z&S#rFO^t4_W_#ByrF_y^}zB
zeZz<`e3LNm(*%_k&VN5V@j3r0@bd|aS5Lq78y@gc@Mk2}KrLcT&kl(IZc4v;e1tYR
z;yLI2-Q@YsK{@EhA*Spx6RpdQ_oBA5dI`VPL+({fT}ww=tVbWPih7r_BAVPzJ|7qP
zLb`s402&1mKOA%uQjkTxdUBG0P5tf?OYGhj)i~u=UaX9cUC44_ZW{q2MFuN&Y_=m?
z*4m-zSKFw|XIW>oeRW0x<m*MX?CPfFi*421IpmO5o$?u{s*nS>x%i5!?bbW*_Q|1o
zRdw{y!$+Lp+98V6VSNV-v<JWc=hlvp^hfW#!}PIM)2vSQxQ6puIb_M47pyzkKtnH@
z3b)j9ad=7*{+bHT#yMzoK{(3ARq1PC+J}rbjUrdabt;#bN*ecarxCw(%rEi3;0t03
za5WR4XpI1bYY_l*rNfb5#8v~eIkZPNM3yw%92cx8Ds6;(2`Dc#)knI1(MWmv1fm!B
z7-Hx5oO*>7u#8I@EkB6HUrf4qJ(<Ibcx`=aw$F&2dhd4$qV#bhh;z^VJ4<ZQtIzqG
z{eHvG@kcX{ufF+qn|1T8)(OQ=1Qv%g?JX;_=bwJuN8j!D-0#`OdWWuP@ZWgwTP!S5
zV6Q&=<mZkv)DqR4|NN6a6}(fQqL9#eA4fhNE5aA?2}A%P>krRM%sRkPB^<(ksz(vm
z&^1wEC(btxk~r;>yt9r6SZkW5pKR$6(ru*&Ab>+{P+q_m5Rh-CRVx|*vnKcYyIk{E
zljWKXEdiEaV_!FmOg<f#)~|4>&;I3Q`b@pdD$(|Lz5Tr3QeWv%9-tzKdL4C!X7Mh?
z3#esZKQCx$xm)gi&}LqBtxpN}kp*|zxxLt)dGyylNmT6r7}2(GJoIhr-LD8-q`?6S
z?E2g9WM)qXdyaZlpOX_D#6(;8+VeK!o^QLWS4eh_$2$vA5ollRTt~gFsR5<Y9M%sJ
z9wXRRiSs9G=opKUMy3g;3K~_hKy~K0N$3I)05_9cULj&T7(Joc7RAJJg)`X=tr7q!
ztvIm5JajeAM|p}MM4WJJ#uHoL7e@$>>9`2MefR7OxoV`=$17kC!S1;PE<k=BDbB+#
zzn&>k3Ua{uq4Z5lKC&%Lmu@X*fLoq66yS2b?f!>t%FN3=oa`eG*}G-KI(rU}-Rh-_
z{9f__D3?GveP6r(n>Kj(2q%JERusAP+8bDzyd6aFOLzC4_QOxAsI`kXEqK@01sFQ*
zGLP6fLg`d(HJSzLV_7~zUZ@MGN5k_v=jYifBAdyw`G=T!l|6Q%B}tpB-tei_t@_x~
zNX$tS>leU*9f$r^yYNtxzfgvC5dkPfnAPM&<1Qmp35o(yrL&%BA9Snn5Uf+H=vIUv
zwa;IU6F#c-TgR!V_`c@6x!uc18*<I<)}gSkpBIxm0PA1<*2@iR>v7pxfmQ>*^V@%B
z6DCdZ_<}Fwi1=EwVyTbl?ZguV8vPOxS}jZjp(*2Ed*ESTQYH<>SMw1sA^}v}XMX)N
zJ3w^rY(ZYnm2bXe?Rnp>EHth6^-)eg$t4~_*jFL4L%FZxNk(@ajx*_FI;V(V2NvHr
z!2;RG=e}h1+t!A19`T$|JrE^PC*?hmNljl%F+T}#;aa=434n_NMkc-F4;3xeld6;;
zML8zK^IOOl(zPFP0pIF3Y(N>bN)E|Ip4KCGPn4Hh*(dMu{hey-G3{zAWSLhrPU%v$
z%mP}4!gQ2pd>-gMXsF%tz_)Gm_zURRbicPebSoEqVzVE6#LAe6BIwquk6n4wZJy9^
z2q(~o@67Qf;~xF#zuIm0J#6DAPet9qqlV@_Zqiiu>b>~*BUZA3&OS>};Ai#RH*BJE
zCotXg-pT^jw-9!Hz}mt5c5cc2!>yy+;^g`5eeV_PMkcl#a6+zD8dVrL#_!`FzG-!f
z-f==nkPYN!q9X-t;0$U7`Fev4N`6ED;V{?X2t+a1mGS`UUb<;~2eWgZ`*~PHY%8U_
zC}-V4*NED5oMRg42L_I^4m32$C_DP;BC=YyTUL+0Ht>p@EM2Uh3zb5>9h0dP6Z7-1
z{@#O!+wBkkz=n((?N*06Sgd{7NAv9^kQa?$t?7Hm!{4{_CljlO3uql*#q)picYp0^
z=uiFfCsu(OdeQWmo`)!3#jtS`>{dqDGr#<??Ph|<*@E2PS~PmdCHMo7?P-YA{_G#z
zLUfgzx=3J0{gR$1>m(e#mCHV`GQzwaE+aIK>`%zNqkq#e)7wE9m57Au_g;Vq__!6<
zdeI1l!?gh-fc9G0S@HiHDJ_T~7(2ycq;~mG7j+T>POQVRAcXVVk&Kp^K9uR**rgf$
zsLSyrTE5$!)T<|6U9n+>Rcu}B3nME~RD}K7eH3O4FQ+yh-L=D3&;FgSpxs7eKl88_
zW9W&gb^CY!!Um2Q>B!e8sf4R6c;`)f;n82%(F6M%?x8h;ue$9HpRl2hQX>?;t%Xf*
zUAKmXB@f%?wQD?n-yKe&`zz<JBMzP3%yTR!DtUygp0feXdpwSVtLyNwo>?8|{gv-m
z&;6^99JJ13FSI1ATcR|LI6+MvZr(jReQI6&K$%r-BA`USrja`C${yD%2Ox%Mi47R;
z12xvQXM^iL0Y^=)U)okv=R_-e-#`s<??w=EKx#l1sw;mWHokd{B{#1M>u^5ScbMhf
z_HE0bd7b5rI^S*6d~(zXe_5?BYJ}M+LTLgW#!aySSKo?x%FG}-KF&y6|Jt**f91zb
zYMuVBMsU9o<Lu^d{Tb^Bgj2L6l(ZJ`VuD9=o_U-lV~_hNkM7z5htq|ZT*l~bRB$z#
zdSR|=y1KG<j*)hyyg$j&o^S^xeM&>u%;rLfZ7=EP`c}}{KrJS4oakt0#G}k=rEz6p
z4ILtrryT=M>|GLDIexjM)uk2ow{*h0<d88Xe3R8~T4l9Ns)-eJbyH8o>8asN6AN&%
zB^&fM#;CqlqWJ<R;ep%h5pRhAE?{RCr8xm`(_jp~auz7^Vag2>jN;_xPpQfwd;~dP
z`)-&eq;M}CC=)7;Fs>Fg5__vDM%fa#NI_c1uGa6C`%#4YxrLx}dzcnh{Kg+#FNo@$
z$+nPbQrCa;2R<@IP(r@*KlZg8Y}a1BZ2%))uGam#Oa0c>h@&DFXoxa+WPzxEoRjqJ
z&$$s+fkL=vN3m^L!;Bl=#WQ<AjEF!wO^>31%uCz@5$ryb<~G!=Amb?yww=RhRbMd!
z24cvxeQTCk7CJ%_i%DD{3HQnD+1Ij}7?REG;CN=P)zYsCR$8rPKx&4tJL|-yRG;_M
zkc)<0d{>DjSAWv*+>>_Rh(y4(oM=t}>JjGl2Q)GwfTTFUwsrhQcAY=NvZq`T#<Iyx
ztK-vYiV=vN>C-Cd1du9unFc2W4eK=hTI)$}o6ZYWRb;hpn*FF%m+x$iLQiUI%b$Jt
zdf2Roe@HMX<Wiyhgy2L76wS%g^ztH>jvYXZ;Q(1g`$){x%$?F5CFCY#dbCl&87%?t
z$`$SGfWv6usIk5zd?^z?HZhw=?pr;_)4QAqIzj}4AcAr}M0Mswkf5)$8d+z!SB!Sb
zqnE}A*2Iu~i|1Je!5xVJ5r<+dA_ftNoI6$O*W);SQ26RMuf_p%gptq6D|!dn;6OwK
zE&?RBTXF!6%-2K!<Jb`gXs!d$5dkZE#F*RXB7oja;=)aCT<$kZpM0fdu(**rx^^RT
z`G52GRzntRwp^6FP#TS`Bt#j9QUw{k23qf%@3X7|yi@#^TX{DY!M+7=`My^=gFk)G
zn`l?u`yC&NYM<Uu-}76;{Jg9@J|syS^dKJ<oR{LKwyt0Nv5NyO`MPoCGFv{MMWU83
zAps>1_TSwJTBAGz1-KXTzB^)J2NB5~8`oMDUk&MnqN#cPLP(A@cvkt)WD#XFpDEPR
zhFFKr){Z`w7*J+#I=}bMpJRuYedr@Q16eOcT>M(5v}Peyu3l`(!~4R=#mNgS-D36h
zeG+|4L7}Ak_d=XI&Xm2?k^pqe*EQ<N>TClTDWE;1CSeVvI?w?+=v1aZ>S?l8^pFNG
z7n#9nP_btW@p2ufUPab$Vdx{^ieqIvZP%O6yF<wDc?N%aU{zfFjc@vwLgKLRI%xUm
zks}^CeC0p>$zFcsXSjNIb6iWWQrOBDpoOLy^6YqC9ipI;`G#e99iRKzKiM14JmCtS
zau9T#W+xB9oK!kj74=rld)t?l3zu`{p1gM#l0IkN{VgkGuEUvvoMF2`w!T;<i$y~+
z69jgec9q4C@TJlPZ)5+TXy`L>xEj`5Oz@G3lOc(2Q1|>Vtd8krk(*d`<b-O&4Akjb
zaezVW+(MB_*a)zmU=XsC%#tXYm)yO>l56pxNv`81OeafNX<%u%BQu7Lvz+s%!@BT7
zL9y;+Q9K&SqIh+;t8eo~kaSLN%U$ohWGA!|1}}al(0$YdyBL?MKI^9GW4c=3>s#>R
zv$mWCDB=*Ulrw!`LM&V2N?brIhAx};t`)CZN_e)r^+$XtR<BjY^)*m^L8O#V$|)zH
zGZQ+L+pkfsqLsw-L8%Osve6e`;UizeM@SP9C=0qX3ptgO0IH1LGXbss5l_psc6dmo
z&5IMH!C8(oqHDLTh7cKB^si<;S0iSRzdhR$dv=84Kwepy-ol3f|4J}yyesbF8ZzCJ
zTh^FypH}+0o-3Xa(vMJ5cVI69ZmdO$-KpTm80BK48vRN~Uc(2LKzMA(D4)TaP6r?~
z{6=CH>hyFJoX)fEU>%#ou(nRl#?;v3OkzB|WM0_#=y|8H?Z8Z<i@x@tb;dGLWKE+q
zU|8%#Ti;54y;D2)Q50^$3r{omE}LZ2QU3CqS1hsRbKhhF>J>Km+MBHhOVdgh(W+y+
zN!ObDhbLH;=2JfWu*?>{!#V^cskr8^PUKxgXe!Q8IHu94PV<q=erGtr^!vVV??3Wy
zc1)(15OX>}y@O1W?J)KtUjjx1m(E1cjyTHpq3j)h=Q*obz5w~ok}&&9N%kCOxnKL9
z#d`MjcGZ<JTbRB~Ze9VUAjQ!GoFnVmw3FaUTm7upIV=u<!{5F^k!!Fybn9aQQ<B6s
zAt<Vov?+59xx;*IOOW)CL}tZMR(uX1$W5@aCrNe?1&W?H0orN0STFm!g))lEU;Vw+
zlx%4JtW*4IN2>Xx`+vat0>imisILk!YM3%_y7XaQ9wW69#Zpkq$SP)L(YnPS*^2ky
z^eI_AFsZJ7;Cp-%5VH>Ut`ur5Z=>~kl$E5(n<p5-`gqk)zDObmki^F>GJcCu1QpL8
zaS0rN5igOV8Ob%N2&oX4h1Jm!3uy25EmlKh?sP%=kiI9>4(^tu-*m4S3Sng#qJhya
zMLNl1P#NQ<TK=sMS%wB394f#hjrA(B*q~9&5@JPFl6BK2U5SSuZy{Zy`zBUm0qok^
zT2oGN@KN>TVM^<IfWnL71iY-sC8RFxgpe#Rw%Vuu)hd7Y&sM?eAjhA7#E$;vf7{{T
z|J<s!ZGdgTDY!BmDIgyLIkJA0Rjyqe-Qu*iId~2y-2ENv;y!eOMl?vDUaN!9gdokY
z?=@nqjl23LC%EXQT7U1@o?X5Wg^rDxd6l)pb;=?ec8p0IV(lj|_gt1^{wY~Q#IDg@
zM_Z*^sIGoTBU-<uTh!48E%>nXjTfzwkgr&^G<LOd!Z+}ZXf2=91^T#R?Gii01d&J=
z2vAD%Ctn_NT<#NeF0{NWZw+0+QWy~lnoz6hV1e>8FTaK4ojxA@6Rx~S{<Hd88z7t?
z5dl<CL<B8CvrJ);0^QI>fN}(y0&CMK?Wq3!*;fDItN02&wff~B*ine$#HvMbd=Wrc
zG%60wd*f6eL1=n+zNFF9#@zKCcbW)M>S%qoWzG9@`0hFm5fK5%h|~EBElWdh4czCB
zMz8Cui4A=8+H8B`M}KK6Kb-5{wt7TL58?>Y{v|*4;RYdDMM&|KEpDuR-9v;|7f<*H
zELXhsN+S_~9L<Lub=w2p_SV|c+A)1O>>w6V4QnZhyGR$vCd)SyZ>%7F$XHMG6xXYV
z%T~Sjl2yO`0;{qeciaRd?wU;Yl=b5m@t(LqeYcfA$Obzm0;r@&4`>N^tmMO|Jx&2h
zDILi21|VfT=!aP}`5JVA@eS1K)v;3*wPL{d2-4_3hW%Q%b92Mxr`plVqJwc9X;!g1
z#F2-udp+9ts^=cH6)*qZKkT59Dn!YJ+9n8TlsZZ+h|?-vns}n6Wi;BIi0E8t&>Hco
z<4AS_2=6M<6W&9F5$Xe)(YzLsw)TU!Jno?TB(R9Ov*^R{uRn}Gq@c|voqVEp>l!<X
zV@#ix)1Xl<M$V+m!<;{q>(E6E0g_Wu_tvvkKlcTT>$7vZ5$_%#4#cJPn`R(7z%in*
z4UjLpQaz?2zLPSM(j1gY0ueA*OU(%<d`PorluH?mUHNrO#~Gx&J`(J$o<$4l-gtuE
ztG4tplPwbqLN>Kze?63aoW&27!+ts->!Sb7_xs1ABjjr`=1$VcH`3vC#2fUHXa##R
z(J@5H$~El8=T~+ve7}KZN6*qX0kx1sheGrkM8^18w_4G87rHg!_Xpwoc9n)=%LxLu
zODD4Hquxa!H;YEU2wVH=>^S#c_tKL%JF=`lNiXi+4brSTe*Fp-(JX%X3F08FGufzp
z+KLMt{rGLmhTvl;g6g|WRsl&L$KsP%2}+rB{Qw!CHf@&cKY>#AbS>h*7mh+tQJWkv
zT``fOUro2FvX@e=e$%^XST<b8eh5O=p?!@f<YQK%p@8XPv5RKnnPNH;ik_Az$(T43
zEp<5A1$+Zw!gMgg+PB<QNf#9?WmYf659&S@$ahe9!@br6uc7X(QKi*4b}awI*0Ts@
zEz8je^i94RjytR7EwbQF6K=oXhFo<k3K>cgTq6S2UH9R;K4DY!wJt%Qu@~?mtImG?
zA%aC47tZt9N-hGZ6Ulmsp6Fg`i$=fe2kfhJL{MGFT!;dBfEdETkVts2+TLr*Wmb3v
z^0^Js6tyqf#>-3WIJSJq1vm;z&nI}6KA3E2I1rD63l~`C4fj~ab?EN&yPA=}KcIGd
z{)U>x!6XxI_%fERI2m*s;k-V^w`ODyDnmls<{)J4E)fR(!BRM^XJ4~HEKqdKoyG@t
z!{b~fD$=BcKnomUs-&ZFODWRvI!1p5D~Pp{oyytfppNP^eU|m)BU8BZ8b;jy;?1`4
zdDa3*AzxS3qVexoxtJ;9a35Y+FOb9NIPaFb?SgxMVC^wY)8(2bp+m59>4zw7FR<Rw
z!H|W6*jfbc0T!HG{PMFb(~6f95Yal4xu>&wxPx;5`oo{2XHg`pH4SU*gMVq`?)kp2
zg{+`XBp#eYK+L^nTx*?Y+<00<p!NPL;FR(bs_#5b0Ebh6$FqcBNp70+TYdx05=vmX
zB<8*D?%)O@5$?1;Wa|S?w_XqKlabIY=74m84wUAA7VU~)WM86a#P0f`KTJ7cBBcnD
zjIsn&moX7GNJLQQ<hs;yrU_;apAO`WpKd*`WWF3PErrX?84#5Lv2`H_e%~kW`hrxt
zmyojQr6;TgMQG5)SK`#^N{E>e3E}iUf3kIEs(B4su$H1-&$9K$N;cbuInTi<3TzY;
zQesqA%K6%P@7R`iUutNcddHE+3rLBLc$VHL@;ruhlGcGBP4{sZA+K5EkH$)NtKHIh
z#KQerWO*U^4>g2)k1u_{;W=&X#CL3DsohnUJ^8YRQ7@z?kmt1<5x+8F5qHXCNPwT@
z!gno6$T)!0sEq=Bl8>p$;g6Poh3hRk91(zOg6UQW02?xito1+x6~yY3lm?&!$>{Kv
zDii1cxZF?(M|s1YVzrD6e(lp4{n;ZgvL3LtG~{0-U&X{B0|=n24Y=VOgiEp4-<)k#
zD3c-pWf*TGH|`+LrD3za#-h~2na6@iLMzZ{%%*g}N1&BAKKbe2v5?YnUuarlAO;o{
zHm-m}xt5<AEo!%vz;uw$t|PQj1c*DxstJiCOUjvxDTpO?ybj+$`HF>n@28*T^d#Gv
z)}%wgJ+HgdQ@g4+;<QOUtDzs8?qEJwFP(4cgxD4Q(X-^-s>TZ#U--5f?FzOlC{-wW
z)VHzIz)MHJixYwT5am0X-nHp|DL;1VKtur2P_|M=P^7apg4O^a_MAla>x6C|RY>CD
zORT^##0nuy*taA>iL`6(^5siaPaRT65=neJ5yVqK8a8a_Yws`xKYY}1Z4HFSfX4Bn
zb%kNKC^%hF^70G&*^YN!v_o1Z1;t5(aCpsPTft};fXlhxMbkb1Uh1c=4^YV3<Ed+p
zLUo8G)-*!Jrj<LVeT`JzBLcNu1gMwQJLvnsI?pcG;U8eD(=t7em*IRmal$g;Dvl^d
zzP^681HVXiuOjPr`!`wMy_=uQ#8m4__D(s2qMp9`EKr}-Fn1zz!Zar!Y5DGlfq<QO
z5EV@!&<rj_o!aFMJ%EmPv`x44CTh8-N&#>rkK6qt(Az6$?APl+QwX-9BBb;H9rw<_
zFP(Vdx0ZaFvK+0ucnu0kM~f-_3lExDVFJsb4mYN(g3kiw78Kn4pk*_<eR>(K(6@q0
zNfg=k*uUGs&1+o=6jI`{j|=<SpxYj_qC3B5StLtDP_uuxZG7sdw(;Fp-9s0daT>7-
z=gNxENEWNsF(Fb#OT0D($x+5sScg+05P@PMlKY_|2v@@Mmk9?bX02mI1FIl}qvgA7
z$J-=o9^PjsaPE{6@X{h!-gXEw8zL-Voy9=uUY`Yw>RPyfVg)?Xb%7axD}(?5AOJ~3
zK~yvr+v1bzEw3U9NW2@0PAR<*sgZx!2Iys1ApdK1-U)yoI=F};r%-bcdnwu2U{9(s
zro6K`&zdcpOD{DdHyC;zCL`fXs%W&-lMkQRg3S6XK#|G2f=|s5O-n%K>fl=B*WM4`
zw&S0?MNYvYD|zI9+phOt_kc~L>?!BH2O9Q}`~KVtE}Yr$@*>W1MA1Rg%;Y4JCST2}
zTYFi)=EP1hIZ->v=XgW}LU>c)RLTbs5`o$zkoT>Iwuxw*Lu8ZBcl|ef#m)_n{n*z2
z^6zc^Pkv;FS;9>woyxI=?^rp`FRgT{Q6`g9>n!G@L@P+vCh#8WJ5R)=z0!qPHr;{|
z7qq;jaDXK}@D`p*LU0}cYQoi;TqGPXj(#_NbCHZ>Lrc(d<XR9S1<FG=CLT6WoQ}&W
zH1d2`P}E;Z;sy0<m*R?S-N)p&qBF9lUTb-*e<OFU5Tj1gI(W*R3+P}${4j|eFFk6-
zd_v`D>GseC%tOQt@=?MD;&AE1%H`=DyL$Z^6rv4$kg0gVyS9tq&K5@K#upy*X=x%5
zv2-CYGUXI!ZwfBDoI`~5)F!=a9JX7&a*0nA5doq3_~eV8q{J2SEgvbA^(TdDMFdCq
zY|bGT$J7_cbuan*^LgjY375FfK(}udFyZPI`=>wDr^@pW#$4om-K_pF1|B($0<VXo
z$oB4RR;9_09qhxdLrC!qh^u>daXs#2V=2wML`nw>7AIj}VuRBDJ+8hQrV+9C?tLw|
z^akdnhYd-PeG`B4na?DEv_a!6|AxC==~GZA0<Dj$1rRfO_O)8Yzh(N-hT5_cJ4!CR
zJd#;x!Lq;g!dj6_zV|$`ZL0~2)S+$b<J5=fy#31-pdT!0bi{zj_H<ZB6jj&Kk=gqo
zk_vs3F9lgVw+p(4%q)%m3M`w05@it23F@67_aF;-?yGjuRT|Zb<L9w9PkoSXHRbd%
zvHk{Nzna)c8i^muk#L=ZcZ~Jy!#azl*z08tRh#XIjlwws&$Db7asjSO$`X*LRiL$i
zuDqRaB#9vU4G{)QJ}}#~g7%8Bw}7`f@*Jy#IbAm;0M*W*T%X#qNdXO!S1hT9plG;n
zk4_I5jU?J}f|K~H0~D6f5rO>I8ukm{3eQFNX|fH-C&;<udzPV`L+<FSU?8KNt3V8j
z#3_M9{%~pP^~x-QD<t43Cs<gy3Ri9>=hFyLM-C7XMSGUBNv3D9w*C%SFisE=ui6&@
z`}w3*cSu<(nuxj|7j-4sP7!Fy+s-WF>>fQ1D!omy0(}Zc3ocait)8PS`yNAgQRp_A
z2BA<dhAhs}*Hc(-u@<LLf@NPDfVS6^m6A6x*13kG20{+FzE1MG_0>HQw-7*Yva$+`
z!uJ%>^KMp}YVQ!nETLmrA`VzZ!8@~=4%RYhg!46&|Aok38&(Eg(T>)QgA2%QbR(sS
z!#`C6&DA91akL2JunD9eu#A~Ff=$1U$$tZNMnc?@3*N-A+}6DF{Yw5I`!cV)msD~H
ziqRwV#APEhSyb{k4dp5#gmg^KTrHePP^gv;bfhAOYf87;al)>eys9Nur6r3H<d$xS
z3tAsqsy?`n`!+#B>iKy?$3Xz2Lk@rfco08DRTB=NFP;}L<w~n?JEE|=^H5OLhAMs5
z79!Mrk3u-LL?xB?;B|Sv6kvVdFN-N!^_;60H_%8F5yCAq&Lh<xFQx7)P9Oqs@#m(Y
zKP}bD)JE6lqWF<~qp6(kj8lXU1rv5`#&;XUnVo~`8DwJz1m&7>pvF7W82d+X-5{46
z2taip0Bj5w0WHNqf{`SdOvkxNLgSe@X90^mInr4~QZ}mt9=fF1e`|hd5FWdbl<b+;
zyTeBHl}uVW_Z6$1`@Gd+amd+{&gfQpv|cPg=g8_+WLb>vdMt}Lac^-0rA?h!OMr>d
znZfAS;>teOA%<*LHOo_d^?Nz;P@EtIxe!3R6alEqm5*Nmi;m(HaaQ20gOz8=^u?*<
zR)EA(FYJ2mS*Nv-@v=ELKtZm+(G(-qT={(>LV52ru{KL<_H^iKb(-y@k<2|ZFP!1&
z+<LBxvUugxiSy}~WO+&J1BQ1F#=?>CYAPn<An{uO+rJ9-p9%n}PhuauZr0?Z9bskv
ztFC#2^81MW>u56q;6xH4P{kW4DW0NgAq3d{Nhx}aItMx@pmD}Wp^atALh-<v;*IE;
z@6zdTh?5}bIlwY+d59%Vq_8n!V8OM7jqBcmVC1*P&aEf!y@tsX0rs<;LSBzfl`|zr
zor)<`R}MGe3mT&IYBH58%XibUq^T)3AvdY&)6RSlCd5?HrU=1V{YO|k#DGSV>SYlZ
zPy$9(X-RlbMqQN<iyotimP*l529km?%G}LC@wEH`tC1HD)~zpjR*=mbM--%qLqfPh
zu9UWPl;yZMfzs(A%*=}}^F$7HvJ(JXXWtNfq8L%o+H&t?X4$X_#_E$kAlxEgZ9o%I
z;4E^kz<mN%3Jb^}YGr*u&bo#7w`|*9ELyc70BIL9DSh<28K}cM(FkWbupcReA_82%
zNzWX@S%IQt^86`#_+&s~NxSg@_Y^8aND$v$Vzs~jDH$&~Ef@{XDq&@ba*pe>Xs}=J
z)Rc@<peUQ{pbQkMI`n{qKBLO$uHQ%EhY~8NpCOh^eUD(W&EeZcX`Orc3?+>ceRwf<
z2ve)&zEvZrBd1L^qN4^SQsO9yK2it!K2FASf?WJ`h_L~&ymL0W1)0o*s>S4rYvvAp
zQzOD<ki>j}rf}sBk2K=b(9B&uCj*n!*}gah@2NJ5800$F2u~<avZ(^8b7Jj1i%j{M
zj%<jQ*(;W0;qIgl5b9uI1dHCYV9h7sz~4$&HU(~M|BU>Hni`=Q2hd>%pq33n)uvNg
zoDX>6B&pv%@0<z}1HOh3-?4LcEsj87g8VF<Z3e-_D=key9y&shM3&XP{<I~F*Lq$-
z#w9me#s!z)ZpQtI(x)`2I+7aeaIh%dIh?G@%R_kjcw!bKQ3_wZ*2p7r=`5L4^eSAt
z8CujDUx6!#A}qMVF@iy=Q;$|(g(fdCqjWY$0(FFBeUvH5sv5OrAQhRdn0h68P8Hcd
zX}qIi6j6O?^x1HjxY|%w;xazYwx0CyOe_t>?}gkt#qU=zD0oJOI6$W^j?)AhenRc0
zKh(|ucXtA!HZpu$fV6!#v%|XH=Y0nGdwJbM`z(gJX@}s(EkP9VbIN;g`DSNZAeajJ
z*4$xg&7u@EtF0fh>kD9WBxX7X5En=(VLql6H<*tSa<csIQDm_j@8jheNvbHD7>7;b
z-Dl0k!Z-d51!<C{5p2p}bSCjDB$Ulc2gPxl*6L$RuwS41PQrycObE_mRHXIjM<<ts
z2@uq;M?tJA+vRf<q?`!}`k2CTT*v-(Ek;xwlT<562Twr2KDx2ZRZmG6@<^tm&^BoD
z;xH(*RXcEOp}?j=jA3#H7r;f7_rO=8e9D$M4D;SBbNtkhWALncd?@uI00<&Y9Dx4P
zv&3oSD^Xsbiz5_kR+?r&@UD@WM?DAS9*&=8Nd@J^0i-<AW(S#me3?C1g4k_+^lzu$
ze`oZ=W}8C`0?=s)Kw9EJ$^{h1E87rwp@2k#q$nH&I4jo(OF_WM2|j+49<PlKxz-<C
zi~CcYLj=P;5=5%vFaE}5e%fWXSsKX`9&pji(GeP%^=RjA9#P-90h3JYnJgJ2K}E`$
zk8U*M3~cfYxIv;CVv*$mD3d7*8JWgJ6a{0nFy#sCW6zRFwM@&cS25eEmJ#b>M#KVP
z3AyRWaw&1~Bw0X8s-$CO*3~c*r;d~~XY(LKL(3;(U>?`7LI>Zqg~fNX3^JyZDc`&}
zRQ-wt&iT@al)4DuIz{*5bI^TQ@?FI3vwG-LpMP=kY#xbLrs|o3PilXYK4)2Si@p97
zd0ov%x2geLXirj})!^2Fra*7E1Smz?+wUj`TAt;|-W?X;r<T0;#zd7sl!8JUwaq~8
zOUx=YT2+#~c;dr3UN3g@!z7l>Xc$o*L*TASSpZF6QrDtz)y$o3$Da7He;-H7#>-Ko
z_(3|OsGTB-15gqHDSQga`gtDe?%ZaL4O^%$ZB@Mcob7$=Uy%2#vVn=|;amt+GjKcJ
zaF?~a^M@AW>*#)8>R0h$%p<IIRExY1?=K=itf|dj31VR@8SexVjUkBJ!@4?0@uUri
zDvrq1;#uA|h$@r6W%Oj-sSyxeN%~e=Lo<Lo1uGyt5_H=D;qVD?+Gqwfsn{w3q|UEp
z3orM!Ho1gd*jzwdJJ?;~#~Yd?_M<EmvB3!B?`Bp|GL;`dBq?+f;oXbf^OqKr^?;VG
zdqhP!1od!;BqLPZAQ&*((x+c<Y2z<(_7~r{%uYP^Pj*7N0m?z(LYN?$xz@|;=}%V5
zw_Ln>YYhRFHUUDe-@4ik{qCRa5P1PLn6XX-T%aVETnM!NeShhxS$+@IXF+Vu&<zPz
zokSzVy#x?zcwG4bdM~}1b~wteenrKPty#!Ci>2(+N}b?6)MxJH({&N3Z}qY%@IB%!
z!AA_HrhOh&2=De9Ki4%LYQC4={AaUY;^DufTuVXdp9BYX^We8EiCmBD(0~^Vn&!i6
z1T%@0*_m`sO4~*5DbFzW_3xq&z|JHR1oVtPK|_)so~{y$zXnUglb1I07R$V3mMdR!
zFx6xJ)G!4qd1#MSzwm4KP2`{ryC~ur?uiWV=zZn=#bF^t-o~a7V9IGRMY)s{hxhr!
zi^@4qvF`3x%e(w$%R~=wYl8Pk$2FaQ%Y&qoAF%|HPfs2dhf&ih5;H=kz@w%77UCV@
zYFFw#y{`VKx{ixzl=nX$JjuGkg7M>u?y2uSX+*C2*4Go_UVaORKhT<ut+ReL1vjnz
ziqd36>Tn~pNdT~nB#TI{q3UePcPS}MHC`O7m~SzrgeAtouJnQ^BhB*AvDcHz4oa<3
zp)ZAc!&x6t)1Mu507p;)*_wFw1w;sPOm0z$5po35G!jsF)V1<Hrm>t#8m{2@qPIe=
z8|_!izA5Ifo2$bG+UOb=Qv7fc5RFjolYZWG%hh*}<?Mm&Y6aA4+}G7_{lV&2EwJOr
z?W~!s#-WusW$6Ht-7!o`5rBIhb)B9mWQy3)OB}=jXb6YHb83{hqkj9}@Q?R~h(Lhm
zpH#fz(i>e@NV0Z;$s+m`^HHhYy1$Y<amcYYtKTnRFa*ozhu63KE9NKMtrRX>o(_++
zKx)&9Tqt2KF0h%>@+L&b0+xIW<eAe;%G=g7QDMR*mh4r;r6D+FOUq3m-(?_jO^8oC
z_X|8&X#I?AdCeU8*WKe5hPqA<_aYM#g((7;shm)qu%2oGAX~pRLNz+I@1W6q-o=)8
z^8=<8wPntFE+d+GHW9j<TOTH&1;uesiB-M)C{wYQf;%FJT<l^-hyc<?Phvub7JQaH
zPumEBNyC@Oa@`2TdYg1kq=1ts0w)+XQv?}Ntl0mOxyW+NPp`-|>N~Ql9r-%1zSSTT
zap8#!lxNu_93S03wcX107vPW!+J?_0fYfC|zSv0XH!4F0&4YbOi4m1YS*Qd?l3KG4
z#VCBC@NUt*e?E?km!y(P-h)tucmW+8OyZk*5B_J15&Cqm9*1?EcPP(EDA}<I_&NTB
zNKTC?xI%;+H9R~=pX2AxB$ZwB8-&n$6w*3z5du!iM@T1F6Z3^Ixd_%A2O*v{q<hfu
zPQ*B)#EDo)ko#&J^AE(w<R-@i)H|q6O$#nhN4VGJgr5_~;0x;wpb)OOfP!K`lJx+S
z3b5h0a!}+|1VA4I3*dm_M6H8v@M}tO>!%x!o{|8dAjywsDDx;$KeC$wDAPp&3qS>E
z&=IS%BAhfm`|{EuLiEBR&;?>;=nwYzKf|ErH&SueJ{H`DZh)-iBYYrVS~DF%z((0c
z36!%s))Yu8)G1I$r$(AORtR?l=^Vr;nI92B!}A&4nnmNGU^=pbe8Lky{~wrlthONp
z)9GmtfsbU}pAOdu4_SSRxOitJUFs7yy01D#MW51fQK<83w~qN=b_8%py-UMUh0d?L
z3t4|DY#){{ST>KrAZ=g3`}8Wp=Ynn^(ETYfzSb5jekVNE@~<xakn%XV<ATqIHg$le
zmvN)L=mY=2F?z<jHa+M2IEUN^E%ql4ppIk0qMR0~F7s+qj)Gk!7QFv5l>Py|rm+c7
z-$oLBWA2+zZ<1$B$JL8?3lpC%W?DL0vL;vHz;O|w^FU-)olIszgjjEgq7Z?80d17L
zc7)QI31oc|g*FaxX*pXbSU5ohYKMv=O$4G{H12wG3<6TLlq9Qb<adZG0S3>Zh%me+
zyw>+!2Vg8|%^n<0A}|*X5IRennWuEU|5B*XDFsh{f9X}|Pe~NQK%ak+$%nf+U`9|g
zQL8pJ0t$ou131HkIyE%D>8a~}M3qM<e?@5&Xwh}Bui!;aM;<_2vEDJ9cjSm|5%dY(
zeco(ONpuygxQp40oA{K`C6+|COPdcnj8RmEJk*!TmcG|mzv*6zfTGU!Q{K_+AzyVo
zI_Gj%6)->JxQgY{mHf}R@jjnGk;Ym>9`)mT{~S(aR=F+_-o^ilSOKlPRrd#QM08JK
zS~ugQv5UyzGLd!T90`Yz=knp*OTPWAUvD^yT>sE7#Q`Li3X3e@eS^|%`1vn!0`O=d
z$DKovdl9_!+m>EJ-6I6C{{Nr|SEmJMLIAq?k0}>Y;91QEH$Q=BA|mW8NhkPd(s4R7
zz-ABL{JqOn9r96+(<XV<*Ntz&Vs3?2fp@av37;-Bdk11+PP{L6C^@KLlqRb-ReVwe
z<Ja*g>Ub0qkRLi?^f++}2SUhlzoxSglT5srMx!!np;FaIpwK4t>=d}78tpS81FQxY
z4|2>PzT#SfO+=^2rwDTR1r`vZO=`Ma>XB{+lPzsRzD%~+D7=`ONkZs8(MH@#+*6B0
zFx5RE3Dy<K)Hw5jp*HBfo4$LhT}?Lg*#9M?A6a~QaM}dGO=TAD=eB=C8AK_fv<{+p
zl@$2P4ToKB`jkWlI#+>>$(VvHg`!lZh*OB=2c&>`FiE3c9ee3*7Vup>Q<8`}cn2N#
z3Gy$sAVO0FH4vPh8*u<3!I8@!0r!Z1__}8>r^&=qJ9VCVNtUy(C)qXGbUA!n+7cHI
z+%q_Dvc+V!N^uo3WwAuiqsU^{-5rWCZW;;<ZZ0#JNggIY$DAj^_aLD*AhXB^0CNGg
zD5tkyR+6H8JgWiZVN?v@C<M?p6m#l-f~P%gS7~`B<Yz69w|Yd8B;o{m07KMfP%>Ms
zsK)o`Ye~sBxi$r2x$=2S37T<(B{8{trZFSfQG-$y;On;+e~aI0QP@d0K1AK?e7c!;
z0IV|T*~d(aSCW3Mv?paE2V~!P=YiZLW}7dF07nT@p;t#RQOv|*h)SjuoWxf<>&tzJ
z@OgY4-K8G)Zc>C7aSOGZ5N)8OOKI$CsLW6TRso^lBu*<&y^6#Ri7vqf7rR^Ats;$N
zY3|Y!Bsw&4gFHp&WV!~OCLq!n5W`5~cJ|1sIGXy8tpgT8jF?F9=_m9_eR!<pUs$94
zi1J!%{{EKL8;>+0v&Ms;wFiZ%6^~JVLxJzL0*s1)>B}*~uToqb^kN_{iT&;7VamDU
zos9w(yn|x%)W4C^w9Z9_4M);kc!_tsk8+6xM2S0G<h;2Qy+LkfkmaLS579_X^;;+c
zIK*!qR&l#qTY<c9n1C9keqQEPQ!i#%i=|g^I^mT}5Ym;I>-SL<j-0~SZQrzD=B=T8
z2El<_F6lgsdy*hxkN!REo^B!^z!gJrF}}gn48%beFt3kU!9=CP`$rXod~z#-H=g_~
z)-N19LU}TUo9OD(+S1xH2Od<7IN<H9KV=rBB_Y8cgBO2=B8x+2!qjl&P%-+dmE(zE
zPCzc6oJqEY4vQ2ojTU0xNkXlz65{W+4_*n)N^u12aL+&F1It2)4;FSDk^FX$CNJ5l
zA3CQ8YV<~+X9!WzZ^_`)RO{%FZ$)&NTuC`z@C*h_e9^iGPHC`fljR~JpZ~I(j82Wp
zk)-X)8uBzQ+TkD~iv~n^#ECdL@d`__hN7Z}4FKoR0CMC<x>du;h8;D34n<mj6Is-7
z{**gsMF6S0?qmCx6neqe7I2)V&V?I!3Yj?+!>yZODtSY+jI$cmK^aj+g@iraO6NoX
z`%aSD<#Js0l&~p(!T!N!lP)7tNJj~oVyWUR)M*^~shi-b<MSVm4?jX$Sa9A{OTN3i
zfzULkUfIrmEqR9lZdjRfR)#p$ax3CeO0baWiI*~2UV`2-%L3^xLcT!qUCFRw=~^Ba
zy~5?WoI>CE+mPUK7&+i@ViAIHUw;W3CojLvl8S~#98t%ym|~=}2QU7*xsIW8ji8nz
zPwX#1K8-v(U>KYoNFSgaLMK?y9VSycQ(6)M0i9sS7H~-tM`7Q_Q3&D!tvc4Vmj#$*
z4Qb3`>nw=iW|BHZ!yEk}$iZo%NfBBGMWa^=)x1}|^MipS!+PidCLKT~siv>@D)J_I
zqoj+-(opDBaRw1q&;G7?`~B2(WOXofEYC;LW32-tYdK&);LGW(E)ixq@wIg3nT7SZ
zr?8-Syvb*eC^J&HlgbO!^Q8Br;vibB%hR>x?pFH;lTSf<ToR?S*~mvM#XfqQfdf}p
zJKF|Eg*^=Nk(p-?pN9iPPZbq@i^5R$4-rMj8@JfM!Q0PR45v;K7M@i0utu&%F<!T%
z(!IzJ2*`&^vLs4UwsmTPi6c)LI9J|A$MH)F609`9a~Dm1bR<Mi6TwJUQ~X+vH=Nff
zZR+G<>Y1mxYYu?s*9nx6q4+@fD<m3OA&Ngd@h?tXe00D)fuTs@DPr-ux3YL%c?_iv
z6H$aD<m))Ig#tX7rm5i&c#_#rNrl15j%qYpAxMZinEP^=Q5A{9s2z=4HEkQ^+mvOE
zhtF;gQv7@X7f>d#_!|7rIRQP@(D#iu$D9htv<+CC!Q>=LdC)`%{%spH`Q(TR5X87p
ze)=tVS4U*3lZ9M5CScKOoAY}JfDxy;3Qep4=K#C5fH*pz<DOcsR$#g%HGO@(=rskJ
zIHGJ_at;IKG&<4o41p9kg|0OXPWpkw4WrnK8E}Xb=TNQ-&_>eHjL4|V8+j|SW&+|I
z0h!23)(93LruF?ktPUUbQ?3kiAoM;0i6SzLW3N16fhN<ml1&{}^uHzi{XXRbMt=jH
z`kAx%^SKE?&rA`)PIeiV#&B|Rz~&^7tj4jUjxn-y73Pgbq-Fv+%Z$uMA)d_FfR9MX
zH?B2^47aUkA}RTitRx3k#!L#)KJpO(O#gP7tvPxu0Oj|Wb}udagO@^kx@bh`frQ<<
z9j_!zvVl#bRyMaxx0fGhG4*FaJoFryv&zfUI*B?abI%C?YS&!6Rfraic7YJ6uy%P#
z$T48~NfKU@*CLh_=Z|vvR9DI#;q92r-;Ibb^-=4f6HvAze=f-9Wj{Zh3lZS0ph5Lm
z24Ks+L-|(<z1a##PVe4ov1fi}Nfw+=;sTYYOJ-7PJcJh!pEr;n@TCmX8U+fcs$)-P
zjj0Zcy3OyQXUN`{YgUPp$`z0Yt#F{(O%E^<2ZcOJg!t+c5X`oaXcWxK<MHxUXkT*@
zb)QHeh}A2qrz6n=X*JBddD~S%a$ep`rpzTL^NuW6<D5k209S&QK>P7KBz3$Ia<lMM
zTYqV+=VdH7SIF0cXyv(s6elR*j*?A7D19l-@XGHHs$siKe-6qSJsrCcR3R-4`P@)h
zBT;VJ{<w*?5VaI60xc~-6DBlKBgFv%W(qZ18B?QD4ivHRS@)peO+pUmgd-g*!7=IX
zTo5~YBHBG%Np+<_4(HwkeDp0oc@P6Bm>ZU-IKT|<BeM-kKm-IUKWyXx`cBV<=rW9W
z=`^xN8XRJJ0qpyL^!3<lPg|hG7AG>DXcc$?_w7sOF9P}cea_&Vae$~rG*B+%75x4t
z<)0~6QxK$W05Um-nU$P&EuBWEN-RWnGgd%SdHVS317!w*fIw5C_H1v$2|z#t)wJ;p
z9hL<kM~y}%;FoA$>|LQ)A%Vr2<eQiOLF*iN@!I?$|Id`#E$-sLa~-&oh)*1<M}H>J
zVyTcTpcPd@0!dZVM#Lzm*V1|D1&sQ(Q@NsxU_+jl`Tx<cy!5$;bIJjt=A}3ReA_;t
z=oup^^l}@ZRB9GU4CL^U<}8Iv7J@ofMf!m(2aR-1j$mq6z-%4G#*=a{E3-$|0Rf;u
zA=%c}#ueg5UJxpvx~D+(wY-hKs3GKNAuA?%cqmo`qk0lKT7c=zKQQ{2gx4`A&(6QN
z5y8?=Sjp4yPP!tiX>V$C1iH7(K)6%vH59#N^WbLa9G?xUAj|5%Qg+j)pI!Sb&o*i0
zS>B<I%ftydr96TkvE4}dTMEOXjqxf3u>fU2ASU1=R4zB=^H)?&$Q2+WlJeHce1Z@>
z0afl(IEJG%63iOe4I?$Y)PE~;sXxRL&21#D+ZJM;MS6v{q=*Olz`~%>p;Ai9nvt*Q
zA#8~TCVN^Z+Q2jPf)0}JnkaKJ2=PkXlr<nFRMX`?JDR6EaFH+A_5ZU~Iycny#X)K)
zd~pxZogo5ofvJ?gp-iE)%?&u|AiI1R?qFuvBz@)$ns+1`qB<vS10h|Vt@-v?3`TU%
z6*=h+O0!aG`k&FSGD8Kda}@mazoBGeEu=()AJ^!YhA$;fGnr)e;ebj?mWu%K=_d&i
zIfw8IPWq#EU{wU$H!#{4V70Hoti%#IHK456#}xIG<UJJm#ln|D0D1+8K+mH0><5$w
zDfDa`+<+4eAkQG5n@Qr4ODa`M<|Aoa4P2q2Vw0gE^h^K%18hk|K~x<O5GZ|0o;0y%
zB7vT1tZbzLBN{mX-aSpJaz&8Q?Qsf;AbIc<ew8OuTZto`k3>?FM>XtfwCj233Ysz>
zu(lB&GWaZ4Zo{Rior7$DN%;@T9*{3i@P)&dMgY;9KnP&Z9Y%l6R@^|pPYoKOTB)3`
zm}n-ln^jU6J)WNu5pCS1;Uy&^BKhxi`7Oi=A~DnCd;^OQYqb2UYY{<#EEKYMT>sE#
z^^_HLvIuH<b#$bforRPiQJ@;K&CY>?hx?osH1y4B)jmg+QrrNo&hDkiS{O_L!>0)%
zhE8w-GHT@nGM1Tf-9SMXDPK+8y{CD{)2Nmr7MXB-D8ko7kO(2p;Yz2L$~k?c>v_lt
z+fMlf<tfVkFB9=R&*6_k0MWx!x`B}YFy#)4M8ui3NyH$T%_3Hw+(9CWn{Nup;BNLP
zn>=qa)1*VR#>Vx;NP*N=jv$;)f%FDBq;L!KX)p@xy{shk@cAqz&Yc<3d5|l4unc>e
z@+-<#5HDi*qrjPU_7~K|lvo(Y?H{CELjikdz!9k23`7)i-YE4<!5xVXnUTnIxA7%5
zG?`PuC4q9jgly>u#0(UaalgO9x0<Cy@`%g#Ge>rKf5=Nup<q&Y{QhTbwOBJs!ygyE
z5(E%+0fYe7Yz*aYiU^@Mg`s;6KtvHCu<3r&Teo$*X`M6QhqA1U@+##S3V2@w>-cKG
zSBe0lE`bmjp1wZ84Qy|rAm~lR@s(^Z?K&AW;xRpZO5JR>FH^SsF<Cv&Zxz0>9SRYs
zZ7Llp7gBDgTuedOpN1cSN?$Taj>~Q@p-8KLiL#h-0K|*^e<k57O8`xKD@6?A3Q`jB
z1$!Ri1h)Mt80)R%By#Xe03jX4!98~};pR}5Q1*dz9skP1p9BG%+=~zdYQLf3*>K8a
z$_12Rl>bwm9it!&1W_3F0G4*v-v1PyLG1(&pdg5q_<zBOg;?3_z+;lIMY8jD=FJ2_
zJU1Aq=>N^6^ciOK=dcUg;I!`pW&bGf)(vAr65w-pBZELAL~?)n{k+N34E#E*f-+)_
zEb=KTeLu2D(E`WMsr=gYEtt?9Lk<7p@bahprC{IlL)-8K__q6zLQsKlY&tZR34R&s
z2j4_M3W2B8)o<!t;H7UZ8zF}T?vZ1-6W%-jv?s#<UK#R)G$#N6002ovPDHLkV1h>x
B&Y1uJ

literal 3536
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

diff --git a/assets/icon/16x16.png b/assets/icon/16x16.png
index d28919c4bfd8a4aeed76dfd406562328a85b455b..77d669639f6093212e166277d90f9fa900a2aebe 100644
GIT binary patch
delta 1184
zcmeyuwS{wnN<C+RM`SSr1Gg{;GcwGYBf-GH5K`hAQR0@Flgi+16%$&VT2vepky?<E
zUzAyz8{?6mn;H{Pl%JKFTv8lk?4sb9mzkSbl9`_u<CK${my%kf0GEwO&C5(w@J!Cn
z(@O%$y*n{M3~0Ut$b6T?l2nFzBLhPVeFIZ{10w|^BP#<_D<h*Wp(lnwMFJp2A(^?U
z3<d^PKxAlWWndy%I%ft@juY&_qC}vik(tHY;Cp#MK|zq9Gf=E3k-<?xR{_FI-Ldr;
zP?8%Y8JwJ&m&yPppDM;q0}9s*gT#Zt&PLd!XKpy7@P_~c19P0Gi(`m|pzq}S*)pLb
z$M=6fckW%<x9=&NC#xyu=3e@8{aRNp$La;H7osLykmuL>@u>TP`hV8@wE^)ppM704
zM0B~XUU8^jvP6HW%A}SH$Clik57d3;&ABskU(ZZB%57Xf=lA2{bKmDx^Bw;0wlSjT
z;+7MSZzZMuI&rgS-u$KyuKO>W?f!a-d3$o)^1r=Xw{Cst-Luz(!z?0Z_cYt!UtfOw
zna%zwsz-j#tfYN+-S2O^_$K<`;@zjOo_h7E{78+j-<b)ahvW|??=kqB`s>Nf^OFKi
zrzbJWdmoF8>vsCu-oav5KkKROvm0erhS55acgqrWmaa9E;`LUvICW|9{PcS}OLG5w
z@Oks%P2ja#H9cRew=ZO4+In~SkH^n=k0fiw+1E4focXwG@~Qc+-q>yAzIlcDs6kKo
z)z<I(yd)+|+D>hH7G+WV%Y-dgxV-MS=x+b{54IM6u6TX-d!i+uOnlOUV^ikUbEMtb
z`&RYbrdHRdA7bVme<U!k+rxyfpf7JZ?>dbyg(kkjLOjZyA~sge-5264&CXr=CCaxq
zAW70z=mOAy1HqDa_I^FxeL{SFT}yYk{gL=3Nk6|we^3tG@#I9ZOifA5L(62vrV>5>
zRR$tVZ`bvno$GtW?Apg;Px~jzomQUcQUB=eX{l-J>iHM?D_BLhm=-)(RoK=O_u$fJ
zk^PrjtS2=rUU4IOXYb0-@(0fME>7CHVz<yn=i>o;zHpk!-E-f1)2ZB|<?d@E&+pv{
z3IBC3TUNXixck=LFlZM;dI?i%cE<{##+w@tE@CRG;@c>!du7|T#^C1<e#$M0Twk>1
z`}@<^>i3E4<9Dq5uq^#TQS6M8>!0>@uCjF~eXz)9;@;-s0?m`naqNpO3tf7*wqVB8
z`8V&Cxn7!m`jJh{uKCJLUziRgaaB#((f53@`!?q?gF+5R7uK?ESx5efTsvr&b^ek^
zn)js{PbN+BEK=~S6OeCIP_?_+#ME+LM&)usHh+6W{9m?u=GSdbPc?c1{|ati%PFGf
ze`?LThDnlIO;?*$9K1RYybOLA{KT#DMA-B?ht>aBzczneB!1%L0gq$vH$Jy!6iyP0
za+(}9>GXybO$?KYPqxT!SbMy*?D@0pFJ>v;;rjhzf8L+%D?1KwF8Sj6;uzDWpUfh5
u4%;&qeXL<E`|f`0zRC?r{`2jR<yS>a3p>na^8%P589ZJ6T-G@yGywn**el}z

literal 1396
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*9U+n3Xd_B1$5BeXNr6bM+EIYV;~{3xK*A7;Nk-3KEmEQ%e+*
zQqwc@Y?a>c-mj#PnPRIHZt82`Ti~3Uk?B!Ylp0*+7m{3+ootz+WN)WnQ(*-(AUCxn
zQK2F?C$HG5!d3}vt`(3C64qBz04piUwpD^SD#ABF!8yMuRl!uxR5#hc$WX!DQqR!T
z#M01EN5ROz&{*HlK;Otx*U-?)#N5izOaTg%fVLH-q*(>IxIyg#@@$ndN=gc>^!3Zj
z%k|2Q_413-^$jg8E%gnI^o@*kfhu&1EAvVcD|GXUm0>2hq!uR^WfqiV=I1GZOiWD5
zFD<cE0=g99h1>$Tv3bSNU;+l1ennz|zM-B0$V)JVzP|XC=H|jx7ncO3BHWAB;Np<V
zf>iyW)Z+ZoqGVvir744~DzI`cN=+=uFAB-e&w+(vKt_H^esM;Afr7KMf`)Hma%LWg
zuL;)R>ucqiS6q^qmz?V9Vygr+LN7Bj#mdmq*wM++$=Tcz7}kca#ul!oPR<6#&X#6I
zt`?SVW-z@j`N^fZsd*(Zy(tL2E;#jq(n4+l&}Ns^qRg_?6t|-MTm`V7tuk@D#Sy1@
zP`xR*-Qt8(uRhQ*`k<IaifNb-F!_L(@N^60z*Bx|9x%BV0n@ec?cQSy42;h`T^vIy
zZY>Eut=$qRV*h=%WPhtD_e7nW0^HnB|ElSTXfEl<(0LP>oS2@N_$kb(bCbid>=V}7
zn<o5ZRtr`Wd}?TXzx4dieZM8=-?S`!Z~J}TZ|nDmHyIl%Fco(AocWV*^lkDT*Xc9%
zWic)Dd+W63kb;}evh3dhmUqfSC(N;qeKYxTeZUemPQTeVn_XtJ+B*kLVY)u|X@PRs
zrU%8(zMGoAxoQ*jz4fKypTeD~PdTQ|?(TdaW81cK*`W?aNv@!l+n$F$g}TpFl)YiW
zs-0{QGd+FJRXy25kEd(>pU5O<zL9zT-q3oT*(>Y+vK*7*>hKp|m^5Pwv!wsoMY9hy
zAKEnYSeZUY&%=OoBD_l^q~{&F`)+G;(QO|y#)6!AjjrO6Ds1MVYu4<ny^*EMIJLN-
z<*3fdxOv=+inH^sOp<(%SleKFG)VERnP}_IT1}noge4Py)ts96-k9Z{{@3Hp<+0J{
z{v2H2@-_UKP=$hyy1padyKhDn;iUr81hoT8-aV~&B(<y7<Ok<@;kk>;>mIND`O5Lr
zere6bBKAkRToo>rUgCTTQ7U=6*G}Pi_*a+ZgG`X8p0wx1^v0ss?^iO#2Xyl$Pf74G
z*!7mXg=fQ&3GB}jH(AA+_}q~1ic|I3l4HhsEHUZ7?DKp^HilW}&%bWl;#&zS2R&W=
KT-G@yGywqTk@@!k

diff --git a/assets/icon/256x256.png b/assets/icon/256x256.png
index 0c530d578d28a5fc7f32d519163e567d04777a58..d9cb2976ebc86bfecb551174122077bfb96cda86 100644
GIT binary patch
literal 64340
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%0DF`#tw#R%NIY!L<dk^*t-
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

literal 4429
zcmbVPdmxkh|DWoVZyo81MAj-1v(0r|hFmJ;78A;nJsS<%w9P%2oI0h6PD)BBCCq7(
zqe3XTB)2Zs+?q-@_tDHXd>^S!ozw68$M5;)x$J%Wyxy<Z`}0|hgWWE<rOHbo5Qv=h
zZc9f9L<W46fygcfZ|;mNFYvaGW#!6pqI<D|JQ-xj4icS6hFViSy~&PbPg2Oy8nQ72
zvXDu^yRuwuZLk2Hs^d9lqZ3T^2fZN>W7A-NPr#SVf)dHz6dDdDE-r&XDI^@s#lRM6
z>u*6mLfIY4AUlQH;ek+J07HVAnm~<%v0wlyndJ!$ruxyC*kBy&b6hO=Jogy^gMKz)
z`Ql*nMY-BKKrQGDGSooF01hB^QBWg{4$43ugF<OTb&)7N1PY1J#lTT0tiBNzWeELp
z!N6<`k{8y|a_5&^;2REhgvIj5A`n4AK{`QtI&_9N0)@d~5J+8wt}Yz3fHOmAEYDy#
zjk)P-1WPg#U{L&76gmw$7txbQ4`AV7V5Rd*p!(a|ehW-vegO)E3=!<<k3i`l5mf5j
zx;|SoS&rnt%lN4^6CdJFMmUn0^Z*6`_QPw_S7#8r|D9;g5Ud7k&!B)!@$|E#0|8Vr
zjb&|#gMq*3kSHW98c8xTAnSX<b<rdYT;I?D4aexBL2NPlo<>Ic28Luk%-1+S^WT9o
zwA^Wgv^2t?El?;cJ+zg9xdl?s0%NFag~seO{OW5>W3oJH0QqZf3Yhzguf_lL#ab}P
zo-8^8PpA8RWr4#HI*ZOcLidMSSU@#wJpl@B?p<@PNApXzBr_<1WYSIsoeKR7GM4g_
z0!V12p1!WWCtTOdfCSe!K$GDZFC!w{fQ0n)B9iq03;-^E-k<dU1rGrhg_vW?cg*?v
z38drP<2N0EFW;0zrh)QdfI4X_k(z<p^|!X%fe&u&f8!gA4^pi<>gDbFEIsB$MTLI&
zjTpp<-R516wAw?iAG|aP+(1p}-s27nE2<#86>E3LUZ-A*(!L0H<?hXBcXJKAZdUl$
zm82>~^(w^^Nl8a+o(<kbD*i@HsG7j#OFFN<YPl>HZJDiW(Gy(_3H3^ynca$FJ$)N7
z-cH^#5?+m#rse7`mjO$HLLe(35LpOh5hMzB@$HHa@FyEJx&iBgr>YRhg1H$J1%ZHe
z<7zI;hVZXKFecB(Rqv(OH6$Y{1_tCb@*|s7yH&zqI#m@BhP-(8$Ra8_06rDNZka*|
z?tO|ehF9snADg_X)Q${b-K@^Z>$;11ozPI4_C_;ow)mA#ogjV?-&#<wlUL7;)v=`+
z*~O|u&O9z{x!4q9m6aWFOdtw)eLU{`?d20oAw%nbs7Yf#SNV?dE(%dP+6AMnA|@{+
za`Nwc1d#+McIT8zw{nHyHZu}IWphzY<A)Np+=4?!)%*Ep8724Ox7CsW-`;+1<g0aI
z9_J~=BZDgm6IDIH0vx>;n{E1>mZ}nPG(&F`W6NobYxdEt{}GL+2|2%Xr}?&z^CF_g
zGs@gQy^NeZ$=MxQKl>ugr4A+5E|+;9kZbd7_R>TO)u=9yY_O?5?-tvrKCh~GrO?%?
zeXQe5K*GS-Xl;IAzJogVl#6{UwHAlU7rQjZ)rZX<6i#qUioz9v(E?hTj;0_;NpI}I
zLdf{iFWs2$+L?<vZVt;FXM&7p`2~h}#X9Bi)S~XAS$lHZvpN*)m1w129T^9Ot`=SX
zd=t*3<aXec7`I||1fI~s&+aSq$tA2*CyrJ_H<Uj+*)9V)_RCzO=R<>psN8l_895a^
z75z5HM5_H@>5Jrt!|e~EG5<-$_CLQUztCQqn4@+X&>VIz!T@EjGEEnmeoDbjIpI2U
zvm+k%iL)CYcMA<A>8fUOvQeKo^euFWkRww|ysWZb?q05||M+=~@HR05rjUqVc9<Jr
z%+dN)&^z!!+K~*r+9}s3Q5+HKjhf#e?93RGP=EzxI%5sok#MM0<%S!J7kytbNZ~_F
zUevIPK}VOOBu#20I(!NYjsFm~BIOKc@*d#<E$;T8s?I}OA1ZN5Z!7j&;XSwo-ur1F
zW1mku@Voqu;?z>NKbE$vE6s!t!Om@mMCE=F$GjG<xfc37IwjXyf70N%&d|DY%gl&A
zyJo!^LmO3U9F-z<4zE`o)%&Pmr_{hpJcW!S!`}9=_Etpy6_n8PD8A;l)u=a(l%EUx
zupIJM>mOV$RenBEo%*JO7N@#K?`D%^wkiEu@~t*Dj<$xqi<>Q}?{$)12pv2$os_xv
z<NNKfR64r0u)D`My_`V3%9p0=2sF6Y-!%L};fdasOgMuL{f76Vxm0El1~1CZTkVaj
z>+12iy6sJ#aoHR?FHcL@+^1J{1;{%s{}*S{jxCbf_H?p?cTQ`U^U}-Tknm-Fum}O5
z#23inwi{J_CxrQ_;kbG|mUKrs2>!_}Urc-*N%zeP93TO;Q$km#X*A!^C?zj#waXuO
zn0YW-JZ@vv;;Mo0;f7;<eQ~GPozLIH`u(P~CFE+Oy{V5GIE3bLUI9^A0CL75dX=Z2
ze!_o(!=`nQivcXqSaZPO#eI$LwoCn@mU`vde3@Bs(rJ#pYOSJHc=boc%zT%!T)TCu
z<6+5RL+3Gp{xmWvO?B|^83%?3QMtf5WpMayrN#60HZgMCWBgQ2^zORez1yb}jS$U^
zsgl=DPsOgZ68|SE#h3OZ11UBAqEFS;xo7yzZN*wTbwamM^LwuZd1-Rv*4r*@KtB05
zCY@L0(0=yGDs&GA)o#06mgM_X;rMR(=4n=k$-BxSm2y&R>4rm>*Yq=I64grlz)s}O
zL=mI~bvcZI+E-yZPlw|bc#I`K$lautw}1pY^gvs4#vNc!Yf+s_ayO2*XinvM=Jf4c
z`^g%|=(1qiOuy`aZQwb3n8o)xip)}q)9h4Ly9+XdBYXH$t2&qeJ<{jt5nAKC(B$d9
zv$01SOx%t*TqXecih;bFS*ppsS_JyBdQ=#Ehdp6UfpGcM3%9YWea`~eQgL}O-bJaY
z@F25)&+EtzUEt4&D@gT7XK~4qIKrCMJ&qfj#6KG-7nFyD<yWF3J8?a(Y3LoVfjdQ&
zo9?_vb%gn@2oN+FP91e`tGH3L|8<;p5-<Txi98!<3aE+JO$`Lh7CDX@9$eplIr>RO
zQ6xe0JF<X8F@r$5;U03$h;eNCp1N}%O?>`*H?)P>Uw;``Cfw|Yl^n;6-raYDN+|(n
zqHPMHq$ENR@rDyKN=&ZxITj%B8Wy~^i%@^r`7l8E;9+h;c)r%c4td{u{T3Ya*~vl4
zzr}>8{C)Ylt3jD#_yq2zZLuv!*1~8rcOJY}$!YO+IkB+P{KnQY4`<|((1Br4U_$XP
z2d!yqcx{uXbMBjC)DOK9P!LIdT71!9V5jAe`~<h$w=4O6k5W|{H6%?d?b($p+LZfS
zq5{%kv8^9(T&mC0@V(tY+BQVx;v$?M-bZn%93VZeD^66sD^OdUu}t)&HNk72!#6Q~
z#RrV(UV1Obps#F}N=fkzdotF{)({+6Gr*J;srDkPp8<iXiR>)f)4L|z8YkFne)q10
zt-r0?CoUasM>GApip9x5n^)YjPbzh$B*go|NINo#A6=wVY(*X$miLj&^cy#bPHmq%
zO3bSmObm{QjP7@SX3olm+sad;*p=@2^1m5&-5)hSw?t^;Pu1)0^|5B-4$^|chw{6c
zIwbqU1weY$tut1}_P;zlomr&g%*!;E6*<Nq{Z0%E=16?4X>)mVR^~mYM%+~A`_@Ne
zM_Ku}guanwk4+`FwbuHTy}G<KqF|46ZAea~NS>7hcs7Oj)L}(@g-NdqoW74Wgi+}+
z@9dHzw4jQMMnMpWhs?L55Lmxi-qMW4{qBaEeP!~kAq~fDU1Y&TuMdt&7MJki9Siso
zcJJ~gR@dc;&$OKKKD*~5?PbtIum1b9iJY!m>;r=*vIKDr`5pH|xxjP1u_lZQzb5T!
z{^Vc`mj1k9|8Pq-TOab1E!~-`jO-&u_o#{{FT&F<1j+NZc&t1o*PId;=;b^W?ZdRG
zH!<!@3UBVYN(lBVoxbm52@isuIKVBqjvb;#Oc@1cc-IS-bz=7!9JZIe)HOXIB6ex1
ze~;e$c`tr*`X}IWSD@`tdNqb`ST^Dt=Ed_^zqRPz#Mw8a(Q%P(@7uhd=gW)F^!nV)
zQdwKz-y@q>ADi{i@%@Vg&0(xG)|eL+c&3vGH*V7$wIF!RhSsDOW^SWPG5(R~fFBhT
zrQHrU3$4aTf_61pUcVr@v`>5>+C!mikmE7Q+f>)|IJWxO){P3aGv-qEbag{O|L>;@
zh99=!OEp^)O}DotUaL$Qz$=xF<TR>)jrzRre52Tq+jX18p?7d$gcp&OH)EM$qu26j
z6PZa*uWxw6Dn^Zm_SO&rRRg^#RFa~Fx2$hx_Sh{>Y3|_N#>X9(T1A8G_w8HG25c?9
z)WSc<$>asJM4l8E{d%MKAEOdvgeJ&{*d^|ytUX<&S;S{4&NiaEMUUcRIGKam1$}pN
zmGTv4htJd1oJ$mT%4G?XvFe;&CzF*T9co>_)9hL>rqlWOqf4I^F8tx31s+@MKTne}
z_DhVyp1(N1@|K5sFWtr|-{(wrlU;`0=JT!we_~44KeI&5r^?;qk3j7qxBX`9Fd;`4
zSMYyO_gCYL#3ddpLp#zq#AhyRBAjmt4!Tt=I~-bLMLel7CYcE=?%jKO6;i6?5*qoh
zX*zx(XK|hLlM3MEuyAR%2_7$9O%CX~E&Bwmj%o0{P`z1U1S5SWE&QmW2u`ok&%5fk
z{}IHsJ)q*xS`t)u5>|$~UCbE^-eM8Vk6CcwFz?AhsnuDl9Wp~}f7pmd4yEHe9&jQU
z+Mh1JyQ}Fge^2DmQ@M9MxNycaYSk{tnsI~rjsG|@1#f=5@##UOGF@+U;@f}iYta(A
a%wmZ1AK3#A(|6Di@UphDv*el|j{Yy20cq9%

diff --git a/assets/icon/32x32.png b/assets/icon/32x32.png
index 9ae25c42ee0c62c7f2c2d43ef1635529274e7f22..c82a2463abddd808557bdd795f87ea329f820fb9 100644
GIT binary patch
literal 3126
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
KfvGTXq5TI`MWSo~

delta 1044
zcmV+v1nc{@7^w)5B!2;OQb$4nuFf3k00004XF*Lt006O%3;baP00009a7bBm000id
z000id0mpBsWB>pF7<5HgbW?9;ba!ELWdLwtX>N2bZe?^JG%heMGmPe!Pyhe}nn^@K
zR9Hu?R$EI|K@|4ybfYMOkRU3Ah#tDojYujg>Lt1m(S=^3B!7rr>LCaU2|_D~FoOgO
z%+%C6Y9^(orN?vBJm#gew`smTYt3GJ&g^}T)Pj$hJ+s!gzL{Aw=aeX=3PRfQrAt&2
z$gOyD6U3P>SrRC$uoV*EBY*mRTGb5AsM_Hf^;`pejQM<tCf<?+NTNrBQ|g&cf}}k5
zDl;3j^%*l(JAXVI`0zY~==>HZKoUIo`ZHK%-H1sDG>`rA_FtxF)Z=ecK@5)pM4N9u
z0W#19lD(gp3;JC-)21eVtM(sr5g|Shebih5ZqO6Gnipc*iv?m3>yA^J(4+u%y4L-}
z2E-Lt5*kL$PRQ7+f|Jr2V*xw~RFHGEE<CjLy4X^*?SBga>W2Hw$q16dTmhH6#v_in
zX58<a{u7z=p?7LNX!(ZV_VAqK4wAwkfCo>f#;gOQc6eI7&d#dN+`J`ELT>?)G6zWr
zSAXh5z5w3F4yyQtpk^qnfr{>lpp`iy$$^t%@^0^>dN^PnAL&yJP=s|O=5+)IxG;XP
zb6lNp7Jq349BdnnO#BP@{26z?<kXdq;rSnG%i6vbaG*6D1a5!M*?!zEpeEu9Q^rUx
zpu9C)tQD~DT~-}w9}SM-g5D|~uk1J5=K|LfFCh?DAC>*)IlkFr1n~JI7yDQN+gdVq
zkZa*ak0~4p{xQPa;LiD8Ov!--qLsO<fGy1#wSTK6YmWj2!*h(Pf#?s6d?OgH58!ek
z7x%4zvZfI`h$1=bya^~I`3+PLnq*bF(%m_UGpVS6vbSL_D*)IeM7Y2?qL?5A*Xmy1
zq`I%`11;wHssYzO<sTiNyPG5O7OWS_B+hr36-eS+qOxV5ePkg^Y?P~KlMbbgX|;iz
z_J4|M<-$BiVlIgUvhN-pbAYq7(X)Cs9$fJz9f&}Gt0)%WI8`ygSIYPM0qmz@W)5(!
z(%d{xX+z@)V5N3kC$?(4xHb%2siPXlG|)e+3m30xxlWARgcwviiW^*5n2e{i{y!wZ
zY6{@Gz)E&#(%l++^tN(Q$wvj)=@E+s$$xK3XG{u!Nk@h}yUk6}1oD{V+*%#8hK^E#
z(uC#;fU)!9hO}DdsCQT6OTs{`j3@f2`2@gRBKhqCLfvn7jA-*MP5?|2@M>IQDUN;Q
zJV11QOA-Kc$pAhYV3F<vzQh30#9JW&Y(DZNP}u)BUor`DE7D3z{sPGAXrSOSN(}%2
O0000<MNUMnLSTY^E#MRY

diff --git a/assets/icon/36x36.png b/assets/icon/36x36.png
index 18f0ee0e88373fccd811540cd35d0a4925ce3e1d..3a25e4c3f4a4fd219de75b1d17dadb5ea3fec4f7 100644
GIT binary patch
literal 3739
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
FV1oCqqD}w+

literal 2767
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
Gec(Sn6q_ml

diff --git a/assets/icon/37x37.png b/assets/icon/37x37.png
index 86e0c33f1a0d9abcb0b4195507a5080f03acbdcc..f515c863210c1bbb89dc53850c52966c1b8d0f1b 100644
GIT binary patch
literal 3922
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

literal 2776
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
RqL%KO&JJ#j3cJAg{{X~5q;~)S

diff --git a/assets/icon/48x48.png b/assets/icon/48x48.png
index a2307c3558a6c0bc89cedf8293eac2b44772d750..5449d62c433734eedb700f42658c54fb7cc48698 100644
GIT binary patch
literal 5873
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
EAMCNsr~m)}

literal 2923
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
B+i3s*

diff --git a/assets/icon/512x512.png b/assets/icon/512x512.png
index 647425b3832d1b2416f006f8bd86b2ee2dc1aee4..103a78ca86232fb78d3f99aad1658f497182f84c 100644
GIT binary patch
literal 153321
zcmX_n1ymeO6W|)|?jC{#w?%>`xCPf>!9sw=9TpG4f)kwJ5CTDh!y>`m-QC^g`2Kr$
z@9pf&R84jDbV*NFRfnso$YP<BqXPf{EP1(i>Hq-f<q`xyMSeM5cud^AoX}u$dd>g<
z2El&^5RjTq`U2E+d9UjtWAnuVAT4aD<!s^PY^ZAivvzQ@akVp)bFi~8RC99pY+>%=
zY{>hLR?^<a&eX-m!QN2ni-r9s3n$wDkJYuXw=t!aH+Qh-F#8X8)bpMArG3)>+J9&2
zVgcac;)Zf^@pE$V(DLvIa|sCZ@z&oh48J^s``<H~Hg*;OE-vAhA2+u!7ay5xddh#D
z{$Kx`Oka>Z0?<Q^CHog3-hV*p7nqYNK$4c7_Wxd5)YWvoATj<!YM5KtTLAv|ze#75
z^a3XM53K&bPX9kvJX{=HLb+@;Apig^K>nSirU&q#8O4OU+m*xX>k`E%DlWwP*ete)
zLvOP3Rq0$Mm5}4YTD5n^!ov1O^Fs2*YeCOb<@)f$y7_NuUuKia>|Mj@-+ya%52Td<
zeA#JkI!?=&%`kcpM-Mpz&(PtxZ4LaG{ZVy)EX3=)6)8t5g&j<ZDunAqyCKmNz|tLH
zqw%}jG)x*>35fkm_mA0Ji|_rNM@>V&2Mt_@LKT0FY+{n5AIeKVX>*oB6Z#!Yhw_>j
zC6Fc{eDbcM=H-SC1r#{-AhSNI1sa!!f07WU1%F5GfqVkXbu>XF&}s2-QRF6V*7P!M
zkkQ?xP_ku>4IB?aE}(|X$<Fy$dmtYm6_CdmEuo)e?)yuT1v@7Wpb|{CA%W?H@G&&2
zurZC7!d4Q)CSA4n3grvo4dDwBK)P~~z|MxKL3+R&VCDs~LWGrAh<FIJoN(t?SbIjR
z4aN71sH>n>&w|A4*EvL9WzcghEF=-6<^X}tVq7({Y;}nc_~|)30^Sc7mcYs;mPoY(
z5MhUAs!75~@t&}RxTYvk{V==ko>m`Um@8nbjTlhzf-)H{4FMsdNDp5m$g)Whe5V83
z)=QB$gGE`OncoDxDL9(+Gxn@l>5|zit&nVWHM=&O&SF}%542e4Lb<eR*j|AO1gEC|
zjs41_v&m0iwI%<U4st2%NDxXjqOfAiS`<SfM~tKbw*r%kLJh!`>mGe0^qGlEX>yr9
z5t2&_d!2&^!-nC*)QnZF4d4FGv-q(D+X5J(O7{d@w*?g6je63&!H7_C#g>?%kR0B1
zN57l}px@^M&>wgJr|Cbpcd|6jO-aR2m=EeF5Ee*7*qWeda5SihG93w~mqXSEPvw>n
z#iT=#!p4jR=YY80$%K5;hzEOp8vY<$cr2vc3aKEkz*ED{&bFcs@xAc|5y%J?jfx*h
z{)1mZGyzca3aS(86<l~fTD9^HwiOy8ge#cxYkR;+5K#y>o!4h404S?HlfjLADG{U%
z`i%@D_a}yjdRX33k8*XQqFCD^^Z*<L>A(ZP!Spn`VeuQ6(E`BqOB<*{0PJ9Ni5qey
z8*J+U)qbxk%T{DZbRU(?VE|W*#*=A^F6D|6FyyTjs05JyBHs!O7z9S$2XJS5Q6)se
zrbH1yX;xPJQuue_`R&lSS`32^`Yi=u8bl2Ky1pa!U<5~t=Tc)?v4_~Jiek=SdSFOw
zW)q_WlZo1KolN>*v=1Z7KV;v!ilDa*<B4KjSr@qzt-MAE0}3xR0O?ma9TV#SBG3@-
zNF7XY#R71M$_h|kbpqDmhRP2Hr~y+ZV%+!Ku%)sBn{g%jA4Gr@01Uu_6^+Vn5Sr<U
zBU}KI4qOp<H-!BK*o2l%C5e?yg$}g&kM$UgRuk}gFgJaUYIOYGusjQ`4h_a;!VcfR
zNk7Apy)}^{4IKauVON8hAFe@}C~9<2@O$_?e#Z-KyYqjv4-DxIR3lPZ^T%5N<`W0-
zFA&W3V_g!?>tNGPD1sMzC+GV-mNBFW845(TLPi90DJi{-HKNnUUgPhi{*LqVqbMQ@
zz}uV^Rd*T^WBuYkBGFL>)Z36IT2K%_0(1aOK&lj~l>x~Yj1ua9q`@9a8jZ2~JL6wt
z7#`DrG!R(c@THH+aoCF}JYWcB@Pd}ax+FPX3lbFVJ^Tsv<vnQ&gm75_+>agwZtJu+
z_4eWvu(vA=fTPjv0HIU($s!U#JFW)h3J)+5c*N|1e!`lK-v{`gEjd%7ivQ%kmTO0r
zJaNYI=U<@%Okdf|bjSMLv;?A=rr=WUNU)Uxhe3YW+3F*x7Vx3)|M<Oz;`*tXuW>6K
z%INOjZLV}K!g0XRf2!ct5ic4g)Q;dy0FszH)&W2i>;Z(Kk04vX6;WSom&=|Kl?d)=
z?(1QW>Zh_v0-gd>gJI=<EVQC;abD>1)&Y;0CnrCrfvTV-B*S2O37`K)ObA5^$z(uJ
ztj3{8_MY%W^wYK^A`IXRs6N11mgS<ujL!s9-a3b`aIKI4hR_c}=trV$|Dz*AX~#KA
z`6Jwf7c9<xD+r`Uf!Vd<;;Nj!=uJu-Wj4LU$}fZ>{2B5kjD7_EKN8{pSWW1Ox;kXb
z-hTo_-Pxn4os5eZQ`7#>vTuYC<7l<O7L*slkP(#^@6l1@_@XB=Q8gNkX3Z_FxP~j4
zzQ2!ohsfanvpg;?6l*>Y+!J1aJMKuiM4dMv61Ahp=|7UBER7ZcR6qTra)2m$9gP~Y
z9OOUG-4l@G3|9p6VgCZDq21uY-9Q<2p)a!k`kyY#1V@=N;y&oDfTpkgF<`vesJJc0
zFIp^x-K2`GhF1siKsr%IXfuP-8UN?k{so+XA6sTfh^H8y_S?dT0n9fYmyahkFQO2p
zToD3C0a!uCC{1YZX%~cE8ei>$z9^DTS1pS%dSKT6tqxcWrw)wB^>{G|+6}~xGrS+n
z4j@N=LNVbb3=lB<&rWpz6RGJR+s_2jJLkTue!l2_(Knv>G=)zcxYCp<#Inx{y8f&D
z97FXbeCso=@;jH<W&6^GtCAfa4z-&N)VnQ9)Y^rC;Z^nof}X3c140t-;ReW_TZm^M
z41<m+=w%p5@&A*G+!yq4+6STbWx&mw6*oZ4GS)H;mnomLp;R3H%qdGTepbpWwBlX-
ztb{l6yFcPk<rEZ?-$?|vTgc(>;>M`TLEcLIBltAOCwrqY!j>X{RcA9cJzWTI9KFAz
z%+D?_l=aGnTu9wqyST|YsMfl;yU3~P6uQ*Zg6Hx|%d~_I(g<6s>gDGsI2GN!OE279
zbCen{-~~9Yq>OZ$q%!C1A6g)Ljwn@p6-cMV%wSF2{|troMFTxFr-I2g01$t44!)y%
zO8Ag>JHH>7X&wm4hcd+FbLuOLPl`_3(Rs?82@?l~@{*#A3>srjXRq)A#aY;u(e5D3
zAV=IIN79h)f701(t3z3p3=^{gmmO~Yi}s&V1`D)TG?Cv*A`Rhksp;+P=br%>a~dhC
zkQWtf)cPc48(seLDH>=5x$yBT>~BVlP3dyl)%~3Yb7Uni4XH>pmeLj}bci1(gMAb<
zA%5T+R`@m!ANZ9fa!&{sL<p8|9BT5`)GN*r5J)4fy7~J$#&PrG6RgueWOzoYmnqLe
zPT^xt-X@8>rDJiPtz=fLF|)iHAWo=6HIxSce3|)>L>cSvV$G_Da1T)^u*7xa^;G(=
z+T`vxWm&t)kgQ)#;1V{cnyyrWtO&Rm5I=&Wi3dpe1QiUVo2v~QXa~1#39Bcx6m@K?
zT%<iw6NCH?sIdd}$&sGV0UTHda1bszMj)Q)iSvp=E5(z3`$XO<03vR5K7{-r_TmBU
zw=otk1JQzz7<SfcvQ;^mlYWs|#OXo7YQJR8dUsO_x)Yl5&%DSpHBK?NO4iWVAH%Pt
zqe5%>LyGu5UVbnaqdQjgc>go|o`qN-L!EF$Zip6km7UfHOd^@%wjELTmrv!Kke9wB
zvw?c+&t<=I5im@!XGXD<Z)@}>rGSG!2`ys!<DA$b(3nA)k|?;QDRYz_;>)4MgZ1)L
z-t0FKqh(>h^rI{sRMkx|0WvyT%3oFX6uMo~$?b%}#DlmWaRJc6LzaVjf#KLDeRsk0
z-6FMqA1&7tS*Y$D>NRb~;!wcZmxk3&J0SI&?X7yeF#7M5?^w8Mgx%26`FGZwq--Nn
z*{$1^+ANqMSXxA5nyxZ)oKvhKK}$y?g3+sn32bG;s$eL^2?633Cja8jf^HLn(^E<)
z;VXr|vIA(a?w|fQT|Swj!r%-K34!?XTJ3((8v}2W)5m7xGDVEgyrcKl39MnVNmr}g
zo8hZD=sx9;5{dTYsl)JKUS%rg;T*Dbvx@ft*=mB<Tm0&o?RsR|)ilkV!wN<D5H*p|
z@Qg8Fe)i^=XK@(4M1D4&f+VjcrZC53NEPG?e7d&rnhL!c<;Dtet_JeBk{~VMLJ2+N
zPia5+v0xN-QaHa91%C$BVIf>d5kUS7oPex!ULzibev7*YM%*jh8%7J#Mb+fa1VY&v
zTNb<E=EtCKuP=Q0LgyvsJbni4_CUk>@?9AU);`pIZae6;;_Pa?)fjpVf+kMMiEw^i
z=;Qh@KwyFfQ~)O73jf*9E?cdf(9!A3AMYmO%gU94QCC4$F(p^nvwaa5aDO0dpEl+-
zb_d}GLf40*fY!jgu^;!Lf+Id3@cZ1K6fu5R;FCR~IxrMJ@Wc6)!;)EVRu!)8O@1_y
zpZd4X;?ZWN6cqfsD;zd6N;wMEt$7;}dndx7tei|eh-Rmikft!PfRupQdtx4Xs_)cd
z>H|aWtQwlB6Kt!6ydG5y0gOhJ=0pAi_!mWG-xfR(WPun=F?}KCD0xU#5F;)LOd`-V
z@T0^*;fv)^VjY4FTa<qEz*^8WLRsQ#a=jY-h3~Fe0Mobq08QkAPuYkVRr&adcJ*F^
z3QcsbzTpgh9kho$&4a=)MB&M%+|pAH1gVv5_ufV{so}=&@?G|*ySl|f;M0AYy7phm
z+uuQ(_g_)uNhK+w-l(_W6oyo3EcO05zyHVoljfr!VkL@arNAf=@c|nujj;Q+kU8TM
zpomPQ?*6IOP}omxu3|sC(6{e?Fz3UHJYbmg2785`5NK7-gm0R%KuOx`(7CZS0Xe1$
z7SErJf^!0Y1C@GrpKNB_vjA)lzl0+4OjezKM1SxTD7e)4vz;03yjIPpBaZpNE&kn4
ziUyPK2Q^l#3ThJ5)X436gC*Pex01d<8-LIDYY(Hru{-P~*F^k*Q*l-HzV?|Br!qUp
zo4Jzh^7H;w3TZ0;P77(U^Eih31fd*wTt%(IS?H32l;kxX;*#ceHR{M5nb0>;MBRB9
zBDe)72Y^HH66gU3(YRU(sN+IvxAtQz0Nk6kMtDt#W3WFmARK@@Jyw09?o~-yDL>eS
z&XeRuEBWJMb{_`<>A!UM!x^Y_cMLE;M7Gg%WcvjgTY20v{|ahfjp=2W>l{oZCA!At
zh*B;uz1aK_tTpky*p{y;#yS{ZrU$vy`P9A>e=K#T?+gMx|Gv60>yI_W^2^Ck7-O4I
z=c{!UsIBs|8{i|3$h`i<-;VQcZ2862W~bX3zunJud_+-bLTB5>LCav6UN%oU7J%fn
zBWb@w*DFi&FK$@v;$-aW<j?-#UjU_WJ72=P1<p);QN>CtPWXs1+wD2s#VU-6TL?+x
z?jjS#o;HOB-mn&v>}F=KFS}5!v5+fB)+S7pVZ39IXYUy|>+#yhMoaaRVQXcoz#OA`
zbLbRa^K1SSesa54O?WK@GHI`0>;c8$nIBr1^c47U{ZjdE+rYK{QpA-f>?3x)=7_Ei
zn4#TV-5XYG7$`O3Sgbt_wcs!$p252DMmVd13Lb=eKlz@4eKB6!W-<A;(%$UWS#iVX
z@2HVrY0C+y;j`o1W5%riN~aW8+bw3|Rdce?OZ|A0+=GiePbZ1|o2s*hh&!pHEc46L
zgLwIVaTk61-rj%ReRvPqO-}`1kQeV&v1xgTw`cLxU>)v#RZ0_p|AFiRG+FyOir0wS
zzuj3PVJ_iqsr3EZr6{SEk?F5GjZH$<C9*LTUijVz@Wq*Ex6F21R<VJ)dXx-e@&z)s
zLLR^?w1mJ8>Q^0HWY8187OeQ3=lI_^xKH&v6AS>ATTYPDXHGxLL)DHpK|S0%Mq5Es
zBmW<t+6Fmr{(X?5QJ-nrXqt00*oo^K9LE!ka>BG1{(iiPCB2i2t&ydZ$;~w5*-2{A
zK7=&}^;}wRJA2#LW*+2w+w8-(^?niyB(F2Wqp@iNO5;#pU<Qw#zmfdiXlZ?@7eL1X
zVlJn|Up>j~nsaudZbU0_w@>UMKq-uCT#Gm9NCv6`Ql;Mm3{zg2zG}sb4`w8&qQHHq
z-ZI9yQA9++<sCMX#cW#$e=jiq>z`Iw`X$sy7IT&rGj#q>Kx({c106+__w52MQfoOT
z8@KDuS%Xyh$FQ#as=h|3vRPjWe!=1rl~T0(Wit2LV1FT}-)~3WqS9C&VLKI&=H*Ig
zo}&>SgWcLz3F{eoXkIJQK+Fg_hSl89&rZ)X7I*&wcEYNT*S9D>9F3Mb+4}*8g<bwN
zrHr|eWgISLU35A|n4+kNHyL^=lw7wkxq8<s8Ypjm5~Th#z00=3h*$==Nup(snvlMR
zqTD@yWAX?q&_AcUxy7`Zxt2$e07C$*;CK#LHBFeEx2NK?!fwNU9>CywCxnv&Z|QnM
zoIMGF$Mdgg!QODamsGlZEp?>8-I_3`oSI~q{AYr*&9D1<s0{8vv*v<wh1Szb{-2B}
z*+Vl$ikNMSCJNchF)fa=xy1g3zXFthgVw#m!;F2moQ)a@a&@RXb0e2v7CVPy%MR$?
zl%kyoviO@Dhy|&97Rtq!6x3&wQ~B_^*KGIU?*@L2G;`yytIOi9<1)A&a9Nt-$H5fn
zvSQDYSCmD`OiSzo#Z~m5Yk10v*gW)PR!^DKTiS#`i(j2$1aznJr=!TC=}o5dJ;Jv~
zzB!{0(TKm&5?PA9>va&7Bi01($e%Q-fp%nRF$q$@OV<`4ce4@!BaCN@oo8dv5z+~y
zRi1?TMnloE9~0F#`pUU~3qe3rcw;&cwv?Kj0-BAI{U<{BK%oqm9UcdfLsZzYOO*|c
zQ2LyE7Vj&GHMFg6$Ly);32zFonwYx(wy+G6>?ip9WR`Th?tMhPq(=27xHFj@GNDN~
z$7H}7G|@@RJhho&Hw_dn#s!IEOEA)r$r2ZS+FE(np-HMw+}m|8j{YxFm?bc&?#?V%
zbAiE;Ia1>4#GdG*-uKkIfysRLb9!d5{m17s%i!aQ^@+aLg14-{^;Z%uS8L+l(}1-a
zmlEd|4f4zGs(=2?3g8eU<M5fyM0(&i;UokeQKNQ1HsJSBKj3y*mC93r;#im-xCq}z
z48YQNjPPFEHT5w@_g-?A`p@x%?0PIVq=((oJ23sZrn;sQ=u@3z)cLwrU+(C|Mtpp3
z|9)_k`H)0kU`Yod>O{9Fa$%G7r`U#TZN4KKnI<<O7N}F$_wt!mgQfdP)x4__>MXb*
zU+izfmDiDfCHgvd!*HH%#pT>aF`X4%UEh_+(3ut{!u}P*(-+m|dHyH{MRH3e<zqJ2
zv!<(%8n%{7VM^lx-bQ#_?o>XWq`v+t8#IeT?P%!k(yD3atwA151Fy>Y+uQIC202($
z380ZgLye)>QWR<nd}L2GQO;@@3;}VWG;dF}!~l7iD45p9dGf70lzE&VUE>73#bi?S
z`XpoYVzv}*KN_NI8_#Xnh<Zx9(#ajK-0CDxLpU;q$ka~mk8;q9?wNssA519=r#=J}
zk1zD+xE$H?*rn2DWNb~G=Q~?jY-6-0NSBL66#FP0nj6hwJCY_AZf+@FVWum6wN<c8
z>f2J1^j56mLjYA?7C&$dX7NhDvnqwY9KZu-Zx>!qn+c?}t<mP)PXBYWRhBw0dOh?5
zcUm`7hmZ#7uboqI+Z&CFUo6{=^s9>VF0AG|-{2oabq5m0w2HiEu0QaR=d699mBO(!
zg-UlgqYc^n8w?%Kvc8qOc2f}+nhidBf}Ds0t=eY+FjG*-in|qv-*=CnC@@Rop%(Cj
zUV+SIb9Ff`ZS3UtXJE!7KH+!0ex>8sM=5%-2f|9oCC*!!6~)qzh9R|Mown)H+i1pX
zROuWM?<%n4hbhyRR$Pfnvcu06fD5H!H-lr}z&0FNrRq{{Q<anId{zN&ECc#Y-VKf+
zlQ*c20%Hq`R&4U!u8#zbwf)|$PsN5}&W08i#KQ?Z3spWs=~My!HhQy14NZHvuPEkc
zk?1DWjX6n5hUAd`)@IE8L9(5N@-b!0)m>A_ysEM;5Pf)l$lZ{DSFI`td<OP@{#C@O
z@^54M`C?kVdE02l1#tyXN#)6T_i3$Yb773<N3;da5Nn>rwgQi+kkf7(Gg5)d{m01r
z6D3;^MfnFYeL-Vck3U4f*1+szFnt(y=eNvjXN6IYTxupFr)xz0^-`Q0r8*yeliLv?
zf&c8~A-we^<hJt?A2K90OMi)QuyZdhvCNC2K7(8`@9)GhdVosbth#r1`E<{dKRTBt
z{F<ZPovBqd=W$bU#f_WkR1S;!?mo^@rqT7)S4)MU7`j7Bi0*&43jc%D`jhvf2|r+1
zpQfPn_Jf06QF0eXjnnA>OFir^*sw&jII>;XfPAt?m`WC<y#D%wp4VboTwG@KS%J(V
zvS#;+nQN!A$n2NIXd#mLpWG&IuZpMBMSn-0q0?UQR$Tp-8JKGJ2~n0({G)=-^u<A>
z>5_f+x{r4Z{XX!TppqMWGGhGjmJsj~OGH)CC}bmY>CB4)sUacJs(<ZPk`T27@i^Lp
zV@x?x-m0Ei4ke}2Qw~RxVb28@q2%4$Vc1M{-=}yBd4B9)5PfHu3TO_S-sCF_o4y`F
z{b)E6l|yGqkdB$raTHL(Uap|{Z?rcLwW6^GUJhyj)e#OM!!fw22Wnq+r3tyFp|lNu
zc+vupFDziD5avEXb(5_SG|vOJ4jQ4ppM8xfQcv?Wv&FaU$vrG@#@^Ya#~+3(iZ8KP
z_3f8v8V!urI_(SGK18zNIN~OV8XY-Z>Y?6^JGHDqWtN!of1vcya_Y;;DJR!YFTB}5
z@{>60w-o6I(OS}63=Y26$~htKk}rMp{#enrntW~#onebYc%M9PT_w=DFuLD+_)#j_
z!T0f7GIFH}_@u}90Sw_K0&H{Wzus%~4opUkpI#cHZ++TsO{!}A`?;ZwQxkpc+=@9Q
z8@5E>+byXgbOMY`innE_xS2Nzu574ns2`^u$BuFesr}hOW01r3R?T%ckX1$42$8J4
z*?d2ul8vRvwIHKgbIETLs2U*ef()$v(S*M8W>bI}xaua!MXxP=B7$3bm>zc+c%mxX
zO@jh!ZuQ~e3J4UpT~$DRGRU_+WtIQ;HPLp{2XC-{2i0Ej`+igQckPRt^#oUi(mI06
z>0aTxRR#<{ze8_YT%nBRU_8IW@LYAU1B_&q`fu~o8WCD|dS$)SWk*bZ6F&td(|c`$
zrc49w4O{$Wa~jqm_Kn7vh(i+Y+_j`o<k`o)^U6aK@$V|X^l$_}B_~M(Pb>jSo(!Zv
zv>oFE2*))6ewV}kU?h`>G~RSntGG2-ipFPqAht)~y;bIsu9&KmDN36W`a+2u$;j4H
zQ-dSXDTMD>(XZ|nsE<>w1yojSO0!zk^kv1lNQINkp;fO_<w{!pqu`V~@0E`KCj(zx
zcay}{_d{hgx#7e|4>i3I!rk@expT)l=AuQRy}31n2LD`n=7SSI69^aKi8oy)8inCK
ze=D8X^}Z4ibJJ~({66;j_gE)`8SGQwH{101zX?b*OA}-{qPC7Ur=|ro9=}R!4I7wU
z3!~-veGtaMK%Mb=1^#xLaDIbm-Q;Dz)?dx*AAA3y>Sf3yu(|5&9OKA087c9Nh1JQ#
z1CIQ0h2$E*PmrtT%WqAmoztOZ5E$|b!}IlXp%tKs!lr(kUQ?gJbJyA~w$K!;<{5$x
zH~15+MyJLLsi0#Hbnh_(Bx89{L$EOF=K;TC2y1LG{?*&ZHF$X_R^$e=cPgWe$*7Y*
zR5wu55;d~~xlj-R)8DGq-&)v+Hn>+ZgV=Z0rh(6>jBs>GQnN_#5GQRHIe%hWZpbt1
z$qEf{8vOcV$xryGH>L4iA9NC@O*O(rI07xY>y|#1--*bI+$1=?jfD_jMgIfTk*Vag
z;Z20CzENU{+9Cywk^Vn-sgn`bmc13~Vj(XHjto)sob6w$RRh++WYF}T&j*QFH7<;n
zVD$xq9gd=EDnU^gnro*lLC?kZtp;%Ht2{Znz5nU-*--p4RTBPpB<aqWr_JP?6+)5r
z2|3M$f8XxbzDUU0mOkL~0<7G=M9*Z#N)&7n^<C6Q<axyA;-<_3tCYu39sf>LPj(0$
z>ewujqPxeaV7Nwcxv++dxA65*fF*;h5?zEAkQ?LXz>Rrlhsk;2yr9FfJ9~nwc1HL#
z;F+pIq#EOE+4hbdZgiQOa_^MHjmFF}%8el6CCT#fcv!zudu!?ZgC1-<C@zL&_LWCe
z1V(zN>}Z~ZEyO<6<CTvM%}^@KSDEb&kqcj4f4j2QSFTLaJ%8BC`!lWlU*BimqWv1K
zl_z*p(|FoO6+SAKO3u%hCC-!>c7@hlxG~6__$gX$RBv1dy5W5HyL?7zXRDr%BYN|f
zf069uzdOT|X_V^nC%Ih@k8?KW3`TZkWp(ERlZh4x?+&i@zo=Sy)`G=Z?WaHc)67i6
zz1ofqGjGF<u#!!5xb<@=x}OBr$g+aqWr(3L^j~d)M(|OFS3+1!#VK7(EAc(ZxmqQU
zUm}l!7C90N(b6N5N4S#>wYCe=zkYDD<8$P*90)CwYvW<=hYnUY*Xs#$j{UW7M{a3x
z2G#;fzJ2=^JvliU5*=i=;TVc85h;p_>aTzGOt*3j*o3dRLyBf_()UyYrdx!r{gjCP
zPViizs_I^$#0o>TiB!%&JjSBC)i>l@EW$y~VncrE>uB<miu$Eu`u(+n{Bnn<9Zn~g
zB%h`^{h7o3&#NaW7Z?Xm)_-5MJ3|FSb4qLUN^lMn=XeVlYwO;PRXMMOPX8eLGk^5&
zE!{E639*9&rM%wB-pRQImk<5lIb}|kcwSj-)@=c4Q=I8}oh26$Lin3&q`$|~d7k#H
z(F#9Q=?o1V)rZ=qqz3bGHZ64&g1j$Xs^ux%L}8DQ7gvKbh?bgtJ<9)A3!ss@f<O`M
zz8Zf8_<~$*hwhL&SM;<~S6_P+6YqjLBVGs(iTY}8suAmsBa0^&Pnqrz+v*baiX_?8
zz4!gDjXkOFlE)xfFR8cu^!HlOS~lb$1b>7(P7rm!f#<*6T;i!+r-EZ2jX3J(9>ND>
zz{sDNOFfCtAcz&sGbT&pqom%$s_Op&I8t;bm=71V(NxZotJPeBH$^UQte)toqg2*+
zv1@bdKcGG4I<(R^`d^w0oh-zE_NvLihH*WL&oMl<QBxc*11N&}I`02)WRx6$@S~2w
zi#n<^`(m<twOfndgT?!CkdLZTUbD<N509RPXB=aP8>a(xd&%HR1ArA7$Z@X_r6X6T
zupm7emZS};hfDvyImbpqP+tG`rf3pe#T4b;WLxtXCY$eENX4<31;9?r$f@DyQ>q`7
zd7J8z$3+~gnf|ZiuaN}4cXfLTyEt@(J}n!ZtqN<E=O)2kdJSoN?Cod-7BSZSF6`Nq
z%S~_L$jl&u0&x7FoR_?Jv?@{i%NOp0qz@L139bmZbB51A(87g~)O{X}DtA_wlg4VM
z<<LdzSU5eb#YH-B3L5tK8aG#N{#2iVTv&(y=~Z(Ku|{~+iMJA9ThuW<-%JU9+SX9*
z!Hc{oT}^8yntJd}LHqg-F&qBPS0r!s%;F7Nf?R54JYwi8>SHAHh9rrhfSQHg66n48
zxrjcc#f^z>(l9pzlPYTrO`Bs~(7a<l;&!BuLY&sd3mLBUqXAhH6~@a!F`=0r7n)l2
zhW`r43-*z%8_&g-$tJ3hg}NV9oLwU}fhxn}9%{|=CFUvwi$&2;63*4FG-}{#w<jvi
zN2a28;}n+Ee}%U=KC(2!QYXJ176xwq`jExWZAV?t*6PUy*atFYLo}t(NauHJWB2=m
z%ULu5UAuTvHyRXAP<WT$gQQZORom`UldE8#6zY@Hmwm;okJ)0;TMS*L_!3QXfIKp$
zdXIMtbvdq%`Zv6XYm{EPDlBY|idL%qy><@$)Hl7$G5n9t(1Myv(W@PUu#N1w6fDDn
zI@lJ(5{%7EQa8K8Sh(UV%KeCA$iRxUQ_QNEgG@aNro|dwAVZ25?@7c|Z143q%E;K`
z`q^fw9Jg|9ayjUJLkRdABv~UXJK?<HjX-s};lx9Z)vFj|!V!ipzWoUF`DwB_riKAI
zyfsJJxbQyisn13E^LjbY4ewREebBagg+_sYNxf1dD$`niGxlY-5Ypn$&<QCuv>d05
zFe)q|3~f24OdE<s#(`JL6^M_CKzm@d1R4~TkyfDQ9Ib0+RlvO+Eo0S<i+K0a>p3gi
z&L4>xq$_@|`{hroa&_vEVUzaO+Y|X8?(@EJA<a{tvuY;s+`iHXxlVda%F_lx&$(Sr
zzj{EGRnxU_)(K@O4{5wEg=T|%_Y>!r6ADVkXQcj_!<ZIiKcG?F?TG)eO}mf)Y!VH_
z-lE3Q#6o;urLPjaCCXfAmA$g_Q@(0_Ox5o{Mrg|palJC<vz6HZ8@IVDQNe24p9ag<
zFWLgi#x%xE!Ei>n%K)Te5c#CeXLwkJSNamizp`LkkvbBGb9z#N*V4|64yK)r@@OAg
zQTA^Dp-0&>5m|im>5cOUKljT(COUmk34YYTtUx6iQYdBqZvP?Pitgsuje%lXG!<3^
zOhWq>lrA(v|1znVxrO$-Fu*Lzt*>1OXu}mjYM?n>oDS0evdmrIXPbzE#nbaj397}y
z*sOrBm9ke<1Gj7Ru0>yC9C>OM3>*I(`Wn-LGV;_?41FR^_nxE?6pYF|XCM_C6n1Tv
zBsYrI_+x0xfe4V~)%nO+UqvD(eC2z6Wi}BZNl6rd27O<0KrlqT#57r`ioSSnxw$FA
z;C?j^;?GyjM27qR7BQgX^traJytPv8*<GB^LvExVYTr45PMz7Zs&>?sYx1mes~+}M
z>{ai(uMKIe{Dvzig&CI!gZFj<j=Xf1JQ_bCibi#kRf@I;p@F@%>*+^B>~G@Cl-z4;
zYdg-(HtX1&<$uh^X$h$I2`<oLIJ6ifEu2ZR7*~C`B~&XUNyR?-mfg4=0d=U%D6TRx
z)6#rgJwG6MLztVFBOatgYO}@uk?wT%c1+!X@ogEw(6$OsLlqu?DtqTGGmzjn_%U-5
zBK6|?N#DLf^&`J$Z$GU2cl=T&anGdmb$B2#P`TDL<5@$!$qRgSZY9zVHfFe#9DD01
zrb0cm@gpWR4Y?T~xrtn&Gu*a~CaNpHqX;S{nIS#wy4Nmro{x#LI<V*wG@xHYErOe*
zh>lt4<;YM)$YpAYOxx-C>x-R5$bi8gnW(v-z$LuFP^+byC!aFW^C<ts_4%dtg9?Ak
z#HXEop}4mOELF*Gy5%ya?uc6lt56M#zhs1Qi8-4HI{gfTGNYIN!Js9erVbiT&L60<
ze79*E9D#y$oEW|><UPxJ`S6*$pLb?J`hpmXGfaU4>)4}Y^-a1=Jt40l+p(XV_JUve
zK>Z#$OKPnePxg048*jkXS38}yy$H!4N?|e@cbwQ73!ny89wyQ^3E^iMazArummU}1
zm*#ov2fB>(5H(W1R?9X*C?L>%7;2@^>O=$P#B$QeSpnuJH_Q)?6rbz)t{Ty}9B+OX
z-fxS4b$y~Z{vH`<X4Ob8?z2NAvgH>^S_^w!o^`?$^*+o@dk$ZQII4s#<?lQky}pGi
z%y%JuX{eptOY+u`rF#I;beZ;PYA=e1YHA{US8ohW)qUZZX1@xosV!WwrF7k9h)run
zNP{T<s_{JV?gtn;v)#PyNA0?yWB|AP60q)dmY&Z>*@$)KMvHI(7jDLwvZrt6B9Zs8
z*WY>Zf73a9pD*KRx<303{Hr61S2d`eq0RM*%z3*%GDI=I_>ZK}7xE~pf@syukFR)7
zqu;dba_C*Qg?+j-!s&T%P0RCmGVASZ+(7ralC4QCduNh%$oJtOfr>Cna!2X;{Ukw=
z%;{i)Q@Qq{Jz=cPxCsp)Kl}=~n^I<N`#Iq#yygu;$BV-RoB)`EAnNEaa|eN+Kbn%h
z$CkK>?{)`TAJoDK9r!D?oEvCp{*B=*a5C=y#<@AzmR)=vT<h-XDz0w#%<8u08<I`9
z6sj(ucIzqa4sV3wat|vrv^%x%$;7#!q(OSRQf+3}HY-8MpIxrKbIuadgDgbe0t7TO
zsFP|%wmHntlNqjtt^|^C3W5rb+q7Lw<{nm(YA5uN+eAf_a}n|0?tT33OBig=h9Ycc
z=~AL>4qlz26tmIbc#nY-$^niM>p^Xzo6fs~P+5&vZ^+4|hW;r5l9Ak+9?}mwgpk;e
z&pV}}&*Fv3j5X0o+7vCe;u3kN6xnxEYO=>xo8+w7gbQeARQ?VxbJN1Bcj?DcoP>Gh
zg1%g4`?{j+)mY1Qv1+QhIttJleRC|a6d00()~-_t-S>@;eQ@ql`*)Y9fS80ktTy(>
zs~QJvOHgwVhJILkDRPU%H`inTXr^-R4>}PC@B;tPoH#~y2-`nR(tNL^I1bjS6e2xk
z(rq`wuqkDFxFXFdTT@~)l#m1O_FGYLs7#lR3oA~qCpg2ho%?akk1WP%hbVIRI5{Nf
zRt_W-dX;`)<M^DHH;^N14(>r0KI?ioM?HWZo@-(KCXu9gC2kTGMeA{zSxtVGVQwaW
zoxC7S($Z*AxOr43(aAqV;2;yU+*g$2lrikq&2Pb~oHTQHf8TV!0UQD}EA~!m`aR{y
zk$wWG?xjNl`edo2Nm^C|y7Mp@76ex_>y9??NSm>SM|k-KjlY@Hs-wS$y`CEMG&4ni
zOKfJFwaS{7ooZV9zJ>smW(arfGiaCahnR(gE28()hu4!dS~2m(cUIH3qaGHz4sf|?
zyNVL~q<>f^sfy%DESAd;lD#1)L*I0=V*9=Sn#rvE{Q31%{GbmX;STVRc3{RK_#AU8
zpgOY^f{tK*E8JA)vUBeJlC-Uq*%e^WKjiyj+oxNn&}ZMQbH>fOmc-#VeiPv$f#LGn
zkn+rjFO^tMc`G4G&U|k)aPH@aO9Puiju9lsHop0MSV6FSnzztlhgZO>E=C1>nN~tg
zUXnLSTDpz)h&xZBgn)4vfr0xOsc1z8jk^T`&xMfnV^;c7MU}nM`}NaH)nJfd!gqk_
z5h+kV5rR?j<}2A#w_AG-<m_mrG0oyoxwb79+hxV%Qs(n5D>ya>16^c{j+2pJi}<%u
zc|z?WrzpF(u_rMK^t9<mPXNPXwdhTeZpFK;U;0dpDMK%-n&>#2FFOlr_a|0FZjB3n
zQyON)!f=q+Yo`D0u<GgROqElAs-G2JD+s!T))cYcsH5DPC2F`!rz-OaW*e*<zVXf%
zzq2Ve_@gq^bb(=024(eyZkvLF&8koR!DpxJkE{vs5h#q1dahG1f;wa<Mmy2N6ywA7
zGvomeE_+w9%=Md_0v|&mZ{sTL(^8liYdw@J<VelVw4bAbK!C$ce-yf?bsO7fP03L*
z_4N|4n<VHWX~<Q!XCdNhpe3vuvxuS`p)z_BIo_JS#SxG*{ZK<;u{2j|D#)d?wt5V=
zEuoBxxf}pY&u`~a@osad%?}bj&pLn`YSZb|p0j7t%f;BNDyq44Q|di_7=|#$zUp5F
z^k?q@vMp&#O(ScM4|PyBfu5QMp88{dUS}8^vZ8Te^0}7WDbI($JK1D`9B;#W1$EHv
z?YYy@ax#rH>61SXuL3d@2i&B|W$rB4rh6N_sgt6v#Y+A%4jEQ!9u~+2tAeN6?#Oz0
z3z2S0=hs(mNhH@X`NQAvgyqq+Pn1?>h-aV1)}t|*Ezh%Wj_t70<JI#eJjm7AEUM(K
z=LA~}AnXJ3OS$>Kv)H-vkIf5I>(SS;uM@1w>$xOoqc+0r-~uzqk*bQXca5ZxOoD0N
z1dH=e`-4Q0<&f&c<vYzePO4kd`KNoE!o)&qp7s;Exohs^x4B`#Qv0{|zu4T(_3JST
zH;UN|58Mz`HY6%z`|X6nIC{HB);jY?JK8nL)P1xNsM)Gu1STyr6JMll^a(-!*@>(X
zKNW%793HZyVK5)-RdU2TbJ$cf_<H?s*E=6Ro8FH+?l}Vn%_>_j0lxr^66}**dhxEF
zzSQ}FZ+`|Im(H{l<Q<XTdhI>%K05w(JT=^si#PXnGx21&%MQ<7F`&L>X9<a=N~F0=
z??J)(lox*92RwAV=@-9SA{N!=AAs<9S$B&#-65!zR=Zc#a(FD>b$>?1w5P;#rU??%
zc^{#~_)EU9pF3+P{F~KqA{ptVyK6`O*)2Is$o($A`vTMS+Y3iM=YAs|3@LE}^bDqp
zmx)<rai|%qYejPzi>~}`3E5(9y?{STzBKRiuaZ$|l)VpB>h;)Ex7k|^h>t^mN2(a@
z_`Ozxi%}5Ex+DjZJBO77T{%82O>TkH8DC4686HGW(!qBeE63l5`$Rc5wLOODdpmjL
zbgYuA*VS0j4)9OODR{X(4Ai5?w$|>b6W}t;z@Sz*_xQt%z1#{`)L~bb(?0D@Z@&{F
z8At;<`4_eO{rg*^Zw~dU=rAQt+4n|-2T+!B@Q}4I-HM3m$Yh8ur<m~Do0|*CI$oGU
zDh-p@YDAC*eyB|a!3uFj@B}9Rn%s)M$U{4mX;dOgXI{H0`Y^Iw$f*_&Hj09RqDGhJ
zMS%=3FBo@!)ZrB;Iy1ln48hs%G@|5*<kEyDS`HX@$s1fE?RbD6bWE%>O3#~DW$USE
z^r=^zUAnd35F8|65Os$(6Auc95hNLUM~L2q`4>E#Rr#{k;gvVPE^RDT{M&jK*mRS%
ztj0t`-c&!P{ycY2ooGPgg*m=AYV={oSa0g~qV~yX$#=`DAeGLDz_F`s&DQ=q#gV_J
zg5|Jt!P2aoQN1sYvFJ<bfF~#ldgo&u!nPT)UE)}TPsOzQm>VYMi^1@a9`3jOw}j(?
z+x2X36z_NgxA08UPWb4PP187WloJfEAIeYO@KIB#ZD8Hsn>MfUWPVKuHAAg(zG6OL
z33>ixeqE24YKJ1Ay|pm6<3mre&u63@oX4=g*+<F-p*CuDb)|IJJ~3f&3162@K<T{s
zCfcvi8pYI2Fw-EiYE8$Uby;H9FN?16v21VBaT0PLQSgnl1Y;5eQ^dSs^v_b=2(rmW
zrkYU69S))lj>cQ%gy(n0`NdnhfqYdyk^zNbL+E8k2EtXBU`IIRn+!c+z$-w;)u;A4
zw$ch+o<Gf81Rqz5UcHiLJ_Qh4Bl!hjwn@&K!Y@l^fl<z5Z9XE0sL$DPrhUbw1|-&=
z42e?;V6lp7k{;a_eM|GZrrqE7t40p3l<i*bM3mPs+ePc(IgRf8(=|_d<?cDxU<!z1
z_{w5Knu7*<hk)+TbbCdtBB^L}J*pzPt?7Qn=W(ph%8M5tv_ue0HB`Andjzr!3%(|r
zBumA<<*h|3ca58|sy*~?%1+>P&ANw#(Jsb~8ZADbQbbWlJqD(VtOB>qdYJ1LSH^hE
zEFf_oGu{;QE>_yxu|`~q=-rgcfiL40va7R?yOi`vAkf6btq77lyxil0b62Qw4!RYN
z#BM=$HyNZWf-(8S%{*B+Ba;SB`O9}H4;G3FqvfVNWs`_XHUb9?MVs%}lR4tVScVWi
zC=0wrbZy=-Q2~XIK06WKxFas%-wQj|s7XU{2(0j--rqm!g7ULTZI91Q@{Q>A)G&Ft
zh#X|xeossOvtS>=8V_KY12Cu<V!*a+DAS70Ze+VNO4)C;v<ZcoRH-C_83Qo15}kam
zy+2!KZ{5&cu5Mi%%0X17m!EGr`-Dj+i+8sr@=GupXxxac-sp4v{M8EksLxfhQSC|X
zk%rVE%fXJx$Sf2p-hFi#=kVP6tgI}FlW+JcRf%+kec7eT@Hz+O6%O$YWtp(k*xmlS
zx3@N0pCFB|Ppw^K{F@lVT;INOmAw&5k2j&Z@|7#y)7nhGqc4!$#O(48sbZu`;kRv5
z(g#n?@4h{C(hA|5(v)X&|0prS8yO7KAyRG@=gjSI#etF!L7G~_XjZFEpIFls@-M5!
zL!PGr(*P;I=oJh^@xUu3Q%jR1+QK}gvmC;W<iRA$ym1rMt{S86-w4j?Tik)3q@Tub
z2_HUq?9<&Q0>cm^6%>)@s^XNRcgWvDT?hfVHy3!uo)_OKgLyN@Pg19YYj$H%70a9T
zs2?B26J3;+g|W^*U(T(prl-Vrw5B@=*kP+<B@|TbhqCuLi{JchIvr<1rl)dRqV%w7
zx^3(JG*p?`H`VSUho&vNa2Nc$c&69Nm@+bL3eqLe)>R69de<eS`&6^9X)_i6m0;UA
ztZPs@RpU0j>$vMqRQBqUORfn(GEmcvqxd#h?2*VtKv?Ba%CuY;8t1<xX_19QiJAy!
zv$DN#=uVs#VpRCN+KQd=C~QJRyRpeE<~fAV1<T;geJMsXeRx0JdO?;I@gr~o)9O%%
z1>%7})By`_EyRR+h?MO?YNB{?czA{;ex<I9xuhipehoXCXp1^tz5d(x<o+=^0w&t|
z;W}{$edO^V*Z+Z057YeJP@sn-8<e`8g!k}_E-co>ct|Tf>G)yM7~wg#Ynnirl28TI
zS-v#YbKj?ejcFp7R?uydCg`W@h0z3!nS7<@*`y`y6w<sXSM971&PFZ44}2=}Yr5`&
zQ^WJAX`5s9RqD=XMH45H5Ygp=xvD<x&<RsgS8SN-o(f_c*q9B89B`R05)}DsZ{ja+
zR%*e$K#uBfPrn4Xd2PaNVtrmri}~NS0Y)a{S-cSoTQbouqM=mq{^RcFhBS=<LiiTr
z_9W^%BCF_gaaJsY{lxQNc1KJ%U)Hh;>df)B<j+IB+@zRCp63?DVs6%IoW2d;{E{tF
zkUTapj1!bdHB(KF9LCy8ZLDy`C-@30vz|w<H!ktWALp<0rK)kCuEbAzy8q0Zwb(Yv
z${(YfXd&cn>ZyCqG2G*9Kj+il>^oZ9rGHzG5t$r5V=c4)wYSEc)lDa8)IjTMr6P}H
z>E?mHc}o!X5(s2V?{nAXr}i&~Py&3AE3gz0Ba~W^vWn&xna9`nxVeku&6c~d;@1U!
zV2M?lP|{TidP<V~Z4!C9+M~9aNQ0XR0WMOpdV@t51D3w16HU<4N-UQ+x~tYM9lD>f
zo<@X*F=u2$9ksFJM)rZnA)`?J_FG+VLF@?UQ(gS}V_yGPX-9P^?PGtIFOTr+OWMvD
zlAS6j52+XGmHkdOTVshyOQK}d<|$WSVo|COzu&aGDUyftcm&QimO4~Z<BpX?vgY;g
z32XiUl$FWt(ChDruxvSdWlh~i!6<x_qH`*c;xz90=GL!fxH<_@u5$US(L8t!u}PPl
zJ;j&9Ru^sX)%IhbGj{q~L0ig!9LjSXuwGgsUf?DSmDhVyzwY~Fv`Iy)|H%(v7`x@*
z!h@VgO(L>-vFL-NHRxMl&;<)2VM!TRPpPn@l3UAZCFSg&_o>{Kl%IP-A3M5RZ?<_H
zb`@&!vK>}A?di&jvMj$7&U<3dQ~6(%KhqMSTw_c5TFkl-R<AV}e3}haR&Rl!B{}je
zelu+Q!X<Izs86*Mb}SxfMRX9;!1LSeaaV3^a*_^<D^(Oj1e?`na%OWBb9y9aWLha=
zu^*2w$^hc&Cs9Yq)w%7GzZ^!VE$-R#vO{B|0q=we(cU{=)w@i<3KqS|_aRb24py8Q
zyM=`Y+FW=Xh_2wkr4}D>l~PG5x`X@157a%$Ny3vpeS7UODfdwr#=2VnO{4OBQ0LR~
z)^t8zpk;*wPE^QD-*v3`jm8gt|D4oW(xOP44hg<CQS^R{8ve5Zg5`va@)q0yzvW#@
z4-~^cyE1ydhsx?aR==H$lq~vDEoGEMJr1)-^zhU+?<T=>faqQOFTVMwmi&g|G|SCK
ztgDEfu^$A-jajBh=0iYMpdq#gTRIvk`EmKiJy&%q6JBEGRV$j&oge_G1oamAwNkYN
zSc=+G1F+tv*RS0lIJuu+fmw)XtIX6G^(ne4S{D7}J#pOqUK=0N_@VkKxhr8qKuSMW
zM<+dDF>U$#qrp-_L<KF)n*?*@mA2uBoPof3vpb&{$^j$#jnuALJ;G>fRrbGpVqvb&
zvBXb$x|w>;>nNWtT?KnFXFk6w_TBj?UCpe+E~SxP8lA!y%Ni|?ylqIeYJavUO11j0
z<5C{S?MroAt)%il7NNiAMnWz7Mi%wU1S-ezAp}B{GV8^VFW7b<WdF#eatGKPi+oPu
zW4Y9JE0!)gjF_eHmEdcg!uVCXGSo&?;<8rlEps=x_jtVe3iJENT%MJS=?A$9B7YD5
zpOam&`uQ1VczxdW1@;=Dx%RA}8r-MGB|js#mM4n(NZ)mE2pN=SB|1iwqkr0%y%*Yz
z_?3my@8OQMbu-TABI0=ih<s{cV=}4s$QL1gsQISEnSqq!AMvaH=`~BLP`|rwEMDK6
zj?p?a88R+r|4iwZ)lhf7<S%iR@i^>67ZanbZIpDlaZv6|jwFi8B9zjqjtL{xEp$3%
z1Hn<f=d1?!`|s1fS<wgSM}bbY`0n2<`Zvy5;$@HZo17cdGk^S*juS%4f~%6tV;L!a
zC+cC4bTm>Xp+eaJ@@3S*Pf(oYuYP$(>AlXWUxFK@hefF(WE{Lo&P7(ae-j&^x;I^>
zszdhnSE}AB$c4sdN7XJfq}ewbeB(}Q<HZbYt7iBrXcHaExk}i1=+H#(@UUk!1}P6>
zz~iatYCQtG_j*COSl2uOYU(}c40)b73{8i1;>$T)E~A9NAi;?O?2o%we~WWIs?aRq
z$SNQAv5;QyPidbgnWm&uu9z=l-B2MiVM4Tb($oj@xXl}{hDXPrs?Q2*o+shf=fC39
z2{a15Ka&BjKq1b=J#kUfy;8dQB!h3lY|SEnC(^Gx7)}_!6vb0tmoV7tYmkP((=X2W
zj03o!B3X{nJ*6sH35O|IP=I>}NhzBv-E+v{5L+giY5>i5B8uO!fn@n{$XPd{q;iw?
ziyf#6(MOFdnO9~;WtA7pS9^-OU~ysk+$SZ<w#K`=G>eYG+Ky-Og1gn^CF0BI?{0S{
z5Pl70hu`Rh1f!M^%(9mXartXAmLLIQ65Eo^lc7V{^uynYbg0ii1FnpzP=6*|lsd)}
zBS113`=#Cx3(O!YdOuG<=e_qc8}LTrcz0tP8PJ+%nqo%TgJ@%M{=--Cu(xk9^|BKV
zC%JRM&&rSQNK1CXMdE})bauN7kK57Nb!LAMO6rAPSvBMSG!!x1=Z9KpS(g$;ScICl
zib!@!4-`bPB1%XYj-^a5|Nc!6#0qx7TKFbyRYw)O|G<QO6i;w}jQ|{teMNoZyID6z
zGDf0s#Fiw(B-DWI;1<e9s#$i1H<Ajfn)1!{^Iz08c&c=cczA>{qz_sLO48IC#OV}X
zcTg~t-2~utB&-8y?&jgD;OH=3;A2+n^ZdBDf1l|^k3Wa-6DPb8kaLpd<Pb1ziaz=3
zh9o8W2V84<F;Xv}G_T@QLF(sPEM&cQrOPzD*2i^q$A{f8joLlV3uTNicWxdeqMp{R
zP3L3IPA2n~y9mdDSkU|cf(q=CJb(v11be|Q*l;dQziMk+V6Vq~5Z=jwt(Up?H8J+5
zcliAhj;wgy7sasFdDyB#7vgx%PT4QA!MvZy5M4#KU0S+<I%Gc6c<U+@_VzwUGOMHU
zq+Aq-dgS$rQV)hW%E57jxYf6UYye^IzA@6tMlo#8|62=6Y=g3CH~W`}-wpcOCgCPq
zO-OObB%O{Y&>mdEhocw_Jc5^yg6c1soBspXKq$ZQsyg?Nsh2X3R{HcKaCrAldGooa
z<s?S9^wmEef&7@aVvXEz_x-Z;s`Z#@$bg~>`84SO03ZNKL_t(x_rw#}rhQs|tE3xe
zzqCMShQX_=PWW)70YdQt3Qg6ild>NQ(Ls#(dGJmcLJkBtz~z9S1AY%mz{nW51a2@<
zlm1`pMD4{0wHv~}5LNvX;9)@G2vr+aGs!qW!IuDownghUsbh8LE?uFf+IbEEgZraG
z#Kg^&7$eX<oJXh1+ZlF!%tT-|J=N9YSlQk0yd_&-c|j`SVt6d4x#>&c`n&Fv)mL9D
z*?H4le*{KQtA^rFzqEz0qAr~?!gq2^zPjoJFP!FYynIP5VbF)dN$gnYY-<_Q{+s@V
z*9pUcZnX3%z#jqX!sP(xxdlEo4st5~h49ZpzyA*KDL`_p@nBj~io|g$7yH;@p3bkJ
zIvA%H=dJg_ds!cxnGnJ-wj7{)-m*o@<SJOYFS}}^5{3zMFr<H3<_D%G`TOC#wi<ea
zG3A)H<ECPRqlJ52^;y~a+Hd6DS6;-q0|RdzH1%J}m5L87`ziQ0-g2816qmRziCLc!
z*zP>NjSIvTy<5O5>!J`bvjPf-KV5jgFTrT>5Zn{*z>bAl_)ZwEJ7wNC3|GJb7{@}x
zQU#|aB;s3?Ce!flPlKCnZlUbM@=_mXqF`sz*M)7BvH2~c5<sKwKLa#}N<iS-qMq&)
z`~%_7y;ENVd<l>dODvd{k|z1LJtWx+mI-~`C%~|Z23-^=oNn!d0O)RMlFo+9(sB8M
zG*=v#mb0g%qvnkCVSjTN#)bnFj`^kKvi8PXWz{t|VB4Fv6QKCk(%J}Zb7jkH!SBPH
zW-Fvp9}GraZCWC@3~>6`5qTSig4=P{0MjEmBS3qC4Orv9@$UO%CcO8lEq%Tgc|zQv
z9bv8{xk5Q<C)XFZ5+-V{)GE5VJLUYjYT3JWv+|l)jrIL7j2#E!@C{1LE0WB4OC+NV
z&mKx(a&EpP;Cn>pS~zGLIv<@Y;adbdm2Mm$ReyA!Tzute>FsEB6^F5F@ql;gK<?iH
zz6=E*vJuUI#V1#0@H;ZOdN+jLK=^Z=|8c;V0Xah`GG-)k>Df|z-{Vqz?FZD9Glc~o
zn6XMU%dNyIz>lyGr;~N!Z1UE+DyheZ^73I=c^})SeuUwf<YV*b^5OVqC0yOEx$Z`p
zIh(?g6H1;CA6)2rw5G*;zQLeyRtBy7+hFB?XwOc0_18a_V|#Xth!U`9?FPB!-Unsr
z>a}W}U%hO0V<4nmfo<V~IF)wh_<i&?oz6ynpLDi&NL9rt*|YU+jQC%cdhFdFNu|bW
zY8VZ0AU-2oGG;H9oQ2CJYxV-kD48Wm@R-Tbf1i4Ro!uRLc6?TRZcZGZ8sNI&aH(d?
zt8(t=-;v&yhCuD(o~%a;{wv@KC;^-mn6kn8d`vwaK=`x&wDjk8ztULZKzweI%((aC
zQn>LZ2!DE~(?Z@{fuNZ1;T6u%;pf<cV@z9{r2(@7HQV2o%LjKz=Y{A_Wn!uSlc6o#
z55MMyTVx%e49DFjWA?@fe?B(`b2S-m+RjsyptUm%PG9W{6@hx3V)yRrFUw}^7^psV
z+|C|yya?`kIpW`N<1M~*{$K_C@CSnt<OXlkxbc88pz!!ZZ+*)D0jBwPzl}2zF4l#D
z-!O6%uUuYC$jp}9W$UD5<BgJCK3@{yPXbepu5jlwQh+~hT;cpm0P}h<7*R^V)8Ch#
z`k1o4WAkV&`gy<$Q+X*M!Y2hRnIZuSzy@^ndw`fa);A%)L`oj`Z7Ep032Us*dNLoB
z50LOF04g1c#=-UAquNw`MrwDzD|NfJN?Y}5EFX-I_4pKdz1(hQ7Zl0b>pevv3G1e=
zFh_*X)r5X=3t>eKxvy*x+0)&l1nJu^zaU$F^SrcRnP?~>dwPLf1xG&D-|<1ExHt}l
zbV+_X10e!R2?v)91U5~-xK;$(F?C#3aa!JmQ=;9QUzY}WCk(^rb3mP(Svp4w@x3Wt
zwLvnmlof|}lrJftl>+>6;}LQF6#&w6E9QB8Z_fVctJ2dL*?-08_b}=mxR&%OC;;z7
zrI_Ryk-jODyvrhb<Ub!BeFCr^U}n|Fz3&MHGo|Fg-;w;)8;36Z(P|15K1>2TW2cp(
zzzlw9u};^9<7dx75vY9g1!=1~1qU&qlN4}g)I$~pD{KVTK^Z8Yzd)!6@Imp>n4sbo
z!ip*qUs@+ToEJ0o@tJo(upT?OU!HsN2Xf-TUQDgGx!J+U()HKKZTCMUi&w6Zl+;vY
zN2pU3;^*BG>`u~;Qz?r^7qCc`Q0ZuIm$Ro%$QBqe9)N%T%i&bN=G^FBDEL!m%#v9*
z-Yqlmy-CY2^w#uoYkn>u);+<m(#{k=pP`fQJYSV2t)_9(PF^qUlrHXjPbz=>HR--k
zJ-VG5e(l>)<Z&nghlXEt;+Kf_>z?>Mi_!xv{HG)PdjL-V#|#e=i_4|-p-)NPiglQE
zONb!IoyI!C-4PsYykFScG>mIH5Gut$cbJyDEf;E}^4&M2YV*s|2BX0+j6MfwEJ$yC
zSHqx=mh>~>t<Tvt;Jt=k%xRCC))D98Vil1;)xRHH7HELSzin^6CcpW`lX4!O0PRpV
zf3e(f*FCZhb_+Rq`FN)WtI_$m+jS7b55EdJ;->v*2nww6<IIC|XU||8<4ZXA;8h6z
zaCu6zX;d$2#1Fw=diBjxw&4azFPs5`V*fNh*YQ1Ju9W~hOg>K^_;AtbxEyfl;BKkJ
zOhEVfv!mL-VOGwrJ`eZ|lz^DiPKMc+VUyDUZc2rsq9Pjl{UhK(K+KH%mGFP~(~`S<
ztuyjR<Dv_8OZc-B_*V0C?Sd~2T3_0!Hx8cRQZllnVEz&*T5*+3OG%fO^EJ}b4y)ZT
zj2Z`&;KK;~B;4>G+O<Pk;mt2ACs+CISBDSjJNup`pC2Bg`Nt>i=7XMb1{bI3S;hjq
zB&lg>GH1ae81t>esfVdj2g~|YtnuD}b^Zq)|CFr4IRfb!na;iJvUXhG$9F#$XIh9W
z+lz8+l)kWtigW8?4HS?!o_$)L{{FY*;P!W<t*KGvhkr(o0~GSf(~G72mV0ISgOAJ1
zwbw`rlu>nxr2UXg6Ns}zFpWGa173(gpflBMLqV}5my}EM>0{E{95aT2Z1h|}4rId{
zb#-;zB`{?|^d~k6S%A@h8oKr00e=d>(PXg^5@*hrnGgT2<Sbt0oIr<WsgF0WHXz}o
zEdk)-be=CgE%GdaO~W{T#l6_K+i>=@oP6sya`vqkrI$yfhD!sZ{(^8upa8oDuD|m`
za@BP=NI_9Coa*otLf%^aQEl*IPLtfU8*%Xb8v*5I>R2m0=p8?JKoKukx?G(X(2pnr
z!vDe71R5F4v(r?3dhtG;uc?upTi%klp8vJfovjFs`y%joG*Ah!>My<KR+)R<t&)SS
zd~w*;$>+l{yEoED8b}APuSlrb07dEHf;7H#uugR!r*3W)tUtV0DxdtibXA=kjjmp4
zoivEz!0>M|6VP&{l}xm9L-|%rv_3^_FN8m5JAMbihfJqGF%c4q%cbmNU%+;o6`1zN
zhaas{fIn{Bhx3F#r!V>`3chmAD9l$65~`eAr&k~8y5Ldm{IP>_<i%fL%5E1FgV0bA
zY#H^yXFqG<61fSZ@s%5{mRua-<2)Jf)_gwdrO+sq_OgAkf$|KYGhxdrheGXq{7u>5
zl>)#GNZ9FKE<eC?-`@A$m6w0<Q#p6$q;%t?!!V3K2RQPczI>f5y8V7BTD(H}5uq}s
z_U_~MN^q;R6ZcR3n|xlKx5c5?c(=S!5)2-+`W;a879G=61TP)fB~?#-Te{9(*$x#{
zGa7-@5`O~t7L))sb<&3^vjl+Yoonzk{}n)YzcCRK%N9u4W1p9tMJtCb{Q1cqNccOh
zf&w%sq{^|ZD(?w@qfF4VT{hMPXDnMS$@#_73`=Y}8dAULnBdyvYy>~b^%v^o;I8+i
z;^c8G31mt(P9IE2ge?fB@71#oJU?>6_dHG7Lb~NxwjZ!wtL}dJP8o9(Ro>jgx*}>w
z^n0Zd=o1exqTqk}KfeRv{}ZXl`xNfwC&xxNQ1GV}&XlDOd_q=!=p!<H_I!zlhe{Rr
zAQ4;%r_&0_KTfurbkbIti1{A5svt;X)jJJmXQW_fOmguoX|6may^WXb!s8j|tng~U
z4#<l$SPmG^wv5TWC%pndqdz>%h2Z8_0ZRdqUd=IKwtbVt8FOUjM?bGT{P{-yY#>_5
zM*2YE`U~v-G^U*Xuv_)?w-xZ}^W77PB&-(~;G<Evc%}5>W71G@B3u%%AK)m(xjs$<
zy?xua%7xlm*azfDW_GqD;22^C-}AN*>iO{<QSXUI=f(J}hyKrB&PthkSPikFs(n-z
zyJ7To;_yNF^^cyAUp?_Hsm5`}q2O1KaMb@Kq-DzN8}5{Kk9|hUR;`z0D3g3IT!C-i
zn?YLQqaTFUWDmIvl>i*Kom5;VEobm<G!1Qws=3c7UO79=9b#`n0f?DKjaGjry#fH?
zPouxT2iytZKzH0jLQ$E_{P-V8_WY&FmwNC68vKZR=_mplJu)=T^gifNsjuFCX>A|C
zvQ~LJ&b8=t7^uxyvQqNk2DGK2URuwGmfB<S0`Yj;Gslm}{vF$-6Vv6K4alG;HhVU}
zdZv7ek^gz`!EoBG-UIV)M5x)hpY`srEdWmM)}E`97k~bw{NnrHlq2v)NTntWqtAgj
zIP%HEQsTPDJ}XOZ{h(xUTOWSIZs0?W5*+V-R%Vb^r5&Ua@)7f`^8Bg<X_#%}@WLd)
zS(cg!IF7@tT4TZxlr1a=&?xZL$!-*Ay&ZfylPh5K&nX?A{`5IOOq}kQz>)vQeqXW|
zE|WNn>iD+#01023`3mO=e=}Y0qw|&XD*%z{z50x@;3yA)`yn#{&WLh~N~9Qyz%(2J
z(u955;cfvum@x?L*d=fnu6>UkIv@#2_`t)L09^}n8r3iGy~e2bg73pfgLe!4j(RQN
z5=Ki?lWcwcRe9=r-@w+s7vYw;*(wo6N0S3dS-G<Cjt6AjgTEz3*wV?RJQesd_#-M6
zQHX2G;AP08dR=fh^xT1vjCVR2hKVg_Vrn^nv&NlJ0^WrZFlim7Oj-qiQ~!8?_XGYG
z0DqS1n}y5x1&;hn9{rqTV_Kd2{MkSoA_{8KfXMmOYI>En%IdTuz(E-$A82(y9$RbT
z>T1)wafik%8?a0&rV{ya$(uD#n(HrzvjJoHDmCEf--Ek%V*A`#wQW$@2PDvFR6lP%
zHx26H2Hq`X`JeeP)2gf1J=}X?Vz~qR`H$}3D^Gss>yD2BoK6^qvEcwm_{DH&y6(|W
z$>QrjAZeJfi{!(>70P@Oq6IuumyR?+T9x*YeO}b5F_?~2hePTA3uQJbXSyU7&BVDS
z`=zffCKN{w7*_(0KnXYsCBVlTe+MRRYSJnIcxY?zSpFR_6A<au9Mh*3Pxrnb`Ml&V
zUE>IUw1|!JK~$V4u#J+y#`nU#FBVpvZDV*n-M!+v9{-45-%I6r_3=aQ(y={uzODxs
zSGXj?kSM#jR7#-4#HVFQ1Ezb!*#JI`(GNV~Px;7y`weM__q_bVA}D3)-qukxK|L#d
zwOeH4hZ-NOJlFYap^!ZP)RXelZ~up!K5{Ue?zfpX%JG!ELRog#L$dCHk4e$IMee9y
zNh&^M6Wq8PF*!Kc$BjCXU|MJUq#tH`)V5B%k8~(TCB#-bJlZIgML@HTWGn|H6qZWM
z@q^OW9uqt9xNUp|U^5he8qJDHb(xe307n1CcuHRZ(AR&2*KKT{;k48YDTeURgP(0R
z@<)r<sD7aFQ3W!~kOsf7&c@4f{8vAc>TPdI8xBk9!M=UgN5AbnKfoEe>(QaUm!mvb
z!r#=V^Bv(&g}`4<wNtl^rD>I(3WqT>7A%$AnX{z<*6VCT7{-PJR0NLg-y=s3?85;=
zDQe3g-S(>IWS*tD^0`IKFa*)B>V0sZyZ64*$gdIhAlu%0U7q;LzsSyappamxA`D~0
z0Se2)C2M5U$3H6zuf0XmvUBx^f%oUbju14upK{QT)FE_*xT%hYofvSm;CEgRgWwvt
z5<d$MqL+>xkgQpA)%HSFm7(ufuZM8!_E1htEe8}z9A*PrPaT005ED+x^3b?43@B+7
zi0x35D-7XrO{@+>_)}~9Ux3d89MkD>>_S}DbSd~S4)%fD&3LuuA3?aHeMb25fw+JO
z1+JS$9tC^*<qLB1nV-n{w_i{Wd-y?6XLjf0OD3l03zn^sd<f@sSlM#j*q!nZ)aNJ(
z`hF_Ux}TeN?un$+4m8w_1Ba~v(g2%)Juf^hM_+qJc<4|V#*PDtc)sgzxK-}B|3R6%
zaFHZp?N<r>QD_2WfONxQ)Tv`f<%M7VOt#^)!LD#W|0r-edX)*O>9X*qyJgiK_hBZk
z1V2hl+vB-VsJZ}ziTB!hZd~WPX-p(qapsyjX^h$g7tI%OwD@@(E#8RHc^549doAHy
zbn|^O|K7(ijZaw_tc&gP>cef^wwZebaXdh%Zp$lD_tXD~6(yhx&E_t$FHJTlL6d3*
z0K%W^HlGCi8Gr_W;~F^f&%gJ#ApCEUczmc`VQvXmSC|HH&S>2d$mj`I=sKGk<iyiI
zkPDj~Z+)tR{K4Z#)7=Cs{j(?K!k%~K98TbBhHKwA%myT-rE5iiV|y*gdA09}ctqa;
zK05S3moe?5a*+n>^cf45NP2#eT&}9b5yTh`^4A@PQRe`+)>Xo90QcJW;`ryn88ej2
zUo$1^ymRmGFFQeJK9|nd$!~uB3;Dr+{2w{GcXzn0Z`7Zz{|2d;^1u4APs{2%?v+g2
zQ51jF2;MJFBOJ8%*F^```bpvDIX~SFxMsd^@`xOJ>6dc!mrqFT)>ovZ^0@T0HsKUe
z%0n--o;ePG4{ee&XQ9L=;{YkEE|1EId2I~l=rqdGFfbKo74*U2xb5UYXr2E1MJYL&
zXv)bYfOD7$*o&C}`b(M=VNxjocsO+S!*zci_A{<w8ZGDVcvOm@ttVibmcI%08RiSF
z;?^}PjwL+0&c+5g_3Tfi?#*YEz>nHN2;ZL8W@)ZCF11hw8fvQW!%UGBob}Ba0oFN`
z(Z3P$ZW|!%-8kEYgh?l&{z9A|UpRM>G($;g!aYMJAnFqu@r<^X7CDIB0vw%ZX6InH
zK)#v{uy3TE6`$E)U>AZ|>A=T*-;V9_!*707-hSyhX=#j!?OMK8PUZyN_LjkK|INSs
z2Qp{PdYt2shNr@(870_RIv!E*+H|OjBlRvgZmK)HPxd|aJvs60kEIbtc|9$7-UBK0
z$ZM@SEghH*$|{G$A$$v*FN0|xZWOqe%87*28PnhyGo@sf^u{Mi`^iJ<6jM{%I9+jc
zrz{6>S3u=BwPD0>J82XEjQ)$joqq+;ax?0yHR2qMR3WD1vu?UiX596#B&4QkA*qF@
z{w=V9E=0k(BXZDoH8;ws=YA@+ul};11|F#i3WpzNFQ)KX&YqGQ%m_4MMj#26{Ha(o
zbe1D@8*qR3Uct7wX{`Obag^&9r)>cGonIhjOJN|0k5qk4wQ?;SwS8g6h;o32S?6)U
z&jBa`EzQj`y&xaH12UCe2%p!Ge-(VTfIckmR99BWvoP}e<qy9v6~~T*qy7<nVuM$f
zh$;Wo_dFukJos@bD4VTph}=?qrY6{N;G!xBE}efCfb08pM-R!tXP%TJ81c89Ipz#9
z1`_<ZPdv^Th{s5M8g@0coH{Js_>yG7fml3`x(<YhN=SglOX7P1gJT|7+||)39Ti6h
zRzkdjqZ!La<+Cx+d<jaxq%eAMUx(4;+Gy7e;ZK$G{{rx!AH4x~wC@_ZevbT8*W4g8
zANgHL%FeR{B@_T~n+&(1-zb~;iq0EtcVpV^)U!X8n&13v=)ym8^RVZ(NM>DkyUe@p
z1Cj-ozv=`!`+kV4Ho5K4?M0*9b}M=Z@3g;vUKdWhJF)X!dH3i4DVH%55r(nn!2G2v
z<n9L_ku^BwkBWd<78tB0R3vy<(Du!5VXgluISK3j(2L(-TpRiP>6lGhfA6ERVEwh2
zxl4vnr(k#FpcjXdZ}1WFJUXYW-`79NV%ex3vvtScep$}E@w{|4TtqF=1MQ9C)3apy
znoV#zv|Q4QXR1L?HwGFV7^HBvBC`xfTw{k2bqDwUs4}80fTr>FfwT(G5-@niG1g~)
z{#|L=@?!Lcja?4cBj{M}Z(tA5F?P2dojdWHKA{7IKl^Ye;QN65@$O8@vW-#-|Nf~3
zIAhxqloXNvv=OZOiiWcz3RF3k;8cE#RJ`;Hsea)}>4T;JNQKPVi)G<$_e%M?O|a;P
zhdJI`-8a|{Jv(6M`QrVBKkMRbK_5OY=T01!EkFOERPNa(y|7aV!`N~l8OQ!!d+Qx?
z=lu^z`Mmj(fRWljp$l94PQ#|)rKf)(o8io-3(qVR{sVDr<nz>&|H}2U>A{c53>?=@
z?~fFOK0`e%IEkmirmiYZL8}3gUZm`_7w?m{<|aA4;~hEn@~@?t?sx||_)G0R*mS$h
zzWHv+DlNw>U#eGk@ZP>Qm^Ps;Xn@-WizYJ8YkM0EjjMk8O=;V+8KuTOP)m9o@Z3Z{
zG-$#v0bn|2HXg)R01E))8WQI$lNk?vO49J-@C#EdByGWomQqmKbpDa|G-XkL=H*{W
z_47X-QQ=P}b=F^y+P&MQ8QZzi;fX61_5pD)zVWxgw6VXCcSioqkJ2}Ej`d~b<;%=P
z%cKXt{7Y45gciPG7&{Ko4ezOAhh-1e@VP^P#|@{XX+tgb0-`OrQi#;!#J<;Gd`_PD
z+P}%+eY>O+4t|Ia!`N|vOLWU_`JmkR*r%irQ~vb$===%;ZQ!#r!HWC#^;>vD%Bwn-
z`Sfww_0;#}*fT$t_KUTHp7W7hP%85ucw83U{g7nBD=3u|_3=_)F<m>~Bl|{!#0RJK
zI*<UqB+uZv0Vkyw->z{E_yNgcz^jlym$4i$&ds^<+fQf(0Hgm*bp3At9|U-B%a!xv
zic7}j7OK7enegwg{I%-_u~8I}zV&mHhfF8mx)O(92G{P-zVU)oJ@=zg+X~YMCqfMs
z$K>3BJrW1QolN)+r!k*ulWv=`4bX8L@5KFzf%#N9N{y38p8+Z988Q>Q1X8dhav7R@
zJB$RwFt!|MfmQcz9x#NDRZd=><iKMb4;bQe<W@fV6nOHx-;$Sp^^`PRx)_f7$M*54
zyQSsk%ch4vDOca~pk#1Mof#ddT>T@|?eYsxKE-IkTI+{0*N&4tkG=h>?E1;K<l>=S
zn5FBER?x*K<rT@|2OpQ&*WN0LuxWC>R!+9lj_CLA*Um_!L&1S20fUryY;A5iuye!*
zL~dt?7GaC&YliaYH7EcRb}3-ODgY4vls6v*d=Ws6Y}~@M^lT}3_%o7&bGPG^dsa)J
zqg51z=C{l@#|1>(xWNO_*VQ34aPV{H=ikNw8Kdueq6=2OwFh@eBSwIk1;vsMD{{|w
zz~DmO*EhFMR-ZwT2><oP<#Q#kbe7asoRYSNm^lJ;+}@k9zA;Dhm8VX~{@uG^w1sox
z3kqN?*aD%Ct$knrsvJLjK)S<y{bT)D)cuOEo__PkKP}6zy;+jr)Jc69OiTEYFkuMs
zNV5Rk#(A;wwCs552|4_$A7HH?zrP{Q?##RAF`0YA?UI1suwS5~QFeQf^xd0n4&)Qn
zuMQ%k2CD*mM`*)@X+>#;10q-lMlCf48En`*z$wfE9E1`uA-4ujNCiNz`>z1={~0h7
zFn)pC{qDqh+t+ZfKSs}ZE%;`5U<pDW-dQL2=uifUKCHpk?c5?~e)&D=Y2;GV*aVIQ
z8ept<{?u_v#B^IGoe04S*Hr}23}4@nFm3nEZUD&~m8asG7l_l~Ft4y!W-VDEjrH{~
zJ~}((kI>j~VQSokvjO{X%HYZ4$7IKr&GOdEFGv%Xg2L(kv48$l#1>w2v)uNH&qz6U
z&)|C!J@8lM51ugXpJyn$u#|Ip=T_PFqi;y<?k&Um&E+mzFUvptaY=@qP%wD+4(2%N
z$ocxC5TQsv`bb^EvSJF1m$^N#?a<B$wTvl>TOF1H-hdJS9bn=u1x!c<0L+H(OZgYT
zH2}^8j9W<Gbe9y}@t|;x$|nfXBEG*$80vT4NqYj(mu3&()a4SqZJqk@*QDz*UZx>x
z=qx%?fnEly_r53X_-Jsnp3H5G6!vIrq$z&CQsD2ipWexf!v`+|GYn;mm%*rMn$%Tb
zO>YR(kR#Q<upWm46!vvE$AP~5!{d6#=dIutzg4$=NN)bfCnbMonX;Kt9}UwSejs%4
zjjS#FK=j<k*?6H=c0Kzu*@J!kt+i0NhY{ja(q%D(e*q2vGdoC>khbs7`c&FlY6#v#
z)AtkbHeIkzJ1-FDPOIdiQt51Ml}>C|9OpovGcy3(8rU|@Z5j6MC!7MHr~ZE*J^d_T
zAa!}z%ouKgq(y6`_<>JiS_<cGqp(jHGOhka!bia2gIo_co2Q=qhIH0cjEnF${qKe6
zt&2FH`yx(t<B~uI&Z4J5pX#IPr!&G=0v<>YAEnPOjiX5LW0DHHfLRNdV!Kef)ZrM=
zF3Yv3X-9YsIWSo{z!CK(?Crny-iIX<zc1$(WqQkBRJ0H|&k?R(9(Qikz<uvKKlp}J
zz^(3;9N3jsJWH0`^QiJ2qJHFoCPfwKXhzgLtB#@2IOJZxOz}9(wkE+Su)VHUy6c9g
z*qAy-@LGnt8Za>3KGBu}CX@o8r~WsB+5Z55l}x1964)^aJl(J8BcGEr9ERhZ&5p+4
zJ>{$Fffjf^oE}MAv>fRa!z-Ks03ZNKL_t(HVfy{V556MpXW;N676RJTTvMq&BKdO`
zz`+j=>0m!pyPeOKufJ}80tSy3K1feL_9b)YOHR=YsfELtw#NEc=y}+NkOQO2fh<_j
z-}SqHC|BKb2X<tn<2R*$B<8M2I$sg*qOyQ@g{GoWSeMk$bikY6(JgPvJKy^^xqRZ#
zpcekRmVTF_wb#n*4cBYuLxB;#eSeg6+7&=rHM;FqIM78W_4-KK0qE#!AOY^jTaF%(
zzE*fE9G}1z()Y{~z!oS0XD8B9z=To&z+4Lb{|(px7~s`F?kI-1j9i)i;O|QIva9gp
z;F;`b4F0Gq<1R#20D`owwN)7Te-nl+dq=U=!>>ALHXM;W^4n6n2qSe&yE*;T!XMT7
zmONDd2UZMx{Z{m_>`hFNg3>aXF?S)n*i}i(r3>L&^za{5SYm>3pk&c<`Os(oSQf&i
zZ@k({cO?zyFVP=d0gK2*Y`5L<^pB*m>hu*0f7V{Q;U+0u4DYvUD`J%U8MM_T)fOwQ
zNUXHVcN=Ufz}2F$u#uyR7RJSNww9GEtw-?f9ABeA8cE~;xD+sQ4qGDke#Ed7MghR+
zpKW~{@OyxS5#zvcD}o@*y8U69e(h~)FD&0f1^DB}6)u7>4ANqh-EsM%oPPR0rE%w5
z!)?i^(Q}XQyj$*(O&|NTlwc2k0@5Qr`geH+tsoxW#d6?_plrcnX}Ek@E}yFmm4H!u
zx?#oR!2t^Ug&VJzdp`9AnT0K}Jn+T|{3YmMMIB+N5dpj_I|F!C3w}>&u(2swvQoP6
zeQAW3zaDHU9&Vu1pHiG)I(_y6XNCe5^ihM45Zv|*DG$zl;2^9;{l<IYMtG<jxFX*h
zYm<_UWy<dE9_ggJ;PJC3VgtDpP>X@;4k!Twu_Xeh#s@WF6aX-F5m-dSKl=P1w~(^>
z1}VDdqcHl*@C$rAe!c-7L>~Qnf)olX+^tqV|1-I~`2~9C7`HyzH_j-XE$biqoUDX#
zQYM6Qq_uzc@rp<Pnok}dSR3j?g_+o!K5O9;>45L=+EegFjt^KELJmxH4p8{7z3m>k
z{bRqQX1m;v1UjbPe&;9POnvM4;C=2-=>A$DsOfuS25f9nv2CvI<WcEv8=mX>xcEdV
zUVSwbfcd7Cz9y-A^=|_D5CN%6vP>Ur6VAf{*@+*1MOrc2mpyl}Iw{pxIq7Uf^ePn<
z&ml;LOX9Y=8tFb)VV4~1ICllmLC_0O0LE?$*Zb(@giru5`p-Zg{|ay`V3610eQ;xt
zq6ww*r0|i?sBI{0gaJlOoL42>fT6-{<5gVadU5zh_3O{c`In!9Q;Xqi=z}zM*x5Y6
zs|*_dH6Q<+%v!MqCyu2m&ENFF5!exCHQYW9eeK`n2`cyE;1$wo8JSYfB?lZPRD&G?
zJftKHAqOTZ2NE&Dz2Tux$W0%9RI=?Oe0?3_uOLEDXq{)1Anppt0N$>JipO+#6D(PN
zm9)2aNW<CFDCm~7N&Cg=BrJQ*A}L(3OwCrfrR@8ml#6E#!Ms44`OVdpavZ|H9oGA8
zI7YZPDOECO%@bPos}L;XU?cyvXz9o-5$@Mp=_#;bTs;Nyz@QuqSh*B1?&lasW}Jte
z5DEa8c@LWW=Kvo1GcI8otWNVk@_Uj2haD7DeD_>H#ErZ7=n4SltE3K&eyV=<4e9F`
z|D7W#xdpQP-jB)JdmoY9;!=#p9lM5sM){7CL!r&SYkt^#aN`yqfE%nF8JUdZlgs8U
zghQfSIelm!oYRcIf;28KU3k+8&4F}y^SkSJz984!`5~p)s<m|eyHFiN+zo-aPq4Z~
z!H8WbvM}aSLmFn*X2AA<=aXEns>ICW;LgRk1dyCpASEl{+zkFeybv%3^fLU)KqNe7
zIcs;nD;GAu=*)N`-3lcjAs^1iO3FD6XqAc-_4n6Dfe%qaCLEZ-Nl+V{1od^a`m)C`
z!A{Hp9E03C03~1yZ$125#k>N5(f@38>)!ypj!U5M&$|0D$-Vj(c>2@EaA*l%M+Nxf
z#uYAtKs2=2n_GWmpPc#0*QB?3e68Nq;T|hC$Oer17hH3rB*UsUn&Y2{c(>n<koOCB
ztr)m8Nc-ZNN92nS@03f#N2g@=92|jKE@zG&RxV6I8itSq6M_Souui}Kv;Rd_ZNl#g
z3N7F2fkTvhh1Pi%NmRc8?oBK~jUO0iBJ$yhbNZZx(gZu3RvZmJ;A{Y93VPs_tYq~@
zNrnsFNI@wnR+|h>v}FK#nXKOYvb3B$Xh_wO!%a9aEVX<AmMgHGnjZs%ehN^8`?!^u
z2o#7!oITQwQ<FMQ>>tl%RW1e00Xz={VBEGR7`6;_jcEk{!k?<=mjL$y#;vU>tFM=W
zyB<*<^2kiSi#|ZYmqv>3u`3WQ`X-#ZRl&Xf)u&k1xP_#g>9Xjqhh^P^pOAv`dGOMQ
zeg0^)+Yh__h%-m!skqZ$XNI6Zo_$xeEMwxhy8KYMXysTE<#D0sz=9d2>Kp+&tZ9am
zqR=j2++LaR#zW-53^>kt=nH=$OV+Me-ZWJ)=e2fzMLKTdgK?jLAMn0TWv;-CQa9_P
z!cPyMB}-SyG&mumfnYbb3`Psxt<92NI!D<7_yn_k4_!Fo{gG$)qYZ}+oq6s_>1py0
zd^ii*T6a#;vE-1H1w(rN_y-8?y-34;*|a#{A{n!o?X~BmyXK6YGuH7!+%O)q0Ix#{
z=o#yq5A}ZICR7J&AcQ}k>kWXv1<(dyT*Cj)-g|)8bzJA73%xgzAV?4(z}|~QQO)Yb
z>b*LaY|D=0BsX#1eR*GU^WOb#^5wSN@7|l_+KJ;hwq;3Hm#i*XT@)pX6e)_mgD50e
z01^PvanRoX&+OUl>;s&0aBxW5XMlb7%$l}l_UygZ%&b`}qjIj4!@^%KG*5X5B(NcZ
zHi0u?b$1ay7kr?t6)Juom)<>_0iC$x3!MgG9d(BvD)pi&v~=DwS@U~;Ad4=)PV&Ls
z>o#bdy+qoyQ4?zwXT5Mv+r4e|ZX4))PFiny;c&)#%Oev|R$d|1^A|}A6ce3kh2^p+
z_c5dDj8vjj4<xV$=AU<=-1CQjCbf`b;SpgEb>e^@(?v+&2E%U?KsVf1u1*u4fZwoe
zX!opunc-px{C1r_CDi^IxEg@>tQV)0rY~LXTLo~fE(F%=10pyK<zh!M`)}K_E^uZ(
z1kI=YP!C?bV7W3g?CrSl^2UNtNl+%N7xqH2+UVI^W##9Rg6p4w0caQt-?JHa&N2Yt
zoG9&2sedY12p`Ew=(V(*d?~x@5h-4Fz7m8X5@8nrUYJGneDD!yx;ygL^U|>a`(JSo
zFcSHUyh16cStQfWyHqMJyi#W2DB>*GAgH|PN~u_ViA-6vO7dsU2G^Yq+uno9u7JBP
zs`i|F&Fyl*gWr~!IEqAF|Av8yWc6>XS-xf#9D>bHQx9~?hcK(Kg$PZbS^Y6qd5ZY+
zxw`ufer`V$LtEP1r7NVPtxei6TNr^HMardm;9The9+h2j*)?+Kcm7yrVyRu5@eRig
z!x_#R;3irFbqIc&z?*n=cPH{hsDOK>tv*O5Nl<xspVA>YUy9YWip48r2;Yk{&5bgO
zZ-(CuL0(`4-=1mnAgzx!`klfx05$hE02%hy-Cs(>OTUm|7#@q{22WwujslBuG9WFW
zE}bu+GJk<+UnYc!F}soe{o4gXME(@X3iFKPY>=|o!33OrVXuHzpOXv#X8%0r|6N><
z;Brf#1T<liKp6A|SKKO7uDV6ip|Os`F7N`-3wH>jfy3UaoP;{gmbadv?bVnNPRq=e
z{Ob8K3xs?Atq;n)>+ewea^(=}DVse<N};d61S&DhppmeA?jo7F>^!Ny;44xA$=_@U
z@r(dFG6Tgm3uW~K-;pKP+$@FIC*w>Y(rn!eXZ!evJAS+?1P*){?K*MzpnUk`Pvy|o
zO%Numgo@KL)WNL<S05o@`o#;k>hYvC`G6~sD!@xUf7wbI!cn5;L;ICo^O!m_l{nP{
zlh6ZMI5Bg{&3DPI4}V9dLaU`(F6SUuBi*^Fsuf)MBK)`#z&nCfy_1a%(#|DvERS<l
z!9(l=3Jqo;kPzkBaaJ|CMa41$lKy$+l@JhYlELmX9=w#vaBN$S;yYA2s|M%xxxJ0d
zR(_M%E|&mT9PLb;hNiwlFFhs$<86CFD6k)=1TtV2xd3%>(qo(|-&L-GN4z6%Hsmk{
zailm@2g`wH&(T=jDKG(_g9-3-)7eAGsoCja2X@wd=&WTx;_q<L=JHu_S@Ty(`Q6`=
zEWC97rGFyCvFIUS2>WNmYP{kF?tqr6<`;h^BVFyx8nw%rStHdq+$#(3_`1wowN?sY
z1uGNBT{6JEE1^6WF*RXI@Ml5js1SR7Gr%NNuen5OU~O#PSFVxi^A<^Fc8-sTvn_sR
zz-k{bRg41f%I~|YoUk!Y>vA8zC-43IhjQ}3E@?m7AV&}E#aWn2W&O|AC4fR$7t0D_
zG644WsY-9<p&#wd#qwnh6b5CW9nFUirA`R2(^BrN^*}zp4_Dpwpj>~?*OVR$j_qii
zdJEi%;kT)S1*Z^R{jTlu#!vo1cCLF{DIVh~olG?$u@VL3bJy>liM!$So45?D1Wv(m
z!Rd=uNN-QC^guHy3BPf)6xvaLK<Vcw!m0tc5cpOGIlB#r3_;Jyu`Qp<{-^#$2AU5C
zB@cs*Vz%A~*@PUdWai>@fchYWrSbuSQNb!gmSmxfz9S7X(gvZ&v*So(7vOpu3;_08
z&MkM&F#s;XzZ=n25gzU2c48Wq+Na$22a;dAP!SzJp(j%6!jJ7YFhK0|So-Q~IVMd|
z^BZceiyCR3I+(KN3R&{C@5#(Hmr5>=w}7yR6HUW(@IBFl)!@anB)nt>^1$V1L+FRI
zXb-+jqwsd&3>ecWxbj<hEVzoZ;QTP0!mQ!b7oL!<uRSXRF5#X&*c)%yy&Z-`3Z=ZV
zS}4`;$B|{J%PP<AH^LQ+@eXbPD|j|$A=PsiNPcmN9IZQ~wj3Cja;Y9jW)D!~-pvnv
zM=rbJRw=+crU$defa6+)^^fJZuv3wiKk$|&)aSqb;}7J$C;k--bv-QKL1`G?r#1+;
zO{tu%WOvldVCUC`+635Lhvips5#T&7m<P4GGa(?D3DvrtCyoi1|Bd7Jz?p`F(n7ua
zX_#cdh5=7R@f)KZ3m#Qlb0qw2b^GPeo6k$r>rY|X-@B?{%8Ya$LHa((`V`JzDp`Ri
z5ZsN3REmaY@VkfaXYVe^U7fwH0CkK46I%)do>P05=NtooPP!D2?!VwF82iyqQY;2_
z;q~`PDU{-<BYzlc9BzSESe%<!;usBH+M{ngBi-9K;N7ra%`p*AhXS0+>+Y6?cYa-p
zAb7|ZENp)sC4@5rx^9PXTQ~zpm7i^J;p@$B;T=|PBsjQxnBqM6#YXuEAE?GJHUygV
z9fbC=#$DTF6m6)$3?m!Ni0Vfd9vUZizd3lTw8-Jc+xWAw0#G$~o|M8!(eb7R=}8$9
z8gpEwA`{yK#n6&@_jkW97hkIl`sh&`YaP~$V6t(*<2%8z{Mnl?$@*u10U^9r6RX~_
zwxf;Gw12lcvRg8JhGanM-OC8r$(<Di_0~CX`hvek*gMAxV>ylrPQgBWS9_cEpKf(l
z1F$ME0DM|^Z<P}}x5^nT*LR<8k)Bg6(skmfvLJeN%O}$C!5h-_>*uALOYg3g1TO|-
zhbSu$>gkbU=v_(2yB@d02O|?Fo(8EZn8y#J{0_%mUvNe~**Um2fB|R>PI7jj=M)2g
z**`g@|BmZ?T<o-@yDXUaop#Ibf%BwY2mNjlk-!T;FWezkqd4<=V%?k4_Tej0@B335
zR@E(Em$^6GrKD~hBJGsR`of7kmhcUZE}Wcn4uK6%7kT;LKKt(~6JG;q$LwJ98!yUd
zPyd^A^E~kwj`9c1`*ukWUgjA!b6^G-964S}yWdpV4t@%5*XOjGRT$#0)8NI%R>%w(
z5-OinCH4FFN*}f&QZCg4lidTAFkE%-_r5QyFS$(F$x!uiP#S0X)y?_Q9}ANv=nksf
z0fPJC^S_i$uRIg11(U0a9k3s=eT($<_bJ6)RQt;}DAEj{RRt4#!rh2lNP%IeoX`wN
z|8q68<0zKUT^c#L@;BJoE?rRK)4F}5oc!VwIRV1o^2K`TgyelctcZ@rDC-o~9jGJJ
z(ky8OB~n;3-<AgmmwyP$=>f2HX^@-9o>47*U|5D*n?3PK3~)kQj0rB)1fMgS&CV$X
z0G)FuI_clz%1z>fv8zfin=Vse<u9+AQoKH*WTjFA3VshULRb@4O|Yof|ID6kavV~x
zBR-)TyRraJ#npGnyqoV=%jOR8=XXPw8&13pGhpFr;T4|FVi1758-F*>3U0+Kxbj=&
zT5zi6<uc^Q5cE5^{_Vh7e?YU;41&7-+fSWRy3ncfU-fT59RRudR<~Qh0^qDm=?a)J
zQ)(72mZOdJ(uogf%B6Z>vU;F)$qKpu55F%<R<F^sZ>u7XQT=vVfbniRgU$m#CFM_G
zCF||S|4sI+e{bAVE@Z4v9^5O(8xFzvPnmE<LLED_>J20KR(+9}gz)rG9)#udsW1gz
zR5eFBG0P8emCZe)H?wKp4cx%SYkxHHU;=s}fS6l7PpMy5ABITz?EVZ&fbSm!HK`@A
zcjxA_X*IA0*zEwF+Xp5f2+^d&&KU*(v;T6m{(s||k88}wIVrt_J@$g@?vc_9ukdR7
z113Z!><WZyg4G8hnj_ErSO!ltMvZFmii>68J&#Bpi6iT?%O8t)TX<Q_ibJ>!+{>7#
za#6O2xiE}Q1USp2>%m#!ZSTG&pFa5$X+ILZJcG`SUwjx&9jTXN4fQe=f<)Adu9Od<
zwchrcw(GuR{_uD!591J-ff>sb=n9y#Xo<9(IIfm1DSe!BsUApF50JPnT)kHA`|iJ!
zxr>*ntvQZMH8@Qr3Sb3XevVOZLX$z?N1(Z`e$Nhh<7fXQhqrEYmfXF`!b5ncxB}ON
zyaNLRGG%6!C7|a`s)@S`Aw-7}d}cusKRg4glEo0_Er)<0HSBd`sefdmvwJUkV}?dU
z{nB>|@&M2ekX3-AeY!I>vSa4-M`FbgG8@CgqY^r>-5;5(a26_>h3gG40lnt}6L3y2
z03iMxo!`OrO<dU2^1N0EPO_uq{KC~Tl~(==p%@3%*%v&ve@wV0O5FEve&cEB*|AX(
zy=XAcEG?J0_kLT-V0p{E@(?ydx9ay2aN=h%35<8)tJ7J;(t>-L1jGTZ>+$DB1U@h$
z;KENF+9w;He_VFI{jv-}pTR_27hdLueY>RyON{0CU~vZT#@X>}+<=Ade+z%r8r$#S
z%xwkg3aFktU)rGDq_sI^Qg|ZIDV5jh0TTZe7hf*-e&>&5_Phn2nYNQk`}Eu9hq}TX
z(8j?}1vxu5d@OH1`Xf0BmALUZ%GxmR39NuoE}#(afo*QsRiB@@vn~yDC9)83r%l6$
zBp1SX<qMWdE==#XVbx(cM(cv{w9DifI&)fJL0F3BgYk-}AHbvzxLeJm)xa#s4D~fP
z;Zy)-;E7zV2&gs!XeQuCacu<yaMn%0o)ZiJxS@sUkbl5M<v-!05x~iGX$7TH#-)F#
z#3do2<F7-EtgwLx#vuom!A@=ZNKU``R7`fM%P+rKsxQCZS$RNFHc<v91`ivCc!eME
z2;Wb4<yGnQCn=n1U^=I4PaRhIA-v?fK6*zsz4*8s-}ObpUYP!_GjgoH4i^7%WqM_m
zWV!S#uwlelwa>!C;HF_#oa-6Di#`GqgsTJ}zd6_rI0LO>Cyq3zrB%kKT&f4+?SZw|
z-YEAx@;#YRJ=>9b=b(gBzuK#dkK}h!>pTeeL0W$E2k*#-&pjb+&5b&LoWEq$yPzwe
zap#vfs}I{HAk<m7dz^)vBJOTHk;qN(O&&ii1Mg`G&gYjyHeg_INP4guKzV>kcOcXQ
zN9&*;V7e4wI|567F;{7tn~rUbG)(gPAjl|KT{sJlG#8DKcfkOh^<#l&odLk?pE&##
zt{ZTj6@2oqx>HJ^QO|Gahi@tePT&;~*L`@u9DniWGThmQT+ul-`@icOQh*m$5iw-r
zx5cSb6X`(WuhKdMaa<yAmF<)joR=~Try*_3S^v&Ao|9fk`X<_u38>$_jhpyV3C(Fd
z+UK-ex7qFkt3TK)P8wf7F#?W#ScoH8^Oi1?P-sw^pfD(<Iyli!?{}j-&it>q^=`TQ
zo4+sRkTc=fGS2ZCi2JVJD>p>F&<23aeGrQM<n@>2y<h&D^gyUDAr6Exgrj@S*b+E{
zRj^VhCCbB5S@qJW3cOg`1l|Sq2-#V1H^ZQg3qq>CeBm<5z;VGdm`x{THGoQj@Eyv7
z>EIl!9=dxts2#2*dAk<Rkf#EMpkpCazZa9XvoZ-U15zWH_<jf`z)`s1#WX3QvqEr9
z%dDmU3laWnTvH4@nfJ_jD`d(Y4@(yIhd8J>aO?{n+dmF`5CpCH#a~GOp&c=yU%dQ6
zsk;2DN<oiZmtAk<{eKQzF8vK+7D3@Wew&mTUwBkG48v#q>JH2tCIN9Ojnzi@nTBQ6
zf4NCMed;ID{N+ZaMKGoY#gLeaPMY@aQiPhv1gYeQA6fNh;X|B=r@mY5v0$vqiMQeu
z09rtCPI=CPMS^WhX~Y)B2($;LT&f46?Exy=`RaXNms=iqNXj6uVjRb!?Ogsya67Hf
zGtk#3jr;e&(&cVtb<Y<)p&$hWPvgvf^TB<R4GW(|)5;;Ri0x+&l1>$xfVvukD4VFN
zWIo;hNXp}aQ?O!M3hkp^r&?uzOpFl(bc#->kBZa=`}!dd0OkY7rQ>xx6_8mrP5K(^
zuoZAJ-eM+_k8`kjxIP3EaO`Z#0-RL_0F9@v<iEvr87}V#1Ypt~6z-JV`7O!E-V$|p
z69LbKfG2F?eQ+N6YlT#N#|OWP31uGptGw<mnF2lAn($fmS>=0{=uO>tHTz(oqhZ4b
zvj6qx<j}h>%aPC5OB)6=iFd)2saR4svuTGYI<tP$CN7y9zrJ_3waS-o{z|qy|EP2w
zKa#K||FJrS8pn>+9gt4g5STf;7PI#fFftCI=L5jMzVHEa{9ZWgP;svGxp{eNJAfa*
zIxre3CSa^5k%}`tKsy#UKllx~@ty~y7(%%mSR7k^r$?h7>I=K`szP*0T%Mo3aIwsQ
zlzm%k3#9B5Pl);<wcoV!3+V^ZEWv7kIxdKJ%S+rfzVX0FNDHv1J{@YuN1!UW6GFZd
zKK|$HK7Vi!76sD^OQnGFQt1>Ii^JhNl7R`rD4sz-Wwp-EDgbF8q#A{G0+O(g65LN`
zn*q2SX#FQ#?2P0(2>#`+y;e%Ex>@a+v2wneo(lm_*u?wbo%?sn$ya_MqkY{hCTf?F
zS0uA<x>xeRjgmQ6b>YV*)_@o|VdTrZaF%uZQ~xSQKYUGkk2T03wC{yFPDy9uK{>Hw
zvkXF7W(sTs(Ehh!Dm;YVl<y;^ZATk$uK#Cp;QiNS80I;X>Bt1MV#}fRShLa<z+-~8
zYy<GcKYPON3*u(_Ma8+=!o)f~)1*lbUh>-c3!yo!SemFc5ND@TF4Y5(dY}+T>TZAN
z5xMS;dz9@7P2@SE9On%=aQd7$$LCF9g%C}Z-sO;inY&^&Y<8qe3*JGliY3fZh!+z3
zt%vr?iTXoIqi8Ws%b4SW5tsXY2-wVl)g%=*&BHsEg_XN0P%~bL<@uhr(=q@eJ!uXy
z2mLr@l{b5V<UrlI`Vd4@nZXxnl@}8}ZUuy(>}Uw`1!ut#jVfH9f&pka3-zli&l&@O
z<$n_W|AuQdF4yBxcuo3G`m|Y6cK0KaU9R``3<A8X3qQ8sz|7qh7iv2t%`f~+2AdAV
zjB`$9tyEoo3tk`)YpZMzu?Ccc&M*YD-M#x)kISje>jEuzDV^Pr&`pEYzv-~{$K!F#
zZ_0L;WtaoT4TlC~%gfJ59TXRxCCONI^yxI1o1+j8oQ7k9Q>Rye!*@QvZhYNsVgudn
zGkyXY!*F&^wp7oVCnZ=N*}ro;>@l4)dN^VpGpP)d*8|06Qz7j42Xghzx7piKc5P}r
zSs@N8<E-(gf*!a@fV&&+Pl)_vPHPq~Rmb>F9z7xh*vC((+zJ?h9;`4N-LoCi^rLDu
zK<o48lp@^4%ov~uS{E#Y=F+JPS4aqxke*|WlO`a@iB><pyTwb-gN4-CwgTLbf))oe
zU@)z3-wqk=Ju6DYD5aT$mGHN~1SF923xB4OAZLvMK%=h#Qh$LfwkH^=C9%M<^j~<x
z15&tht<n-@2n7d+x#%(eu)7t<rT><X-jJ?OKse)Y`L&B=2F&`>%%&mo_#RmGYU1T)
z2wE^u>t22WTzzB$Mkb)YyIZPOUnn`$5N4I9%6FFyzo~N&v*K-UyZ~XpN#xw4>>nx|
zX@DW2sjwzUCLj~bjO-E94xsJx>waSK;c1v!!)c44s&<Z4Ky%=M-8+@8brqTVN%a7F
zpcIO9e(#U|OfJ3pIxvi0>3Kbh!n-LF+)3$-O&b;=Q&v`vRLriG>P5?>8}D!Xaj!uh
zJO2bcJi>co|1Q|?I4T8Lbu1{IqU45Hq-F%X$a$HA@wX1hq-TSfnFb?dIncb<jjfGA
z9O0V`H$)Z5F!x&kwZ+_uu${LF>RW2Z`8~il16z*6NTqZGoSm%z>IL`=^swP<$O5=}
z&fhze7sl+LY7zei*9DVTON5en=6}H|DZTjt$xtdZ6?w6UF8$U8kMXl4<0p|J;p9xY
z8)`2TH2j(X03ZNKL_t(fKKHNK_liuAnKY6sgzQ1Zc^9jtKzI4{`}hATVAH($6KUJE
zW!zahjd<{=4()yOr8I<|xa)en`~PGB4sQ5xQl$MOwS6pjFZM1E?b;zF5MCm|rmg_@
zmH_jrcA!DJJqTNEQ*p}g#4!=mv78Dlx$>&pw?`erV)~T(-R=RJ@cjVEKsLYT_y1hh
zK(#MVqqrT%jds=`LO{Ws2tD{rDmUDMMZCGw!cRG*Vo12pUA|fw=4rvU7>xiW(s8@3
z^LUdqL6vYi7@bnfx*%KSCHT75XkaRht1X<+6jjca(s@gy55kUps4w9wi}?NyKnYSV
zwgRY|AZ~|M(hL|u>TfzMBkeftgmRPY$Zc{Gd{$%ulFk5FlK)qr!T$kQ^7sD1X&2w|
zP05?H$RZjJq2L&{FTRlOu<={)5Cri~y!MoY;#m4eQOXqnhw@bysXaNnE_gJ-23}TO
zj2p$WTJsm5N@tX|t*fxIPzEb}HsM4WraTXGfx?Hd=YQan52O!5fai)E=<SiZ-8+<K
zvsthqkeQW<=i%)WGB<SmHElC~LXBUi(rGd?aqJN1xhtz{q`9e4&R{7q<$ia2U?#@a
zH~-}Smem(t0*jT|x+AOsqi$yKAjakObXX*~Cqr1GFo0DzX3@}(F>BsJshqzE`YhU|
z<2d!kB-U{?;P~F{I4;<#H2vik7ULaKQ=2eGAc!RTiN4>a0L#jSJjJvnE1`mSs`Nld
z0S){l(s3(bu(wYNpd~QYtpGP3>DYo5*gP26u?hR3NneTQK$wYZ6IKE0lf4R%bOr#8
zB#ZrbxX#Mnf6m2Um69uNf<5_c>;1F{1rXwsurGLQzYjhNL7h{dz9XGn`p1%cye_wL
zj!ef=J@?O4UHGwQ>wp-dW?st<?C*E%$1%fkxYTqoIrFc%1;>A|kB&mZ$~G_{&Mk%z
zWDEAMe^2@obsjn14)NvV%ETd96XcPjN(eT3bp_!0xZ1%+s&=9b17~rj4^1C16)h}Q
zRL+uFwR5EY&;jYj35101x%%3X3Z9!iP`hZUd<(>X+3NEplUDVV)9;HPV~!s^!kicl
zbHc&Cfbz!4NaD&Py`|9VR|DGvX?UMok3c{$!LlpdE^Kc+B+WP>Lt<SBiGHIC#V-e7
zGXXB#ZJ5<?f0!>Hl@gWWxL^@XtM_!Ckx=XLalc=|{TK`#JlQ1aCDSCI27}yN0YS-K
zxSMDN!cPX;KL7#7;iHF4R5I_RiChJsp`cJQD^4l{V9oxoLIcmr>^}_yg~$GKAgtmL
z20beH>$wo{giSnvJq-t><yVgi&!tYpWlftQ6>Gkt&gil(_kKS=8^qDg5b%XPvGucY
zkJ=PNwqP+B03`!p;q56K1*`fP2Tvae;2xOp9K_bax#mWo)1T+1`v*c&1wlToD}Z?G
zHn1IRgSr!W<+tK2xCOS-F(p5+=`wBlbg6}|fTN8K($;c9!BaoK8$GaS<$3b(AO5K<
zTCqxP4VhN!(P2V*T&cljK&~<6g*!Pp9;0?+q~#dTD=d<#1&g8CZzfI&9FcyU`bo4K
zfMvgCX!`8y?Umx`GnMWDtL2`m!U#NK{V+T1ZWjo1K7{S2E?FfbkiY6Xd0a-Y0+A>;
zaI8u47p;<PNcDT3$ru&5(POeS9Aiu`E|orRu?{2-w=qy~M-iRbxIRtxDnL>h0BiRD
zU(wLy&;G$t=UsJ&6k%yR4St7cXkx*q!Ka`u{Mdd2v+mUOfAWoIW#GUzKqltWbMj^S
z1(!<}Emff?KTaN^jQ|OH=gDI@{?{0hi_X9afTef-p3H<G4v8Gw5mq*UHe&&QdvlZQ
zdh>;dWyaD<rDOvyc|HV;vT@dS1cEhGQ#ujHqfyN`#?*P{jMU6uXqyyfnQWiaZ`x0&
zA5MURS#b=cW0`U)<P2)(FOcIng4lZe*hJ7w<^2ul0Um){dfo-{@E?6&<}X>Q-VuW~
z$A|5#@nVN9k0*^g663rR%k?4X;>f`fT-&)bxcznlmnTAeCblLjYHFnnwlkXR4o(Ua
zz~h3aVNal?sUF9Yr^24VRJAf`6Lf{9M$iijX9AcsJPkDPVX3`r?qbP<I^P~B4;tc%
z<2b9CuHK309R)Kn*dLN27%WQn$#4W^3hZV8Gq4RZ1i|h>ZnGu;ub{fefN}qc@&Ion
z^F%<>7yxVbe?1!bS5`xDOP))gIY&zG_=aRceI*BgLo{47Nedk(&JYcK=W>7h)(z6}
z?(^6<pZH$UC_WlfS6?joc-j0od5N~hmmh*sm@4kUjJ*#_X<QL-I}-new>}_?uDlU?
z0H_QoTmaCs|If@A=#9`Ha0FJ!;vMu#AqY79g%@2Rm)!AyTy)Fbvi8Q?<@{@IlvP)L
zRTi9okrFnd`qTdIPE_OnJh)pC?B`0rF){(2omdH&FZp1GjC=z-PxT+Nx>p9gaF*+3
z3={-?R61pfELgHkT27vj6Gxi}PPyO09w6~wiM{@ZzV|0GcOhkfIBK+0K0D}43Ow;D
zU?;Leqab%DAzA;@V?UKIKmAyy;Pgt#RJ_yHp1K~LrX(w5RT%sxAktfnGVW7~GyJrl
zQNLsBgqdmw8<!97WiP%f%{#UTjOHoX08UQO5LY7Y_2aF=zGR*>h@+f98f0(^u*y&h
zZGMBJ>C)eFEN&rcH&R1wCnd9@TJj)#2(Hc@rTjkB!r~PG<Adsr`w#4r(Fv~Z23Ig9
zlqgo>`Wy^E(i9UUjRC;yzYvZ4&$w3Mit2eFU1A(&qy^XCD+No>S1%IBGZE02mjO^P
z{@C#*9ae@;oxsvRbp4;gK2{<eBy#g1#ahDsD<Ea?@)K#IqgDfufWkV{aK=9uOM+A$
zl8&}zmrTWJf=gxjoe#;pORiReb8MAo1p$R<roz=;z=mN)bSKRGwn24hJdQTQS6zR*
zT>JI!DuQ2y89G0Jg;1@`i)Mc-s%Fc)<*Q`z+Dnv?lJ=I9(ns6kF*-61&4&+4D@^{*
zs+}uEC_h|lpw&LKjr~T)yY5>JG5xGU_#q=vTv{sg7A}?!C<bYU$>Nmz?dyRHF1t#;
ziJ5;DX45ut#`D*s!f9_{*bQ{$8NoZ;boh`w`;#Baj!!<6lh~`@w|%Qp?LD<(hL&3i
ztHG&D`P^l@qHF?c#gl<4#LC(csJ1?XmB7hz!&t>=fq-B;w#D*sTreN|<6JfMJ3rC)
z3j*5syE5uL5Ojn=p0fE%VV!TL^g!$AaQ7KksyMuukPYAnap98lB(neljd2vgJn1-E
zID*`vU7yEM!i2MM1)vzT@)a-v-r3!Riw-Uz{HX?~n-J8R{eK08{3R~e`q+eujXHBC
zj{TMJ*dO#_tAT+Z-u2}ohz90~*XgL@vi1E}q<6<>6B7LMAkA~9AmHUtrOBf+But7(
z12Z>~(uCXK3(XN&TBjcFs`D?F>a|zMyeqycH5XheWmPr$NFg!@5`VT2ai;A|(+&ya
ztuH+ZY1-J28|C5n%yr-XQ@QA-J7fxsrSPo1W@K203kTH6BY63+=RF(ynN^T(?r3Y1
zwm7AmTQEyM3L;%S7tB)`v<6yR9qcpql4>7*)LnxtKjKsxC(a3{Nl|ezW`>KUtE&rg
z0Z?li$4UjOOSyBa2Xe6VeEIb^$?ts!7X4;bMPBv?+Gaec7Fc7*-x_NOL3!1P9NN2E
zUVY-{vUfAS3zqBa?vnjqZU!^i4y9I=QV4@Q?$rj9E|$9?rnH>dg%!XC9OIi*hq2!c
zYkx<#Zx&k6E8^+{RE#?>6=(F}&JXj4nM1+Qi8Sq7IBT{P<2dv{f4>Zz#Aye96XSFv
zFv2#9RZ!Xr2x3?w7i*p<QeXhs#{%1uE*C^ZxC*ct3_wz(5tG6ISbP6}jfP!>E2%CG
z`|O3cd|h(Yu|J165DA9Z<6##7ZWxDbcimn&{Th_;^h}Ub^|hWxgvzioK_MB3Xlp`6
z95h3q#-)Q31}TXiw*<2D^VP8-suktOi<f@|!6}#Vy3H(?XMzuW`k^##T8BW;tLj76
z739p|hClefWZA`+OAeL^O}TdcNUQMS-S`1Whbhl8NE=fEn=^T8|BJ_Qc5-;%UaT%u
z%T%g2B@<w^jrFloRWH33K!q*1mBfl;TJ|ZJ04Oq92up&!J-uKua5gw)M2KDW8||*X
z`F6SY8{d}cGpY5HBR|-wVPZ$=_rwmu<HV=QFvi8c9oyvjpZ-V=ZvVoaO!>Jo&<q<F
zhoE#SA1hTH^E5EzDkLnA0yvdKh)<JFSo%A#d4qa?gA*kPif_U&_SajXJm^g8Nmwkc
zkUS{P!HZ&75cJjX!~9`pHZWQj%*7UH=|UXkn=&051dqr_Z~Vf@AutiSU?_5+*lGOE
zwwvL3Ea~{3jo^D4I=D+DP8}~!$uaxDWnnj?qJk#^Cce)+PW8!R0G0rczr{rbK*@7h
zw#r<*MvAY!1J<J)b-S7%=#M_%x3CKUH*5$*x&?xNp*jqR1iMizU5&t~1<%XUXpOE{
zGXQ+eRM>@&g1HEtm$(~-LFc#IVCVOi+X-ph&!7KA%;*1kEbj^|`LFoO)i6Ayk5jTw
z{kRdPa8P&sK~*sP6ciQ7jM=r)uz#O)L#IMKt_Rx)jRz0NG$=Efh7|~|GC1|=5}h!8
zz(?Vt@nT{XuYRpKB*+6(HGlCE>BSl2`hzKR!n!AaGk<Tq>wdZaTi=ms<<r#z)}uhT
zMUO}h3Ox?oEp(?NT!k&*AOyv>ZTwVTee&nhuy5>dLU%`-?Afvr7B53Wg+r8Gu~!37
zo`2cg!2yw0eGW_$&MvGh?E3iK$!7qpiYXx2*;FU3hYv^=me-50htH$S#u;KB7Ixw9
zPs6ls7>^4UR>2q;garE_=M(R7!O>8^4D}C4;o{ZU9wjXu-?`A#iSZ5KD!@Q<ql~mP
z15r1o<Cm9!6cs4reJ}v1d~)5SGXPlr&q5Ra0@pRT!uonrn}_qWMR$E$av*i;o*fz@
zKy-*u*ad)rfz_8Y+c(LXcOdxZ6S_+X?igIObIoP2d>FUTc)FI)iJyg!!w_h^HNkao
z)#<D@x%1fVampRWOTFv8H>Cd4cVlkGyo;}tOK!gp()fBy#mj`a`qb2`?x@?<7N(+%
zKsJ_V4`8{JLVmG2F41@41G^V{uKc*tW_u=?C{r&BwEY?{C#?HbCqW$2X+Ibl1jqy|
z0245T=ii7u-r+d#(<P>U&qfcBF}>}9ugiT8e+%10Q|xhIa52xDVe8SGC~w#rKPHk=
z{u|f5FE9M;M{*o1MA0~o?Is*$ZEmcWQZOQAxH$72%Z){HI-u8o=el>2#sC;RY4Z2v
zo^3cT*e8Wp4amlpo_TTn`1->vL&Lni?M_GQe!0+uSORJOk*qxF1p$sn%PQ3bXHJJe
zAQ%dRpJ{{l;f6nZlP-<S1Fiwe0t_YfXg*QkHhDKz0X_f|5dWTtY0Mb+NoN4ih`Ff$
zzu>}Km|T|)Ykx(T->5i24m<m@UTTXZIB=%1<8=B^TdSOU?MWFr1)-Zs;snXH_Cok<
z>f)8^3@-8V-~pTz@ic8fWO!RhxQMeA=gy<xEJK&eb~NwZDVv}BxeWF7#Pm=ot8m5F
zz9TbX#+1y8m#DM<ocf8Q6YqtyeO$IL#M#?JFwnzQfOz-Z2cXD^ORc#e+Lg0woK*?y
zdFoyvZuDu#JHvFu%<)@k5SIt$Wd5Qhz%xS{zyu6JU^3;-{T|?+`>pqWP40T|At^4w
zlC^p0QJ}7p+UfO}HQD-cPX6P!-;|er@e?@%fwNc~$9CI^W6CTw)%{L~ifa!OVAmO5
zsv?pm9s{)#3Tt+*e;-Wqq^}T%Au|GHMD5%Tg|K4|gaZq()Nc0MJ$NFgo4A{T#)YAM
znUFasp1VkLDr=yg9LEJg&|`AwmqEx$6hI)5a$k|0>C(V>;E_>ODg%&H8adt&m}C-x
zL=8#})RDlpNvuaEl>xx)pWpv);kp+W{Yi6aQ0-WF+e2y)ktoseS6%qge&+=bk3(W`
z?ropEBRw16nVi`_k+R%C>oFNZ7nRm5faW`Wgf9puHicL#!iu~)98PGxvvQ}sd@b9d
zWBk*{e<WSa^``o$@6%v><C5F&hi&nKFdP)VK#2G7`Ze6(YwlFd+tPeQ8o`iE#E}Wu
zzvD~wF{;K1fgBu{()j59V%ern!WpUJ)vpuhPDek>Arrv8<EF!PN?3{Tlsh+jKokE5
z<+l4C#3>OFfAf5au6pqHO*O#&0$Afg0j(b^Io=q^0CjfB+b=yQuRZyw^g^RuysodS
z6WT4eOXb{!YTL@@JfkR35l=7@XCMQx>*M#Kwe~DAq`-m4kWb>Izz|fF7ve+`&-i<L
zRyW8)@X?{3u&d2}csjld`7^4d7^?w;L(uz=6IijV28?ufNLtYp$**02k5M?8GtbtA
zg2$`kp&c>}Ivvi^DnKa^YQzNkbF2dRyT^m;L;~SGGm+AKd4W77G5!wMEML^*2JyhN
z*Ib3!{|!pg)I4n7)rBAJw}_I3jW<rD|5%fpeied$lVs7#-wD02b3F{QT2c+&_uN|#
zB&HFFKij6-<s-Bf+;CrKz|nHw|0Fbj#j~QZ__Awd!J3Pe>Qvo_re1RoS`}b_<4@s7
zze%fYqIY92f7ga}{_co5%w_sIFcSTcD6W|YBO&-G=|0qb!irVhEZO#JyeyE4H*p#U
zd*?XaFbB$lXeF)=G7F*9N&vg&oO9e?f8det%1w9OBZZJL;j{KTH;m&klCz`m>1~73
znpd8BOg?_|HR%NbpQz*ZTPJ3yOU}O#0=xl-qU_4UYZ?X8)Zf4T!(S(41whT-LD1uI
z6cB8KLA18!CI|@5fB~bjFk%~2a<nkMq?tJOT(V%PWRy*Z0<<O>;fiH6_~JA{2>q15
z7{>y!%4pmeU8|G06QHj%AQT*e(V^ky=(c-IJqft;lRXU=jReIn6*&$flg0p8v;R9$
z|F>~b4j^eR4QDwEZ+lp>XJVNR50TH*JXht%kA^vMcDxk_qw#Y3gIA?*$A;(zTmo7*
zisiL4`@vPGWk?D3ud+aJl(HKeU*PR(54?8U96t!K56+RqBTJ`XOJL*EKa=Jy>*Hz@
zKNd@`xL&Fka#@@k3ReAAef}*7C*JC3A6|sAJ$X3Rc%;5gIv|udQAer$h6DR>l&@Q=
z=gft$A&s1{9$m77lL?2%v0)}1eaxSY{lK|k0*Xt^<iMWYsg;0<KBxre=X3eSAO4A4
zd($nFkMZPo)}wcW!u(-r0N}FyajZ`L>WN1|{9j3!32Bzw13|ZWu=+O@aw~eYg`pG(
z=W0Y3whJf10Py%73HDT2>#KlzUMd$W#B4h~D_6<lD0!S{h%7LqGO|7>^EvkAMoG)X
zi7S+w;S;`#mf(BS;Q?3=Md6F@VG-2*4qzK5M6=~lY=4Y`Sr|o|3UDmYEwmWa({7l1
zETloENEr&EEI{&CT*v_I1OosAFq7jZjRC;ypRDbF#kF{HP>)<{_J!9;(PdwS5e*|%
zZ;vHK2>5{Yg^#=Kw_pTd@b}gqkoGs9meB-Tu!@Ye6Vp|{Un%-1gzC>6=mMt#5QC@D
zey76tA#pc;-pxM0f?07i_R|0x0vjIvq1wNTii390v3*<yUvl|%GNX2$CaPBXB(4e%
z5?U8b`SC-j@q6(F91&yyc&5Lry9>6;o79Kbt~3r0Kd?tFt$_=dE=T!hB|sNuaN%8H
z2aonUeQCugfJzTQCdN}0ED3gWbjacTdnb%1>qxo8^uWz`-!He^eJ`Z!HSsskQ$JW8
zvSFw)lAqX^I9lTS<&S<KpMUgj!jFRvf!Uu0g<dt#i{U?-=plp#8CN%TK>lDClnxC+
zb|@A{N&5v?+#na+^^lx@+x@cisvBhPnoDHPnoFe?t9o-Uyj&`lu9B>xGU<WrQ`GW7
zc;7}~QS|iwosi{eQ=0y=sdELB1miqy0#Jnm+U8GZ@?*v!**Jn&3^^&BtCT(*7aZ*$
zM}7%-QQdIvyrq(jW7cswe4x^?3K7Dw<KgDIxQduSCer6p(9)N{1Wd|)&!jK_mg1kQ
zfc&51ita215+=f>6+$rOrUxV&Dj_+(+!xCy!Es<Nf@RV&5(B3blK*|Xp==}hTpyHS
z48w+YqqOY$Qc0obVhJk?+_nF#yQeL7yEIW{GiW`Gv;OU`KQFsqeM<V<Ah?9K#qE%H
z9uyAEbTa^`$RX;k{xtZgyKh^-#NkP>4N4Oq)$u}GU=AdUPc$}22$ldR;;1Z%%3l^O
z<MB#MM*<2&b?S$AjV<mLJ}S!XxA3#FpzB8D2ylDn^;eV*1Hx18+~|Qp*o#=UYPC}9
zY&~U#n0nrB6vF_Fw1BQ>PbeAhF6{U3+`Ms8m^~W#p@vKfnJVYQEz+AxA;9e)z8$p;
z09WoR7O#@aAO0g*ef_Oc4kcoFSQ(=p5vuWKJ1N|oP2oEn@tX+?gcTsPp`j7!#<_aG
z%5jZs_%Dw%cQry&=fOQn_^trfNNHV=E~qVGFtk4m=BkF<AJlwW2+gT^*xMg~ZIHp%
zW><=EFHHsyL583Z?N37+BRk#szDJ;vr_oX*>J9DN26eC#`z}SUKVl4p0Y3u+Fe%)}
zq%Z*BSn`4NU*TGdE2vKao*b98@=__h{3Z+(>wG$@Ap+*2$M{JA9KQu;JO)}WwhuC3
ztuF+%wMzNVL<nb`O&x|pjCOF<C--cZfu3&lqAGKpd=aqTPCV(<jrd`ipR<BqaPKD%
z?3P`>epz<D^n{$+w;jwtY_o+(DAUML^+Ih#g|&OP8(jU#ezfB)xCJA=j3d<TrxgDj
zY%frqa2H<g({XAF<i6?^H{UKd-07MT+I6amo%#`EK;z^1HCW?EKN+WEM~=v&m=W&U
zI>}ntRE4RZSbCrx`}8e%R~Ii`fs-XTo~E8?a0z_Y#<~3lX6|ITD`r(GOOy=<62Iaz
zYaXn2p10Ov08GWcyO$_Z2H=$Jz%jsR%>&o2y<D#O)*nmtVkq0;^1SukP}QIVJmn)U
z4QKpm45(t!GUzDDk~WwOCUK9}4W5CPPcQ+!*yi9WW>#Ll`c`@BL1F%|DL)dN@r)xw
zlRFja#uqGyb-{cYfW|_eq>AK*I!;LrRsnJ#tQe2ucQzdplMvJ|k0f6ffLzNcXzJTw
z0%AWaJx+rsivhqojr=t(zKKb5l>9H?-an3ya8^mjU-!j;6DA3AhvB#4NoZ+UA`glw
zl!d5c4R{P=4NVj@84jxfgHUnVzJG@_Lu22Gy*tzk*@+`XT`k9@3xo0umcv>O;G8jx
z`W*P^*Rubem!)pqTX+d~K`91ITP6^19{X8v-i1nOkzV$9^&dYT=mWbCZNC?8;t6&9
zIv<t!P<`q=EZt{<>ps!cfc}qd^=lby4&3+6??U_9G}fSS;*Y}3!ikT{)UW+I-knaR
zU?%imD+~oa{*xcc=1<l!dCHxGJ#hT!5zN@TloBVk6~Mt|Imc%p;Sv5c93NRAm{oJ;
z;Q60ahN8H=lqfd~D*#K@TsSTR!1`3J7J{)b0JG1(RIYybdoq>B4z2zOYJnd{1w~mn
z0W%FVZA_r$^dT@n_!dR$xFyh8w@2D>TrdmA>GFA85bw6%`Rg_Dk>HG1acB#V3l`#3
zQs(qo(%;%5!!(r~^n9>#Hv;QM`HNPniJ_^(fA>FscRaU~VdhanJ0S~@T)hB9i|T>N
z08Cs+%H1gV!=H#RL99Vb`0r1V?|NL$CQz&e#gRU9#U)aB<t@r2q<NUUdoC-&5C%^i
z(*j__u;-lx$<{)ssZ1{|mk<<ij7-#MMI7x?Sun84g%4mEzq8?hoPyoz6WG^p{`_NH
zU<|fxl-Au_rR!+Dgkax07LGj@lt$4f^I?NP3D<@7mnOE}RRKjtef?_s80k%an>)%>
z`T-!tJr@@GDynN>H{dkRKA*z7J=SMIx1ws^LV4(q{>(D?qMx$$-E%!xomR#2VZ)hc
zPLK9$Pa5iMNBz$}{-~^f_pPXK&?TmR&qfb4)*Y14;1JX~FPB^pFy;6_)l=2MsDG_|
zR0=f%2Cb;~{|v@qqFfbZ0G49!-QEIl7p&@b1GJxSfZ781X#5obDi*u$_rEU{(AnW{
zzW+^%6wbg(YH4LP3<I6SvEhbrgvNmkz;GJBOJpJn)Nw&B4m-|YuZf8SXS^MU7n_7R
zucAuwF~c8#4UZvi3Ha>^aAg$7tg~yNTL4-^!#cxMI@TR^r9%tiKoiu1w;UNO<z&Qh
z8@(N?0PDa6*v(HwMG0pBfF#uz{wG|?J^F_kdp>mj=gf8l)Yw6Mk35(4VrkOgi(^{E
zd(-162xbBKkd)1<SqS3V38g?_#G)WZtbbA+ad2OgTA409)YGLt2t3CebV4C~Re=48
zKX<>{eiu9prjOsvgwS0r&f$kbgK9N^I@Tk(63j9l`s05ui<X1ahs^=~9GyCtPr<CZ
z6lS*HiPPzHL^q!IOV2zhzkca?rT;xr-6{CF(*soBJTfv06VDL-@=2ug`5PC>&v<tn
z1Jo%{2JLrb0(v2=ng~}7dl=EK0J!TT6S6%D2H^bL9+0J%UTG`pahDN9MMgc1b_gw1
ze`n)l6-|ayEpV)E1k3Xs2X{*+Ca~1>M`1qqYCsS!tRoO^;pmCOR!tV<qzbSlFgQ3Y
zp(C)P<7WbJT7lM63vlWo4H{zo&ewE*v<j2i7|qC%5M{%Lqu&w<EG#x4KdXhfUIYVx
zCEdiigfak@@ZXI<?|Zl)IguoXJ)w+w*!#QwE}<a@K1}mKjo-do5sD~T>FhX$WflsM
z001BWNkl<Z5%7eqG!&G{!QiE(Dai*X2osj0$rlI#HfPsy8L$sWab`nMs6bgcbM+TG
zPxYO<50&2`!cM#|t)0i4ma73JFoC*oB?P>1#OOGL@Mvw#@3`-O`$Lb&#aCWqStVo&
zZygHas>dA;^CNFRPESza@8zeTz^TyKKYT1R<&xh6Tq&x<o_#(}(A3PG3nsuP{KY{S
z<}6@@IF7?9P~pq1!Gn8t;uPA%#sj}66asV@fWV5wuq2@4bSpFgz9&OaOB~4+;aJ~g
z_kBZ(!4%Ueg6XTmLqts)m0JHe@i+#HJ@AvT1<-^2_P89s8^;@=H((zO?Lf&7Rs$%f
z#dp-H$6InFxJl)W$3zV)KKYmc_CX$G@L0V`X5WWej!IVTV#%q%+>{^sD4Zu1@??N{
z8K^%fqtpzWTt`j1TfhM9O=PtRWdJbw=bGDJ;#!T%(|3tPI;<>kba^*CAi3DD=g|{Z
zY%ZoXes#wW@BH<^O*$(+ERJvtfJ{i27uGIRas~qswi|ATWc}}$>%k0U7`?|2ST^?Q
z`7ZHNM-bVM4D+u1ULvevjKh+eC!NWI7z@q<OnNHesh&Ge=0nJ<6SMNxV-WnYR$-_#
z>57~0lpF7UKpg`!d2}uKHRbR**?y*S;{1M^Ctd%+yYlQWewwfupQ<qRlawByJ_zb-
zD4jA@X3v?c%w$Jfu^t)WscCU@2KLhX`ue2t5LOvbN4$<>m%_AU04Vq3C1&nYz1UC>
zfRX`#F`%&+fZ40o%F3&6P$ytG=!44FFsFP^8VhV-{I0e`*60*uktX7XprNm0-wwsZ
z=RwFi8%ON;T{ZQ%%MOB#7oU#rL`LaU>Dv7TjtTlE%UBhl6~}_5=SiBye6T#H2i&Cx
z`+1T8i%T-Ndvo|ILvWTvLAeSr3>y0;n1F-{115|Cux9^@faL#+i#j-y=F+PcNZ}3l
zDoIT~O!q}3++jlu2=%~CIsnImlY6I{%EARJWOy_k(xJ`RbD!9ZfO!7KIDEWXalDYr
zVblr0WmZkhgNS`N%ueg>YuoQI0M4_*GeIB&D?MdXr^zC$2IOHzas>OmgAfp0dcnnV
z|F^%VKK3S$zVk^kuk%d#a0w+=D%K7wpn~zkzH$9JdG^ttN;`y$Qtmgi2RKVV3~Q0)
zGb&{kwvsYH#EetV-U_(=Cf<E_$J5AA<?LEHd8}Efur^GnJAJf%B?EB&Me1~q$ul0&
z<H)5v%(nO5gn_Ea%g{?Mzg}vVtseg@zNy%{`|G#Eko_5gY{ii+pG18u&{wn_<gvmY
z$T79m?U!`u3&?}4LOPGy@kRAHyM7<s1cTx;aAdj{%*tSZ#Qt#mDao3%M6UwqFMug3
zx;t>B!lQw@eKOk78eN{mq+;jrNZ@N=01_sMk}w7UoC)8qhj874EBr|UI9V?Dx_c#e
zi5~2%*nP21ci0dELOpPk4#4Q(*rUc-+G41w%$zn8Qm7|o7}EN`D~?+M$1w})#WMM{
znX{lQ3kr+)a<CswAF8_-#zCUv0XOMvn0_iY+!fEn2;v6Kfl&4`7jgk}7B5x0$Zz}F
zH)K{#t%_4=?D7~g^|5RQ^qr-#9t&j0k@)ZUVzWH<FF%x1IB7AF54<it^?NpZpue|A
z>JJ^1nK;f@fpN;E{4i&YgD`jyz#4zkV107`&K=SXmA>)1Dja!TdV!Y#FlBiNn+HFv
z0DuA5`N;=kt^lmK_7<65Ggl9Ot58pw5n%o_b{OrZQZlZ7bU;a3B4nV3pkloZGxdRi
zkmON75UZ>9OBn$_(?9OJjiUi#rKS&)vc7#^8i;ep-u*Cy9SW!yz$YK#BpTb7j$@6(
z*nSye`PM4r*f|mwOXYe;L2IcOAR&b&k^z7sX!%=QH3`8i%0kj$_OamR2PG5I`sO|1
z-CQij_|+XhI?P|=ciruH7mVq`;F^F?O=aP%8p)rtSVBEeQ+d1rsed=z2sruUIPZG|
zi~!FL(>!oCj>?!Lm|WMR3S!lF_))|kU8DO__n&?i2F5;j!QFk%Ow4QL&%}&jTEz@m
zcHSEOVaE)Gkt*Iw!?NgfeNJ8lL!4Eloo58ch4$~>DUbj7pXA74tZ*dv<yN?+eiGjU
z-B9M!P<IGACKkyQtRT5H)cI@EBgPN)g)wkSpn7;J#$VmOJ%KVQz8rx;B?Jh209;Y@
zyD*|=Cx9LR3IS3PP=w>LJSV>dHap6z@F_Nf9HTs_Og}6zY;_8^+REoImW+}q($U-`
z!%($5QODCt-G^|x0>=fjOQuQ=OgHmeVw@iz19#uU(g4tR;)wL@*yv7X`-h>YAiH*v
zWJ4Aps^@Lz)ZY;Hsagft31Ps#aCszG@<e+%P>OLq2L>Rvv(XVS2_Jb85{?H3SMn94
z`97|25zFy1Par<~qU$B^{L7T2s~PKjsODnP#;@-9(P91?zje3cd~l`<i*pE7I*3mW
z1l3A-&a`A2ELXK?<w2^3-~ONO(=AfBb(0*}wpmVN*4zoxzU@$*c?3H7_ka1hG-Iir
z26ZSj$YogFmrnnw=VAJnFPC{P2B!L-Q15f%Y%T}Fe`e)@8NGRRS$?=KN7rwc2~Sgf
zo&4k<|Cb!zx0~RU`z`8$KCA>BZE93ZKq-{ma3v`k7bz8w?vVk=fKcF`t)IumEGij*
z2n+ym3nOe6!e?+Sb;rk%g#d}uobxW0iUh0xc<?}<Wn$Jm72AGOU`L<}c=Y3FbRuTK
zq0=X@8n9J{@h#2AQN0Yv7O9tcjDE1XBe0*i1)vy!ASNE#T}RS0Aq#N6C@p`cpcw9H
zz;6hKp@t79{aeA)02@GW>l3jGkPrp{`~PIw{u~#XfTX#!;we&a>qA(ApJ5YdR&Emk
z3ln!(6CbA0uXb>pw+xjAKc2KK!2`p~0RfaEsHrTNvq(bS-OwV4GpRuXFljxMyo%K6
zfHUoK9D8F2HgAwUpM5NQHhd(9w{MZU?VG^}Y*zg<1s_cc^zj4i=|9t#gad7L85qMB
zoGtR^^QKqvb{ZYW!rW!*G`fEJ`HWgl9G544^3SsCi_aA(_4C`+1Kiqa2V>rf^X&7N
zEQPf|Or$uF;&3Jxg#xEn&XV5VK55v$C+3oj5TIuTz!Ywk7Q_Ucf$;H;b&-Vt`7Tz>
zU!pYs`P*ohXVqheUD*3!o-p#Ik$B>C!Sp37Wi&fax^N<DWQ-FDuA;~EQk!4b!JX0z
zTO0XM!bSl>I#2x(O7Nyh!wNu?^lbkuqM+UgERg0vhAS&x8v$Ik0W%cZf$zl_S_mVc
zI}tDi?J00Z#X#{(p;{OugaH6IQiJmT1{aSiB*%dR&s=(;<X?6JxHuU7;lQ+N=G|Nb
z8Na&YM~Cr?55EJ`1VP7{G_E@$ym7(l`7-BWP?bP=P#TU4_T$*hh+i7j!t=NB#$|JL
z;Ui=m!~NZzQnz!f(xG3Dk7g0JY?L}<Byyes{1&12z?jB@vrO}>bsA0N4a^&_<5+=8
zYvomG0AU`EfzvoP^vutHA{#z<hfyi_TiOF0hbNCWD}ucMN~WmbCnm@7Vw~mA#?iBx
zP*&A=xK7$)v}PH|0GRTvyO*#LNEraj7C?k80Hz}GoV$9hGAquoasKlBVW#uL0>fxO
z4gO5SmO$aGS~-IizYqlMChV|f*mtB(dcdre!X7~;1n&Ix2i4(E(}(YF*B2kF_d75>
z1Vl%0dW_lu-CGVpX#-*Scu*D~bOeflz-%Phku!Q33_$z>C>FvKW&kYd|9es1*Ku*1
zH#v?+|89IhvZ(mS`k0&dlXr6w8RJ)X{P50E6*}G|{YMW&+uszm4`+ysC%wsU<#XaR
z0bzq382n6!D-(mGWbPs<#sHI?d>QKL0hf$pDO6Aa=7ogEIPTev6*lR9)9*Ah+R|7j
z^;lxh$;*=|(<{^o0@Z))H#E@m3=GT%XF`?M4Yy$IBlQe;SAWXmO3xHl9P-fO+e=S9
zF6(~%`h<>k=~7d_=Xwv2321_R#|ZB8AV`{n)u@R&>Kh;vuz%-vnE5>ub#d`A02s4i
z0JgpV)|jUNdLf)R7g`33pu5EFoUe|C`oo0!VG+Z4e`sd6sG?HJp<rha!gbvza3X4g
zIueLOsP(v{!75=fRQ+P6K+u@Zk7FOc?cH0~d%mll0`UAtdb%Zd;R?yb_O1S+cv7fu
zh8N-sq3xVP4sPENxgKAZ1O>Sbum=-wnhFL%iQhTW7V(!sWbVW@VP+y06w+tZN*2!j
z2R*o`%E6Lg*B75k&quFH|5dk18CDXqIS`^4Y*CeuL{u80n1Jdz(tpjZ(u<|CKIrZr
z>^dVO<lZ54#^pNAz>uWrVN4&LzLU|=%!Y#5j01)q;VPv`%fKl1#QDN-XzIL%xgcSr
zpMrU;mqJAS*vIO^OWOy78KdYE!YA9Egd&aSfABw~`PO^nid*l3FyBm^g&zMUPc&Y=
z_yD{MML+Mo`m2<ppG0@=Ib0sM1Kxb$8LR*l$gTH22!%oXgvIapTGcLCBzHaXJ$d>^
z{~(=E)H8Wby~G|(dO>v!KrjBjjq7C^1eCco8OiC=BE?1rr&hlb82vf#{zqgA2=>00
ze<=gl)1T0{1mB_7^}m+s7kou><1pf*CRO90Kiqm$x_54tZ1hoDCY2J!=<uD*p1(}`
zW-pSFhS;}&Vyw-boXFmf>nU6l(g~0V24D`5Sc{8eDLD=^=B$+$OGYsd9>n25X9uy5
z*1vO;jCQw6*PBmD2rB_ouDeSLFl*<QLLwdYX%|9o0JU?`)GzhRv$H6dtM9t=lpjBe
za4SNt3A~*K9<|~?!jCezgieBPgy2}7_A?*KMmj@Qbv{=;h*!)2X60O-Z*8cPx-A=|
zVe|Uv?SN09lZG)%*zo#`a^&DXx%Qr~$&&Lfz-%me@}mPVH~i7tZ^_HQ{6&iRPvANJ
zre-A*@cMI4VJoUsuDR(}C6_Xhw$SACstYfXlg&ru)yIA^$*W0tzoVF_?BDRA)UG&R
zYL>6Yi*LRJ6KUlbdGW2G)xX+Hua+Y0-|u_#c{#lus)Hx6KR$T+I5ZC)i;DpurtG8f
zn2_F0A4u^<S4&nLOa|-7psDudYhfc`zxuWlmL!LVDsym6i1V26tR2e`4+DwYae*2o
z$E6idl{_B(vjjL;F~*;bfC>|4q2mrS9YzIa|DQ<ThF>cpNJ2P_eVpFiU&<)<oU*4v
zx);RApU)FUtf|ujN5B)daU)SCo{)maY?l)3lq6OcIB3caP^gG^`$9amgxO)lt1$Cr
z;))dS%ER<34?a-34up}Hb@8K>iFW2=zi=9ioz&oCQ2_%bU2SdB1Id2&%VavfoE_LZ
ztlPaq2Em9-udI?>d_>I3hNpiKF#Sr8@%z&fUnif=<4q5i8467{ee#h!1);x0>2;sX
zeoB=+IXyr{L5FaRk1J5KYHHLwIgy(9K24uhB|SI}e5?U`!{e-`#k&R2iM{siV+aA7
zHiW>~w?XK!5*i2dETKpL8|@D>uOAkD81EatNx4`_Er;3g3@qVyK^k8P2*&j-NrNG_
z6;gz4UiDI&h6UXHI8qNl*XEDL{f3S9bV|mI8p){{zm9-v)%P4nktFmbwgD!<>;#oP
z4vfn>`$2y<PvkVfgctzq|I^&>f4~KEQ^|9gD=(3}i?0=)!Kc%NRp0Hf1^0(Z9EPDw
zzT?ejWQ3NZTy7M5^!@v{%K(nCW#ME&7L8UI!s8}7$V1Y?vglO(<{p*~@d~DikxJ`N
zV~2H_Dos#%1{cQJd93<X*s8<CnY&6Kp?*^)?wRP%GVJG7FI^>BU<z8G`+H;zZDS}l
zA#MOiv<~muCdZl@aI|Ws6yuCFnHEnQEj(Fa5Zu7L@w&}?K=@bJ2(~}Aeg2s|@h?A+
z4ha9H-0yY|grM^ID8}8anmJ0ZM4+Oe7`lkZQl~-lAgvPeC~PE0W}K?Dm(m<C{E?iW
zurVFw48D9HngGWT0yO1ypThAvm@=MLT?-Q?rTXPDk+=ty?}x=2<_nsMekg+};R0-b
zcAq{aA*{H@JfXm3sc6wEDVc|@UcTUCI6saQ0#q^pl(`zm4G#@V{_+c8Mb^7j;x98&
zF;plth^^g`V}~OpnG85PgahX#FaVKNLXJ~&<dHW{Mn;4CScu#IgNuwnavV9#8}65E
z%jzF1RUdc!m?5IV7Tk_EVQ`{-2X;!&`!5Asbb@l5!D9{53+q*Bc?FU)twO1(v>5?Y
zA8Ip1$6a4!n3n*1@InDBgTG<<tvFQ&BGsKK-Ecc>#hW;DSMd?@nlepVgsIh!YD&wo
z9YVe1{D@4pqi|LmUZTBQw<y_(@|l(Dj6cxQZMN_v9-g)v{4KbOx6|l0vjCPeij|*3
z5J3FdKmJc?fh~cQOZ5PIpbG+XjSvi+J#W5DnKm8ci=!pLxhaC%?@5YTEA(BEk)@KL
z-Uvd09Pib5$Cj)K)&yvZ46g<!YM_m8=lb_0)Z1;6jd||`F+2ukT{)Q06ha3A^#rJw
z2)V+`4~O~F*kQ|Khb=5jn6d$dFyK`NodKcY5$S0<6dMzOJ}O#v0pzISWB_;yAPNRx
z6dGK!VN5Q2dZqqQjM<yvk<=x?iG{Kc0Q!+6$3aTrl~=(4#66RVn*qS=pLrj^br-Hl
z-e5uvmP@aMS>CTg?>~;9nAendLll@yg{`|kObOL9@4qZV^<!+EVBn2(wPQ=*3mF_3
zlx#2oSuls`WdcB4P?5VXHy$3iN*93u6HgV-vI5Gq<Ct!|GOT!$2Y0*uR$di0@dyN#
ziFj@il;O;N&GPf0G$TXWaeQicl9#ynQS66c-rg-6<rGw1R#a81Jz6E#z)m8*3TNxC
z{7#=RQpMY8besa>1#Q5rj5Gg6$Q`6yst4RXK*{>!%|~%EV6l`;36=^s=?#H1;jlZ#
zYT2}M$-s(Q9W4h&n5kD&6|kQHa24+Ix~kCc!NKicDD%3mh%vo=9jB#f#}~@B#W1!e
zh#U3q(>M+-U2+wUwgtFv?iZl*;DLZAj9SMGqc3Rww+zC8Lunb(S%>c~-t%Z(@zOO|
z0a(HhRm3borKw|pQEUOILP4}gGO{Iq8H@zsyBD(qZfRKY2<_P_qo5l}bQGF8IFW6D
zxETOc%0smO5f@hhlIF55y-9LbT%e?2&5%$Zef)UBz$hpjI@TmzZ#^TUeNk}F7#IW4
z^we{-5$Z3?pr&$~TCP*|p>&Q(?RVWH!W=>sme0;(rLn^(*XL(V0O^Y!mtV((=TYf7
zNIhvy83Ax4WLnA?<U&Hadhv28g_Q3p%$ob5>?awHb@2$(Je=3o+X2ML;B4I)cD0L0
zGnKlOpFW1QqMxUK_G8(#d82}*eo{T)?}5`NPsr)kR#~ugxfF2E94?5s`11vYNk}Uy
ztE3;qwPD{b(7f=HX3bv&2H@hrEr9UUPA!x*pk~AR9a~}|rWCwA-EdGEwr*4czfHTh
zO9K>j9o)E1c7OPm)NNWXp@9J@!YT+g{_*4E$HN~cR(@Dem|FrA4x~lF0UYs*mI)|Y
za-NjVU#f6%dcf=R*T-1J0Bl(obv+}H1;|~pMyZtdmL6pY4Al@+G$&azprPNdU=@JM
zfns*1fS5Ca0a%1g$zA@(dHUR&zb2WG*fbx0B5pqTw%@=AfK&1GfS`AMzD@?VVqnDJ
zhTBd^&n~P6fLqR;K1=Oysrpec%ce7RcnG!yXC%pN#55}2mBtS10=)Sml%w)kajyI}
zJ}yFO!&rO}+|G~k5T6M(zSD8exdyTU1Nexvfgu`Cx)w#p?YJkp^rFk<ru)B+<y4pp
zWl2GJDzMWZOvtqAQhxeIp_&+H{hxeHHbT))(1#d_QZCg4ss~OSZGyp@ep#?=xuqk3
zV<--X@k+~qGiTSR)vObZ;rqjs0ayZKKwNF}yC9-w(vZ0*!0Cl%C?D!<0Wpoy(Hb8G
z1UqpoxdV!9I*&C<AB28;K$x4iZGxVGHpz!c-Fyi1u`V}-_v2-UEswt0P=%R+Wq=7#
zvPIiAMyD$P6ObaT0F*+jA>aQ<&Rd&K6^jf2b5ILm`m{>Pg%;OX>ryqcpCGdk+6G}j
z7#vEX<2C>pfVj2+Cc*&l93q$h<1QoCPD-y`B6(Nc3So^r`$Nw%I5f=oP<{hrB%FZ_
zceYFC>rcu^9A+Fxp+9=y@E+;GQg}AZS7y`r5C*6z+rGnN`%T>n<`634>PcgV#~|P=
zYpinIadvqo5APA`w>l14tnyuVU}@tDPa)bod+AEaFDsXJXg%wPK7+|{v#>XM&v*V<
zZ2@rkpDr@~h*Q1k#@qPQq^GM(UVH9IS@*^(kp7R0NuG=*rpi2rdw_<Zu*4{H7cK@7
z&k4lTAv%uFpO7)R&^1sFD}?n2_v3WUDLV<7+=|(AW%=4m)M*?O!8~Clh5=A6%wd;K
zpQ&V7dLXnM?Tp&gGuFMcxlv9W+zV}HnNor}l(4n+9{N#<KFp62OnRd~TlejRP#|mw
zjOVawLI$8@3<khozbR5N08z>Ss641^1gjtUD<PB#`VzatR|xqAVJUGG#}||6h%8S7
zd<iCCe2GUNVsQ~~?Eh0-^8dpH>5L>f5Zml)?viXA3sFbuP^~5n`fiO+1yjV#ACCu2
z;lJK>uc?)QxUj}P^3cg6(zS29GA5CWmxFt0Bu;dyUi`T0cVOWJI6MziBfq<hFn@SC
zVReM%Ax`+S;6za6QFR5B$4JJx@~HIqp|!utIrF6wvzOl9UdRR<N$AHX52p|A`QG<s
z;fmE*8r7mDy6ylxi6bI)jPWz9{anuc2paxgf9f&ex&M?)^*}T|z*QnL0r^;cnmuQp
z7MhDDV}vxtWo1$dIimgBzmyQnXVbBcS@W<3aDiq3NXQ})GnK*j1EqUX41N3+co)x{
zZj;W|2`b)kmk-=Rm@FN~sweFn6k<z&rhvH`;Kwo6F!mMY^r5}ddjw2Y6i&$iL|_2?
zb-Rn}!*?m#QvfC(j|67TS*olAst=2ai1MC>mC|7dW)3IUOfWxp><S74#yrD`nE|j=
z|1Lm<e~Bw;(*HdB&*gva#Vf*u%Gq){^TD_M7R(){@L%T#ugGu%INJ$2$`AA&-Y0#n
zCnZa*29#pFKzIh_8eD8YVGJO~hQVX|t#}=_(zxT@ewCIfz4fTDN@tNmcOIQw)ovI7
z`_6K#d`=k##yarlD~rW(Prd{~PPJGKpswzg#(D@k^|OcxIUYm2@u6?ag;!puwjEfP
zT|Yc3?1ou>jj1aw;1q7!{OLM*`H7!H$~!r73#c~beoK0Qt3?e552z!3Gpef8nD;kr
zECS?Bn<k|o)}tVPhju_v3<Q>L+N{~K@{-HI=t3$#q6@FZK={omo-$RcmMoWaSf^_}
z(vVO=U2gNWV@7)dCcm?bO2G)|6Hx|LgNF(8?uUhkN97b&0J;xH@g3$Cz~b|;0uU?%
z;4j;a2lW7S$Fc&z%-9+k%`1|;#jBzg2K3;-Zxl2N4u1JbGIav*vsi+Q#{r!sCblOE
z7c&EZr3O~WrT=?z#hgD1oC1?%EM6nIm-x>9TPY2pV9+KK?l|}d$q~N$qL9l=h#Lw?
zsQIvTfe}c{E0kQk;9M#*xVZ7qL@bzq5f_`t(a%3*w)4}Y;1-O7%!GaER9?n~!F}b1
z#am_i;3}67h9Jt<HRV8Q4<(r^<}47Z)$KTb6tVHUwO_qeuD|<197EJ6Jak>ef^{lv
zTz(BFz~63adE1NG)>HrTf8-RlY*H@O1M&0#SB<DBsCwQ4DaYA<v(o1-%R>O%5k69=
zl>}9*RkI^pUWY3~nX4|nLh0WKC!L<cJONdwsTeOt4z?L)!6;8TRs%X9#Mn&}y@_&Q
zRt9i_;MmSDBs4fEC6(3C_@|f14GN|zJ8XNxTQxcY2H?Oh={&g0WQ%-9-FgckoB?oE
z5tu*bEdZ;O5v<VU;^<)pPA<@mSC5s=y5UO%8ZdaYK}JtBdZQ*c#C@vWpv_ys1jJNR
z%mf^j<fDeaz_l!<nkJGM+->%ix8ba&J`bu0f>oaJ^R9`3CJZX9LFz1M@0Xv+z~&F|
zL}PoTRy7fCJTBM;mBIrM9Lk1KAqu&u)c_!1<EH!?BL!1of4m9nNR^KGho!ZMwLea!
zv*MVU@w}}33>m+Qw%{7(<WqU<eBL}Jzq>4c*rwt`R<mRU_6)P+G^F>3;xG+byKJ@G
z0bS}-r_;2vg^!JgX^R(6L|big;Dk{L%j5s__evWZ!zq{Qfp~kMAJX<m>JQ7j#Y?3W
zvu!ote1!#mQ38N8gIx{+N@GMFShCN>vieFe0J+dN60Hj;7Fn^kj^*bvYBXHDOonkP
z`wUhmhX(qhEq2^=BNYCHsqYTR{*+eFRXPRynf$o<!%WZBkJATs%NZzKi^eHE0PZaS
z6dG1;7yzdLFyZTp;S_+uWwaNX0ddqk2WH)ap0!CA@s8Eek-i=o+7sIejfmw%7s0(!
z?*DTeASMaKco=|LsEGUjnni+VvRzt1vE<(LpsoAg5GmGc{Jb;Z30v_a*q7;g=S3Mg
z*~C<dcaRO}uiqzU4(yR(aJbn}1VUvSRD_|3nZipGDGpx+!=N<;)xHBWreav7v-~Qk
z;+TgiIO26W(_ZEPi2qg^1+l^^wNsx;W71l2Om6bq@fx7Yv|&2EofeT4)T2eT*-$x3
zO@f?t)4qUN>SWPlISLxx_1!;}8VFsPGymarqF&W@g{Fh6LXmyKc#-2r8s*6!{U4|o
zj_w097G9~iR1dHRIw54&3YEHZ!30prj~Z;gu2D27fDn0-0Sj}I001BWNkl<ZVSwfp
z6iR7%g&f%NC5#5O$b!{t!9dUSBvS!jSq%C>o;-}>#G?S({;F_nw*YF=sfkbt>LzH?
z!!3dCV~tqt>ydI0W$OMnE(kY2jA1I{QVhVpZ6@oO_oBtCrDOr-ntZt}=P%d5-FI~i
za13+6?zDdY2n0a$pc#;}`B)vF0VhI(+ddO0SBN!xyy@9FT$Xtj3_whh*_m<FNFxMg
zapa3H3-*E17oH~>*nb+!aZorzM87O1Jc#|Ep@zv<{xW#HUXDNiuX1|*TS|v@0XXGc
zyoj{MMX6t^86~N*nF73+9M@{afPS`tVRc736>kwY10w@rwbf2%GZhwdVd7Dkk)r2O
zzD&&4spXGL_gN6;^Y<CDMGXr|ONr-IS6nMIu@w2q%g@U0_3z<C%-C`%0H{D$zgajM
zbnU%gm-)+AMy-q8gSQocjYDZabxK}&@-aCGwZbWv>VZV|z&<G6dGq<F<<5s6QA&R7
zuMNka<y>9^3cFLVb>YhM<c6<(OI~~QUu5%#??~1Bg^Do<OYAQ<LIoZ$J__7ITLC$m
z@|wA_@#Saa@TPSMJ+^y%%X(>AyiyikbpyEn;5noRCr`tGpo^G$qJjdx@*|h)&a6`@
zp~Z3RF}QOX{}6P)gm4lfmyAb%8xMz!sgRX`FyZjFj{|Z~8fXSeUXClKS#C@W00aQR
z-pE&QMZac+#1nELnwd}rk%n!6cpSObzWqCt)xUW1$D9ZCg^txr8!u!g-s&u^DaZ_H
zq)UVF4>@8Ia^mUMz{N0~fvLd^gE^F<HIDh{Xx^7vy^LQEe3Xl{jAI3~+s(2Hz(`Gj
z;ftD8Yn3E_5mbYw(W+o1$I*^x>lT*E16K@3hRlRs^;^FE$Jm!#B%i(Zd_>s*o}gI!
z)!St4)z?dwo7?sj>QqTEogZ7SG|;FIKhU4O`=(Bm`c3sf0()Qx3Vl9(_YKJ}Dw12E
zpP~RK1cDsLs2QhW@m54;R;H}J>`FP_)F7X|`I6LP*?#RcH$wT2R~T^2vaG@*)s=}^
zXeHji>mK=cvJ<BbcD(b7bhjJ}Ln$5rE&Mfo{;|}oy$o9c#gW^~!Yu?nc;Y+3Z;|=N
zjfn%^ZQ~rDfw=GPSbQO3VKUssz)vA>(u^FcAjZVaU9vA}V34)}vX-rp;ayk-fOf?s
zIS!udL8IT^xpQaKHr<2Sw+I+x|DU7&uW(gINRn`HT6wkPTzxyF{~>8_efmiN3=#17
z`P_YRBOnajZ@(ZTuupwf93@LJ2<!_pVxCA)Vdxf6emiW%nK1KN=|`YWROfNha9@rW
z;fz-oVf4H2@DF2Oez?C^`r2Bht$x2WZT(D+A37kpSkf$j!Vj(xm?d`h6W<^9x9U&R
zujWp;?Pp@E-}z#zAk=^6=1SGv1yThe!A|H}?|`0v|CYeqRcqw7Z+;i5SHXnXbz1e>
zWg^0I20w3F2za8s>)v`z-g)uq)LDPiS*d%%dw{~F4F~oLndYk6x$2#XR0)a3ScHT6
z1*TP2$+5<I*@{(wOuR4CARoYEw&UeBb*l0sRARss*sFwq;4}#8c6LBs=|p0LVuv6g
zIcv?Ol80}Hsmp_x30QZNM#})~k&ZoI_)-K1jUIqeF0DuDxEk1xcE)@Pz?2WBgTjh=
zt1iab{x~L{{5XQa8Ql3fgb||9IBV*i*qxt6cJm9^28jAdR;&yFSR(l|TuEC2$e0I>
zT$f(2_G8#WIz<4q*Xu`wCk_vCpz)yez54==cqEMzvoJfiZ`1}x&0me%K8Iv-kCe=q
zrIeQFZ3^AVx-T7K&lcH)-zN4N=EONn1IsGIe&^g}E5T@#%JKR`wt(QYs#>}8_y0s@
z&6#I29xPis>p_~371VV*<umy(+Oc)RC-Ur%e<1x)8b`5;P2EyG5OWV`CSadbRM$!c
zO#cR34>aTsUu1Y0a$mYqEjKe2N`m&lI_2)q)~OQ$<zNaZC!k(5CUlC@+0-vdT#(aH
zZyeqi5Tjz8<*!<T<84q@(+)x1;fV?eqLQi$uaE+~-+t$<-`fPu0PL2Iy<hsXg@=JR
zRRKpj1{j_}L%2!W&r@Gp*GFXxD5#v#o-WD85yZ?$ThFdWy1aH#>NEg^CP!P2*svsc
z$gR8v1|aI$ZmbNz9jM@LTruT~yWtoBS(n``S@V`+5bJaHEX&Xd-p!@p2)N@w9i->e
zcV%$@Rz{~>Ko2PC-ljUN2JBbrKdFD8lKqAlliX^;YxS+w$3e4k-T7Vu&F7H^*?{VK
z3)NAjHkjb0g|wT#@jY3(7JAU}jNK27>D7fw9lr%*oPjeEU)KXWcgQm!{%20N0+4d4
z9+><d2w^qtFpdY-E?NQxH^6#e5JgaE=?MNRAI5TV*%YYtEtCCQH_1`h3^-C>CxtMF
zT?&G&-VI-K?7Tj>3953{kAbi*08m#B45-b(YCy@%YH7m^xxa&(l<_&rEzJT0Pz<48
z`(uHkd{u{qNAS*`hNac07yzUVI|VQXx~$vOAFC?huwpr3ESs+70JxPJmLM2lr^7dN
z7@AUtc^V*jj#7&|uu@O0fHo>)RUb7W$KC?>7`~5d6)t{$C*Kv6NY3^5Ne0f?8)Cpp
zP33+V#<(YLxU)mL-}{w}Mx%Ce@>_Gx)}U4caCW$9=T-?}ud~cr4Pbw=M@_$~{#G!8
zBNJ$q%X$_j5BDUeVYV}G`6`)-t$|gST&|WoS&F}WohNen28Cly4e~V3`X8;^&ni<c
z)dNZEfj;QHXgzU48LQ&S04<suW%aI4a~dShxk?s-d`|;}SI<DVKP~-n33&>R*Ji6T
z_j<(J*=&!uz96t4#^Zuhu+=bQ;WFv#ACOK6Nb~)V)p1pU3;>x4<8)o#8oeP9XfgoM
z1lR$~dC|C{CFe`AItCbd3xIX_>zObEz%sE7kW1CT5LEU%e|`RVMTpQxLpwG>DNy2$
zV}{k^1+bI2=fLBDQON;B%>aO_n1+J?Bd&5>NpY0^&$;ZYdih^dBh{~l04PFXVWRx_
zvE%TBLQPoyf9Kh_mw}Sf$aAO?E(^9C-Y+K`4oflYcynf=43${@>h5Djo(<gG(H1j9
zw;zOpDK<jI<wH-xtlBwB$GRr`u`vLOTfpny-r6EBJ@!-C`vnY(;G>dqsUApn544|Z
zk*>~8FagWe_8CWEJR>m^MuW<s74Rg?5ub*&yg}@*H|^aer*ZVK1WV97+Q%csk({bG
zpkfcm9l-28A2L;yi<YY`ftEviVrBx;z|dD;bfpx}sIt*=S3#gZOn_nlxB?Ij0{{YA
zwDkNjw*bQGu&_x40|3cl$y&5pvhXd8-Ql|i!RtZxZSrgb@DojGaB2mNO5<H*wko{E
z-2caVPm&xSen#y=WoKD`^rNfS42V%I;S4~MGl^1|(II$_r=qZ6^Y%^h>wo?qvi*a%
zqz}tjJV{{s)sKE8xH|*Wm~@KhM<dW<GFW-tW%S`3@;kqJR<?cep>R(&<x)LxHhO?#
zZ}SIl%X=@sAUzN^HqMMy*ARAI0F%gfr>fv<?|)bdu?0sr2xffu$M4GX|M=fz3+m|Y
zqF#+~TQ8nETxE_2=MsKC7>m_6-YF|?`<gcR<H|ptR|zD$DzUwm#}2y+vSILW1z}ug
zorDTX$Fl75!V>5hbpk3ZE_%Qy&hZbBfLnM(t}nREG#t0iSi}YMq`KLtZ9%j(M#TVF
z$N#QGp^#2Vl7p~HMhzH%Xa-6EN+U2-6FL9}Am!rff$oz>W&LCSEbsj6hgcD)Q-n6s
z3&06@q&RowOcT%LE?ghSdQ09<N&LIJHswEyJ@DZx&nr{YG(H6??O+0LwBwzV94f-P
z@tc1L4S~gW8Er=!<gK6nK;C}hr*aZXu7<5+WvX0PRdxn=Y_RRovA&>Mk)s;n71!M=
z70cJe^sP1DWtQnL*B@r>K`@Qg7{C5+zg38*EKgvJvf_*i?cFLP*zOt61)_l!fXrIZ
zVwkZ{qT_zWWuVzy4H(x&#Q>lbN*D6{f6`pqR9M=poGqiAGLGRq9q$SZf`E;*G>?%p
z6*XQDP(bj|C-2HD|LbpL_a`4HOJ>e;yQ{OUf(QwePgY68)9Y-22S$YhN3asHebWYc
z4IjglOZC9H(gPtZ*}wVpV`^*;QCCNx3m?yV+&ggU>R5Tn6|(B;8z2JU%#f+lck8cT
zk{7TVuzTYt+OnmS&8kfU-28_@gE9W(Zdg8q4i|ofc2=@Xmc-nxO8s@Sa5JkOvm(sA
zo$rlqLr_@}%Yg9SMBPYxiwvGP8d%J@xPW$LRLqjJ3P(;Nu%N^O+33q~Ma6YQ+e2Jd
zNS^Q?Doe-gKOHu&gWPx>Pob89y1g>mc{(V23KnAzbb*<A|KI*WK6>U+ISn<xB*YP)
z0U{VTR{WUNN61KloI31_zW(H+*p`TDduz;UQjw`1NMsLm;uH!Q(}sil@qR=Y#H?_P
zC`RW%=<kZ#?~}RbU(BG#wcuFU8~^(E^1-u@OB;j*c?8xt78_J_7(<Rk{&bYvnFg(a
z8L`Y%ZQ|-J%^M1@i};4&WE$bWyH)`F<$9C)W35Rem7q<~je-FffWfy>i?Q?96jZ!B
zO**V7rdQ1iN;a9W<tRKV!G&=d0Bb2>E(&zkr6v<~tL)4L5KwVzhl`?4)A6I&#~wVi
zJBl2sB+>T3APih=d;K|i^T&TL`!;V-%6G<F`sed-U(wcOr?Va?KN!tT_43*;AC+T=
z57^NuPpSvbr5-rZco<B;&mhd#<YfZPhbby#({TE1hFp2q*Q9i2RalOGoNW61)o0|D
zfBv6RziYejNMg{epBe3HZI27)#42A7CR=$>a1^x*Ag-=zR5AWAfeMBnvxP8becXE=
zX9YMYzg@4*qy(jk9v0faO-AE2cg}49&@$QwNTQ>v{-x1u1B}Z6pdhBX02j9blH$^)
zR!aH|EStC<zWq?6z+kBDlngi5MNaABEbT;u1;LqMyg0j%0MA%?1Cske?ia=FA1j?d
zE|KA5yS|XOfBe5?!^_Vpi)Iu|;<E{SK0csHXW!wm{Z<)aVSL@XIy&U-=bn;7+mm{x
zHj&+yD(iQo2lnAq$~!MSBRv$JRe#Zpac>&xJgHr>Os>4|VadiGz2A*O`0&V%E%NFQ
z|GR90D&g)kZJs3N9r6GXAl&a13_sNUkpb<5@j6|$Q-kBPN(8`$jlHYuMFH=>ozENN
z2{Dbil#jF{fJyOWiZU?V1O;X=2xU7LLN2cz?e_3lW>n3AGL+!eY<JoO`l%1#ylBdc
z#uflsmzB6;d2G?t9WhPX)EPMY4-Hc;1|TRgJ3kC504brGd)X~k7HuHM<TvTL?4<?>
z?lii?g4EGAHH`GpG_uwz9pmA2JnmK@c3F&MT0CqO$K=%U&$1Z@XUbvN&JRgkZP^bz
z2K<y-Wt_^R$^%p4DM#a@<8?Z_EUSJs9Y7wojpYqN{ckS@?-?lj>4h%vsP^6z#*u&e
z@xj^j;^T50=kG7UawV+*X5lE)s6vc*u>-7tDMo<;;3^()X7*(PQ0;eq`pz4&<^7b7
zf76wz`?=i%o8Ny+rdQ3DD{r|2=lHo5%W>~>3KRfW$wt-j+m)AIDa~~UWy>2c_%iEY
z53C7(`s^>{1T<`Z<({ugd37ynvR)!z(Y~NU$pgdp$1QgdSfLw;ZyopNS%zJX<*~!A
z^j;Xg5MxOAyRwbxWtrv*O30&%qamy!Owf(?cT1@8kYvroq?GNBP+kz6u=LWYY8zl=
zua{AaP)s7g90c65=iuuZtH5X&051J6!xi><9;@KE<1k}R=kY(K03*B<c4!bHHXM=J
zu;rWsOMEIFe$o)>A;wl2irA_+T_)43JSLuZBqBlMuf7|YH;>87GD+5Tm;~FM&Vehl
zx27JIMwhSiTKQPFg&&t;ytt5QaFva;Dvc>q;fw(8+`sBS(=Ml*4om&#>*d(i4Kjo!
z{fRhQ`K#Z&UQRXE$whZOAj>bg0y@&CC>-%!`2X2^4=6i|ByBWq8%eEhdGA|Z0wE+J
zgcZUF?}Qs*U>NN9Va)E%+5OLd&U^2?v;V)l|J$A2o!Mc$gMq;e4BmS$5OT<S@4Z^4
z?fbq+Q(1NE-oD-H?giA@T{j~mBO|k-s?tVAnu0}MJgXo+9$`Z^p4+SzeLP!UeeA(h
zvUX&<1U`!rsKvMO@+0?4ZyfVG@$|E!hL!JiK9`86hW>PPuxYh#^&A{5lj5i#xcuGM
zWFPEeTzt>H(yww<K$U2qZ49$XWToG&R#rjkydX!{tlYGwizt(P857|mC`!=?#4Hky
zT=H`=i8v5!5eGiiIPSgkROr?<W0r*50gHx=lKLedwMcOaU_t?~&F+RPZ$)3o62J&B
z$zF^CvQ-><ZQTE#b2`3|O!;C`ixwBB&DDqodT#8!=_s8(j^!k*bZ(m7`YsLA8T!EY
zIL9l>!_adn!RF=iXBo5{%oi}$h2nWw{u*a#iXs}C1XX%1zoBJs-QeH@RvZ5AzIboQ
zgC_(QL!LZxw=1lQjhK3tOuzj*a>m_1lpZjz+!F2pW))ul{eQ^|INEf}8naz6<jc;0
z`(RT)+EgUcAmMt9ex85mcQ75iH)Pokw@ctNF9E)@&tqr6x)o3$%khruO{ByT<<LF)
z^_R0}-6-WfjD3K#8|P?x>(cr1-V+bW!N9z)<Kfc)k%e=4q0VGoQK*afq(P2pdVaaE
zdGoeqk8+FhNKHqfvmS0CSG#JF)CIO48e<!llWj=x@Ud;Z9dH23*l4?5h=icQP}r7&
z#)MKxe5L|glU)CY3x!xn+FUfb_~gRp;**Zg&4n?!Vl^%qiEt9dJPW~j8V?{{04ozr
z8FZ}ZBBM{AA?JPbM>6`tS<<n4Z|z8=-&<i=&IT-d?^SvH-~Uk-z&H;TlX5v0DgDA|
z1raW8H%2tiLgRnS>J_<Iwd0Rb0)vND%Fy8>j*&}y@>~+wj3u&{FnhIo$F|tJZQk=}
zbnf1H=ZE}gu%~kTL^=EVTZPAG=W}a5dPmkSgu)tjA&{3k4}|qdgp8mt-X(6t*BOAU
zY<!}Sw?k^3#HCLTwhC~(7rHcFxswO?pPQ&jF+5GSCfHUUmM4T$nc{wn`wkGcZEfhv
zkyoQui1Ky-phd{1)TZ12xM#8m7OKLjr8EJDxDYP%O^MP(P_BnVisY4xHVyA{P{4<j
zG#)ak3&RC3xlKSXnKl__4*d9f4IU<Eefe%V{nl?t1=qHY(NQsJA5P#}vuHkymEZ{E
ztdbxDElgU8;+Y>pPy4ke9+8!EXU8MjLoFtOv(G(W{>T6GkMj5b*Z(W0ojtw9__i~O
zOJMN_Z_DdXJ_f6@k)^;mMKXl%Bk_swsP2=`nJMF^UzjA0g=^9AUi<0XtPVKYC0J@$
zaV{cdsy)U$8NjRqdo>Yn$H)-ILjjKYFdfr3<~Z|-PDUE9C~0=AVvw%TPDaEl4}_!J
zYoJHfP?vveVRmT@&mzp=WCm8|$)Lrf*tSoxZFo-Rc{>0|MI{360BGv#ku$@_B8n=<
zs(tFl=yJs;A3!q9bc#!huuK^hUKVXUn=XvEs2Eu?;OLWhhSSn3eIg>p!^R~@lzkEx
zOJ@r}T!*r98FS{ja?!p2Q%0S4Irae`+eVMRBge`amtPCRSLl2q1DCJ!ZPvyk(zyVx
z!C^#m-g-^md-icyajte0?S2bMpaYaOFS`6H`Pz5CC!@!X)$2Py_&d4$n(Ksd?XG1d
zKs}ZZUU*VIdh-=*olU&Y!F!*q1l%{{{LWpv>QX?z(OlZi?RG-Xr?wgv3Bk~%O;YP9
zJb@%G?exI}Su9BYzT6rx(E;cY9>>O?O3H<}LOKcHL*C(~%~je>7LsQkni}W<G&J*I
zA8u(c8Zt5u_ZE+0o6W&{_DM!TR*iK4xQ@_vrN$am(V*dGT|OwJ1N}?n5Y6!O@o+Cu
zGuS3xz}y^i<&ljyB{jcseo0(*TKD<qN*D2FFS+-yk(dp*2eSd+l1^9>XpZZQ9_|@e
z-z0r7v%p?^%-I6Fa^~{u@xiaa6y^&L{93rI(C%7R0&L)C-S}m>=iA?vfrAF?bK<k=
zH(-F=e$O}L>Mz~g-U(<~kt?^OhpOZS7ztXncp;4Uz`C9O#T%{UH=zmbcjJoGm$P=T
z4^ZB#uR~?|HHQxw8y(3Q@N#*CQ6Vn0x);*qgqb+_)I(k_O@t$4%3zcS9Yr2L&oY7I
zYq$nHJfgr^h9GHP5Oou`1J(sb$b43L6WV)*PL^&5>~L&@tVXg*Mx!y!e|}G69f0v*
z&~_UbD{%T;aJp3TZqmZxLkMBgHWm)~C26w~hs0@cz<{6z16(pmuBbG;$9W+8-pJoa
zTYz4yBMd~6M$3hdxHFD4opAo8a>?KP-!gRCj3!N=acy!k4iy<SX)4m0Z89bwpPOc*
zKZ?r6bFFXN#`W^TpMI+c5Jd^vp_Y(9FPvNdwR?XkH{W)<bnn?y-vd4cUVLW6-Fo|7
za_2X{D?NHOuM^l3<@}=ZP^Cb;+uJv7z&Dxw{+s&-J~hgW=DF=>^yE`z(uG&5;%}O)
zIOE`1Sb(0#r9x?(8o?zR=ZJrlSqx{{>EIye{b%Q?va<B<KGOJRr)=RR0N&QV9a6h>
zLv~h-OTor**rnAEo$k)uRM%#%CvqB}&md6F4uD-dpfQ2wTZd@keP((?QKB2moPXUX
zF4*);3ZZc+n?mc-#Qk&*#HPoX)Eb{8Kv?nd407OX#XwriC&?~|@*K1H13?^j4GhFN
z;pg4?9Xa);yQMUTDQ3^e0>dVsE|V{~R62Bu_ip*!y1bkpOG~762lwrjS0DegY*@Om
z{e(X!los*_4jC%n_}&lYk}I#03Mhf*a%JV6<;rWXlds?V17VtW*Rm2=w`iWc{OF(5
zuvM%L488;A=)M*22k{-Sqvw<hFPD+i&PgpC4+~-^Amo!IbbMW%;p3AtcRnHqfPsVO
z6_BLi7_E5zKq;=^U0y5`E+&h)EJQ5Uq$zL-A(1j~u#N_v8d<`~RkWfm*p-Jit_>a6
z^rqp05Yt`G4gkoh05}O(&cx{~n~6n_vS{dNbNp|>B9|}&l7hfAKExS(T5LgV3nGg0
zaT&(*i-#hXicdtwf;JGt*(@5zna)F!j=5K0I)BP#*UHRq|AX`$&sQL~>o#DhoH^?z
z=?XKVuwIaxFeod*@Zu?I@4xhn%zxvh-09n6nk9h~CY~(c`_VthSu@U+j&2WgDEt7X
zC5jH9nQ{J1x%cn>LB^iQ4M6R#B_%NbjThzJ7oJl6mO%8e??LlpWDeH_-x|NU?t_M9
zQ5a)Bi3Zd1()?2RDjuA&mhQ5+ryvqcv)BXS_@|`Kk75Iko>Hu{6ibnno5pI*)<`2A
zV^ct&Xy6Dbzx9VwHU($mu>)gWdI?-?+|NKas%Y?tII{IaR2s=??<cyG?1FHp&~~N8
zG-T1hVe!42fpi1Vmo&u1;4lE{L{QVG;XGptkS6s4G7X<hpA5S+Nj$^pap{e88f`j`
z*tpBaq{s*DcnKPU5tFCM#ozo}nQ+++(h-MRBpq>Qe(5$DG<ux>D6|~-QC}0J<ftfv
z=Z=9D3+Bq(e|@-p-9IVdV+a?+HpH~Erpvc~_#-)a%2X+VevNx3jrlYSJL#0E+6g%A
z>>0;UiuR;Q32=1&{xg4(C39w*r2z98fDC|#!&Ffn;AYe~A|5b&l$?1zOa&)q>2%v1
z`{4mEf+iRsEiR4;^KBgF^n92;gk9<+PE&AHU+CzZw0Ru)CohsG^UcE|e-sW#DxG$r
zbiLzmrSqvXq^J}1;?rHDd2*0TMZhN5TS(8TN!a0_&aS*Ii<~_J#Pc+vf=(2&ypGN5
zP=@{guv-xHuF@D%$oXH1v{Z4N=i!0ucw(BGPx1xGmEO^%#pjCiMfHGr$&);Mv<2w#
zYw+I@U~jV5(kO|ALw-D-v<D6(nSRq9(tpGl`S{6)WZ$NBx`l_zgD0GOv5cGMES&|+
z$k00Ny@yO)g!&D-Ci?Qje~`oN#(rXwIhFv;GM|6(WmxaOLk0}Oaisp?7tWQ2rACbz
zE8oP@K@aE$y!`A_s=!t_hjz+b5~zZ)o;MzUNO}zzB>jdC&uYN<CHad$ieo2j%+xbv
z)5>Ks|Jg@9MFx5T&N&_~?EEae%_FyNf=ik3?RypD=XinCf-y)r<Q~!|GGNk(3nN`#
z&W|N<r0Pd<h|#14P?u%ODvXssS~$ePKRi*ks7F63n|Y0tO*&JGbm=THvy#Ru2hJ4D
z91mPmidA(i)wGdg8_sq0?P>Yt>i`Tx0!XE8T&7D8*i2?Qo9-ywT#q|nTrwx~kOE#!
zNla!5dgX_oT=lQUv+Rj<<dbF^-_r*LH+^tU-bVSS)0sq}oO043A}llQnV&fQ0_lq*
zL+3pE7c~LgbLdE!a?w?=GT15l(8&-Pgn5`;?XQhzh$EH5RoL(U*q>w**8SUE%SfOC
z%AA*8HA}96Mt`r~Q0BvfbkDiTIUp@N5MTY;H>6vS9`g7@4`gp;YckXJ1eCz~#q;IO
zCm)q7ZvO_(iNR!R_>e+4AudL-O{CwcbA_CG$<?wA#<I39nWvQeu972j$HJvEga)hp
z0Mc&>=lCUgDV{%#4Dgcav?4-<664E23%CqM_a&oFl1>w*N(YS0iz~X~2$g!Nhne*H
zni?s_QcFp1w4azw^X0eshD8WrS1gBfzQbo|51?CbX*hh)p<3JLOg?w=EltZPUk8BG
z|82H0IMaV9G$eB?C?yL|!A1>@6SJx86b}>|N1X14qW}OP07*naRHJojh$E_io6<2%
z+5qoCzI`A{Mv_@TuX!<z&xDbNNPE^ndTsC-XVYsECAAGX`M@cjzxY>D`=gy=z#3E{
z<gQ`Gn8Y@HAQ8orJfbooWf8->ybTi;otonPDo4tBw|xVOf+t9K99h}}=7r-W)+|i9
zV;Px1l&@$*GUtt#WyyPQnndlt$1DMA@859CZP@33rBtv{X$gmi-=k+Q`4aecLFeMp
z`+qM7u@#Ej+1lN)NnqZq&*IP^Z0)<^np88qtW)^q=!GBpF^3PTCuR{&$JW5-V5FuR
z9cn!wBp`B)elo4{^mGh`U#E{~5|GS;1&-$fb|{e2VbopdGC&sJf=Y$^;b=aGD;ar`
zbh%)bl#Q7nMQnFazqx$0%q%C~eTU1zrZ9BCBm>(knE}J3Ve8t$(jGe%?K_WwQvY)c
z7cLA+Vi>1(0PGF`8WG5+BXI0R3piv3RSJ%jQw&SV*D>j9WXexH_Sx31TOkeTwdre&
z2j?0-69zwf>uk*EtY>^YY&T6xd@PP(AUuw|`Bf?2!0Bltl{m&bzUtdT#Bs{f(4~~e
zr87QgL8Au>k+<bv42xmZ67Jls2SycLbsfLKP6>vy3|f3JA}=pw3lgRHAi|1H@twPN
zl}R%%QyI7|e~#42oIGOAK1k(*A8OIAUGk~C^_K^w28WrnyJMHYuo0u=MojsiHDiW!
zv<97wy!BTzFweEHyrNWwzPzGBu7I(i-hKMWAAj|8*}P$WVT{_Ta!P>u03X6gQ2)vi
zGHT)!(+KhVKnj(A@*#Lmwqw9}jHoLoOqNrwzF9u_^KW!!jbE_m5u_oQg?D+_I?a<8
z0JxckES|A^Tn2`rmb@u>*}5{jIB~vVyot#jUv}1I(*2_Aq_ht-@^Nkoi{q%BpEcmK
z8TfdFL)hh?hI4WBGgzL>U^}4hf+$oEB4p5Xm~HqNTvY0>O(sw60Dy>^4wbl?QfGj?
znU2a4wEvH(mMlk!+EN6dCnK(I_YSH0{r`~$9DQ48uhKIhz@8#{fZmTqMggvSs|icc
zv+?r}k-b^E@PWD>uJa9r{_3&6Oz&I@jlXHqkS}Po!L_|w2ZugMOP~}~gpO42u_wup
zDQ8GOZ0qaXtvh<NCcp53x|h}Ctbi4dAOG!zc;vx6Va=P_#hgnQMrBip?A)?hUVG$^
zauCOvw!34Oz{s)V<@T?COBMHMHa3^j=aVb40DLDb_t1oJIo3me_0#{5P3zXQ&jb`8
zw|pdfHm{dApZK%RsP%%rO`79#^A~{Rb1XrlGV#2NW%G(9vU}rN#3w0`CQKJZ6V!_z
zs{i2AN>KpL@(tMgL@pn#*O*UOS9+=hfI5$Lr54auB#uv(4}`-dxWs~;&z&VbFS}8S
zF-XcqPkiW-;V{m@h0rK1>fxdRL#2-Oe<3n(88qK##Xk}kD~5tQ0JK(+{x%|_#T}+#
zGClhg%$CCT4GZ4vx^0`J;o!bw6R3L_&QB>#gG7oO#+J1UJ3mb1aLy0o@Uq78NvDaW
z0Dbt9IXLN8LxF{EBMz?E{QhgwXW}#&f5|m60387~4xHAa^YR1NXs#l}n-5BfLwYNG
zmv2_QL(m72Q#jNb2zejDY|T4QKPH=&eHv1>!_Aby)HBYOTkg6CCVj`F|7<#W1wESr
z^Goug^4a96)8q&L@IU2&-~3YMee_{_C!j!C<|11&_d|L2>A%Q@x7;b6(1EAS!_l=O
zawOL0gYT*WXU<Q9CC;}W`i-Y_jehbODu3polu>NFPV#JW15r}XDS<Ng!q_l^1uN9q
z`idzuRTGjXvnU;RiuAbf8YzLT8Q)0)zciLvxBwA=$t+@FM;G(i0iY#ED809#A|Tsx
zt_fyMx0)IwR%{K>T0y^Tbn9R;<=v!64FENRKc<swx2!w1#=jZaejbw4*H+8+dGE{n
z_x+PBc<wK9aQ9BU?dElKm4n`gdqWW*7zN`{JT6A)M;QFDqEyP=|IkRu{I_3~c`rZR
zzU9wLrFnpA`d@m5-1Y5ywehFcelEGY=hhrQt#m~t#WH66iSqUD{f$hYc`;V*+Dug_
ztvFu@-2B&{mxb@Wr3Y!{x*_xY%=eY`{i2~9IBJ|soOwA0^2v9>yczEKd;SKk?~PUq
zNLR4q00w!wa#&VAxx;&e1ymm@iOd(q3_$K0C3iy2hofxksO8_|(i^2ThZ*H$`CU5a
z=Za6m$8fQL;g;#zLlprX?>6w+mUA~imWw20qp<$Z!Qnt$c@GiD;&dzsXj;-pf^kM-
zPHxUmW6!t-9I#Qhd3{=RJC5?fhg!XFw=8-55Ax2hek@y-<6LX(y?0J!NV*VV!?BOp
z6Bycj4LzB8z77VnbxRk?o7nQ#Zs*?#yLmnv+)J*$R=#rg*JWtsaI9Y0&zQ0fujaAO
zN~O;-;LC?gy%Smsyz`si(XzC60<y%`Bt$i4#@=}N_p*NZV%0=fnS+D-1{sb%(l~2F
z3!NZz%tlQ;Q#wKa$I)sWel&f+!=wrD8kbvXE}kPoT((qaIR~E4E6P<N#pAuvr3Rng
zvPtu7CnGy5${{;0aZi?@)8y$=Ryi7ZCp$+Gha}fzIHF943Z>7KS4f7t3);@HEgxyy
z_E@f29RM54GXQew2gDe(M1X4|&|XtkxrCSt&n+7bJGZn%F}|=o*a_flz>WnU$UFD_
zvn+=8an-&(TDh2;Hqzy9ww&#VBa91(!U`%%9}rln?%lOR-gxBx_H}<NkLG&Z=6CZQ
zUz0E2agX%vkBK^t!tArjk~$Ev4nZ;;q{~N_d?{Rh>;&|JQs9^GxLa;Qc{-zFYj@3;
zz=0iG<&8)0m;IcnOLg&YQJ({UoC8cH;8I-f8705y2+u@e;$+A%&Eca?(bR0v;o^Lw
zG--HE$Hu)er=5g2f5$K8BM^p_tt}Vf4BD3RlcuR}vW(<t!qG4Jgf0vh0*7gH!7NXP
z3W#mz*toJy&uZ_p5FnzmK-+Zy@Q^coFyWA|M;J&x08z{asmIorhCS`dWDrI{?l5!%
z=KbkDnGKC$9v$ir4+#VtHtI>HB#W*f5eaQj<ME?D&@}Zs8|F_pE;f6WN!sq3E`jdY
zj`vlJxUabG2I<nRn-h18k(0UeW08q~+cTcZD4=z`oF7C1%%CjY<*Ms%l)G_;K%W7e
zJZyK(mB8BhAIWT(#jZXIV>A%BlevSHFOe}9HE3B;pbL5UWI(3kJwYKrly8hW;H`LO
zWL*F{RDNIEf71zQ>^+SbS$d1eRCJe)1F_9KFp}hG)5?>D%R;!+jr-Y2fkEd)+q}k;
zw<HC30%W!KSqKnu<d3<MHgd(KW;!JP%o@$y3AS$6HY@`e#kWQiwG*fWI2*9;&FAEe
zpZ+gd{@&|Sedv&{43Z*p6_3i>37te1rWd2}3=9Facvmg>MCQH-OLFZ;{Cep$6&PGO
zLcaMoe=iqYa=Das#wHyr^icNU<8l1;`5=(=>+oFGu30S`)~yr5$@nnrcsW0eWByEB
zR#ql6F1$qU`p)-d*vPi4K3ti;D1HOB27ZFAfh*?C(WQXsz9?wpy!-(;Sb>1R;r01A
zd?I~_CVi6}25g>pkl5vGN)~a9;h8YsfX^l4ECWbQH^U*xsWBI)p?+C04&n)wot1+n
zi&JOw4&!sdE|rUSekvYIc14^4Xgia@Y+cy_;O@SdOPl8B4uD=Us@4p^nw2>LFwBJF
zE1*Y!ii<k{Xu9zW<M3h7-gGfdQ^GZ%v98Bn`Fd_~Y+-kB<7)Z%f%{~~%B3>#(rcu9
zzk$-=){~J}^aRZFNWRojd{i*46kG%XyS8kUcOHLGjvUw<5w$}FOMo{0$4)p|zI^9B
zGGWqWX!@JASMw}vm8JnBbieDu=HMPhm?3pQ7B5@?E&g99`c~)?oN&^~s!PCW{iI7i
z_o%UPr7$TvKsVvEv!?5bgZKaX=dx_!{3NUPZ~+oH44s{KpLkGu4ICo92M=|9Jr%ot
zUnxBJB*M#(L{BbPoWqlz+nft^+zQNh#Wc`S-pTYKe-nrIi|<$=O8`uecpV+Tq@T<;
z3>Q^&^Y_MdX)cLRhSSo7xK#R7q)C<O3iJG3(ai4N8nS6Em?hyhJ1W{?yIkbbIsmlC
zi_*1?qY2;)Isu_$Y5Cl9`Hq&o<@z08jP?Iw$f4_r*rqb>WT_Z1L^@)xHEr?pLph4|
z`h%O+$?nB-W#7_y+8Jo_mK`UwgkQaXkF0p<aoM$YrA)c@78x||B<YAXL<-+GCiX$-
zx9A=UpO3-;0=V#d<(9t>o_$=lE^puRmk@iw!4q+i&uw4(mW+g5exCG3Y1275yRi9M
zfcFSPp+QHCbhR*+^~vlHbPM0=WlOX}@w0#Z7x~IP-;}ARpOLN6@A)xT6NsURwvKpi
z6Pz$<irjPW59OiX{aWU{_qK~}_nRPrtt%GG2hThv7u<RewgzU`kCe5!Fg^|+h=nx{
zKk74Ii&roOA4HR+AZOC>H+aDU-WqR+JU`XWPvCrH8i1Q~<j#+gStPyiiqYr{mmB}*
zShld~!*pSOX>dITHEO*!&3;YDC<V^2Q&Qel8rr4<zz4*}KmH;Ck=6llJ%yBFw*snX
zKYs);g&e#}@yvoq2R2|^+2_3jkij%i`MAk4^pYE-I}Y3_?O3KAWcIEp3$D?0MTej_
z_VEun<2>2BX1T0+=?OWo659NSVEVI#-0tNI<jtS1lkpc{D<__RsdVYpC-E%!;l!U#
zEMy-FJ${Mx=(sGM{hlm(?RgxmQGmiv3*E;TiOqSJUMbh#iqjT{4D+Kcl{tP?&h}=*
z=Mdo|$aM-1A3iMazVVv;@fSan-8+rm3{Cp3U%gU(f8S5!$dSWx<~cYvxFZfLu`c4`
zFmXRC9te&OM~)dMcYgbOPz)@Ww_koCo~S+4s08@UEP3Zu88~{poP={YifF?Fvi0)z
zfMLa8cm<S7&{!Oq>q&x*mdxgdM%B3J?Q?nL&6~3ZEGcIjP)Fo-enukk!sksCMA|ae
zqn@m<J}N~p!|NT2!15+t7A`;ppwu5aD2LyDS<242G;09sc!u-_7hrfacQ?!cY;e@A
z?z8dd)`R6?PB9$-yG?*ZQ4J7Mw=|3goZ-IAX0C<QR~>`_pk_`j`<JVwZz_dfj=X4t
zy4$Je$(XNvM|!|=UkQ(z<n$OX>-fs3oqzN)J76TxZ^9IrbmtFb(D_&8J(|*`Z;D?7
zV@eC3_@m5!@vl;g55`qET87}=bzhF+Sw8)XJ}8E_u3aVX{pEhCZ8!DXlt-Yn9kHH%
z<&C$>Etr}gfGOat_rVF?a(2P+5rvr&f3T`bUVP?B`SnkJ>>K}(X4Cq$^1J`~PkHtU
z*o!!b?+TIm_+`Zd;ocYW<<`VO*e3YZZ+u5CyZ)vyt9H0R3DCCx`&bIthG#?BI_G4c
z{O(-5`g|S$^x}_m7WQ!#PXl3T%Reqznjab~3bP<>lD|){H-h@DvBsYXKx6ni?#}nz
zasxpfTEBOv)Z(<!wA5+1kZG>?I`FGq{E2o19KEA;em;B#9e_+PHnnZ$xDy~tLpL@9
zz{3L22_R7n-)cp~1J3loghR0I9OXqZnk`Oj4oxVECDedMs(8pKY3MgZBlHF4gXc?T
zUjSXFLQl{)sl>Bq2w!oIo*aNsJO4JVG6gTg*BZZdU!qMPn)NlMHH?&nEr;gg%0zy+
z-(tJ~U51a9zA)F@5nH=h8vo)%#n&RZn>X<p>4Z}g$6S5`_WhR1x@R6#Jpn^_?7y9G
zT2&>=RBX>>2s!%lS){oy1QdV|0(Mpo?b|CKJoTvT#j-`aYnlYQbnhWo-f**Ac*WJy
z9VhU)O4-Ri5Vgvi+#Qa9qw~1}v1j)#c@7Qx;}8BJ?`eLV75LL{elAt$09=0Ub;uth
z6wlmqG=R-0D?h|~96o|xefr8xx8Eh*a9>Y7@+Ya<zdymKJ(y1d{D!CxaLGNGO~Jac
z%GL`w5;jq+V$_e&o^^;Ptj+@J;fH5*6zZG~K#ZO|fKYyn@PMIm<<kfbiW=(#aDYfQ
z<YV7$$6tN?#KJa9htqZidDI`+BS+RQ$4-D@(qOG+ni82`(uXczSmRJ2wLZITozx#Z
zAVq0=`jbq83^WRDfDV2OkwcL77(fVI262!d9tsp|=n=^ofy!gZq-ja{fN26a#R3(D
zlvejRJpGdXgQVo9Z)%=OtBo>Z@XxSbrX>c<keS3baria==3pD8BZ@SpIac2!BdPW&
z)c3rVr5?%y$k5OyU%VtPeKHO4Mc9&3j5U6KNGz{eyd|Y^L^&5>iBV!Hh2F%-nODjY
zoP)6Kofi_Og<Z;~`K4HwI`Q%^Nk3Q=<4uHRASZ)~N)wMa<*LIP^QUjWCaY(^)wImp
zsfCUIP1xgq?!}i%XKMOW;#SD^^^83e_ayvtaI{vI^{CLdZ`~@7J@5y4>8ZyHlJHS1
z6FheRZ{+|^{JZw%TcuAwEYUG@%iHIb;Fg9rWydx_G+dWo_a)uB_~;*gBYSr4NThBL
z=99oWm<r}MHRYl!^qddMIvo9H%bv03kvTu&Z>SyKgbcrkrZ6bv;b8xwSQZZN^5Hw(
zB*%Bpz5Go`7*lA(Qt=^JL@hu0G%2>7sHi-KX=C9q>jvy*s#!8u&z`A=!lr(tO)Vok
z08KD|ALidon1aW2qOL0YwU<~20FkumIS5zVxKd1mbb-EM@J{eS1i^SYl9B8^bu_(1
zmxg{S3}h0Y7S{Job7eDa(!_iOVqr&<iU*H0yv1oY_({He<R3bXxAz{#b;SAABQLyK
z_TVh=qdTx0;usu1m;sYcmr-Y)>y^zkuR!Knp}PVA@85Y#!x6-WrJu^jPd|dG|0Bmx
zn&U5NKTP%C3T3}j&pca7G5bQ1x;KL&Z*Ur!2n3Hnsrch?gqfDpv+LKakw+i+eUsPV
zsTc6#Umug*yLQSgcYaNVR1P<t05T7pDPw>Ds5l>C8X{6q7vTI$uaI(Bsr%#4{!?~s
zZxik3c;P;$p&A%FoBiZN(tGG|8FnHLX>|i8FK0e)``mGlrsHLA*3!@mX~Ie;Mqi+e
zIP<9reaa|&`+{<$@bYg&W21kj1&vV}MCqL(OA604R1r?Z)Wh5C`7Jfe=SkJ4bEL~@
z=b{PZVAzyX0sCV`<x!zrd>oL~>sLzcoHum$S=~;&$DBFI#CbY;=V#}JBrpjKr7w}A
zEx*Id-$Wds^&t-OeFuPn(D5#~1Q36sAw^5V*y@%+BSseqs(BfN=?j5#<;k=reaIzV
zCPx$V5r~B?pHv)?d7P%fPa2uVA+5fgXo0&793lhGxIka_JS-cHD#!HLNjNm945wr{
z=ko$0DoY#+X%1kj`GdbcBvt$<+FijCsD#4YJ>UO3IrXgR+W7P9i==E|Kc+(jpS@l|
z4&ifP1HKX({=fOJ|B&}ydpV#g93+pA-hM-V|MQ=M*V4FoTCm9~pDmM#U}=3-ubGmb
z9h=jq&ycVG?LWw<6HY3;Fzu9bc+W1G^Bk0a@r^mzhR-|_k$Ey<oWYPH4mlc)!3$*?
z^oUa-kmKmyM;8vVQqaX4o&`29Y^Yf-B+9ygNaDismS8C})2+8h(N@fX*PfIk>sO(@
zj+Q#eBXr4d7)Q7kc4v;f_?Xu{YrswbHK-L5rZ7oCnYPbv_YRY{5=^19ZSNHFPj&#P
zCW(c=wsAZJ2t$LMnYk*&2`}mAOlTt<y#`}}@KcDmC`p3O#S-l<hbzc0fS>YJx@=;N
zvw27P89M$JVcS)|lTOhSuA=y+LB;4TpK#gr(refVO{jUAEDR$HJG}ac;YaOU^^qeo
z@73pI^P;&9)$SJ{ffJ`plY4&fBbj*0sZs)+4ku#*PR@>v2?y0bY1{=O#&etBg1K|#
zXaD-oGJp2_$8=I3I|1Cr_tSs*N99>tYtE1`<%sgujPVowxe^EWz;XgzjC-7P>NL3v
z2ML`pd1^%14&{{qxBaf0`@SrA^Cg%)!R#7^X`O3a^|@F%Yg8T@mzKVg`RTkcrZ70l
zCJr$aVJt5oT)o~Xcbx&?=(?~DgUgSLuca8sbQ~S;WY%q1E_)vSxg6cJw%|^HFF%A_
zyK|cydiqaNxAbFQ^!n|aF`kajR`C%z0M8HcnX=C41fUIUJI5YT%otFz13()9ZC4_!
z$Ivcv(uG1w#)WTG8eJNWJVJa3JN~(F#K+=d0hc<L-y~wq$K|If6Uk#AI<wUHjFk83
zFCDr^z1>`;$%P+$`UNt4>RFh@3Ri^8XBw6#Doz}#M~|9kkuQ4X8L4l#_Lob{S@_9k
zPM15r`vVz?qkO3g5=qrOT0U<g!{_dpm?+caI-(kwT>jvlx8#>U{y(yM>0(EE%>D*!
z6TI*L`zLw#^;e}Dhi{n|H7r5AO1H%}9mJsgt{|M69l>pa-~FMScHV^!-R?Ic0e)Na
zpMP97E?Xq^cqyEmqh!R`$CL04R-^UDrPX(gv_urx&_-NrI+Lw0kK-BA5q5c+%#yLW
z!kiAX8RQ}f@s>1$*`}^%%)~T%d^}sbZkg<U@TYPJYxwoSGG$f{0fKU`Ub9RNKJ;Hw
z`|)eBV|*K+13;aC&;?0DbPQG+wtZX%Xgf#yK4!|@=9%mOP+D2W0$QbfoZf-)8w`7n
znSGkTLtF@_WtJ9iaA`4y17or-AhK|zOT$}ST6r8U<mGUYA5{P)=t-9KZr<t5U51X9
z@fTgKTMWrNR#q0kISXr<@S{HBIBj?U(~}=P^{^b;ZT6PCB<+5>1bA}Z*%x0fU;Wni
zWXSLlPza68syey4ls;?$7pCtVVeavN?ZxNifnWYiHe=gZOFGU3Y~8qCe*4oO%j?L4
z_5xfvTs|(W<+1^XOVTjRBWs5YA1SxM0MR+HchK$%lfdCUJ7HG)N!gFXwe(wske!^}
zx2v3pw9es`&eFR$`dX84kWIoSIJab=e6<wu#0GEJhMZlxICXl6w4M)06vj^ymz5gt
zSK06}(&geWVWb^2X_!^0TeDd9{_)4M_nC*}$f_k$$L-{p-BLRUlmYb{K*xjTYG5t3
z>iI|H;BWs$>K4z=+PT1O=neQD=vb!Exv;r|Fvh?c*mlTt<(Rw89H-l{?>=(L)|VR-
zjW$C>(>f3YoWVMcQ^;T@6j=6TkHNY)=cg4aU!2l|K=;%KiIZs<W<k<A!y0GPW|uQy
z8UvF##3JJ_jgp$(197VCmn+PlBllt$5NfI`LJxH8#n(vBA(eW=*(K$x8|GwkFc?E!
zgAw5ZPW^xSNmH{wF6n7yamHm=$u(cTO?vh=vo=P`agBdU*E!1DhXJ@J;`9Qm4jhmd
zpL#+b`t^O#oAUZSE_sXj`>_7}+n@Za97KLIFTYYMx(0&@TR>k<n`>4$MBqmH4j3di
zLD8@rmM>p<^0B<z6kF^@KIe?qfBdd|I%2F$z2bT)p+OmSMzH)%UcuYrDU}94^qq^(
z06J_QKT%0$=bN2Y^K(j!+0k(fJH`c0uZMX%CY%N6e)h#`FJ=F;f0FvZ>R!XXopSiq
z$K=R+&r5OT2~sj_loa>Eju*(2MuY12?v~oM%cO48YH8TJBdg(ec{I?-(BXs7tg{2K
zP@s;;`dLvr2yVLxcNBw4{)5A<fN33o(nPsiEogQCxaurD8wxFp0!Y`8r^Sc3TrhJB
z<I=(oN1x7@Bbm@d>o247InN^xQH+Pp%crwpPXmCx)l4(YQ4T)y0;xRpEcC&m*FgE&
zJhX^_{daEho(2-!xOAZ&FWf%$pXY(vsLs%Uzv!A9<kD-uB;9a=o({P1VEJs_D1m!V
z+(1m9Iet{$pwY0>T84<&i$?jG#~zl~pMSbl8-JUlaGT&Gzx$=^+q*}u`qIt96AIIu
zE3?KS5Qg2oY8-B=2dqwBd+QxI<fvSpf9xSSj1gJ8%Pj$Z?+ageLI#XEL5A2}0eok?
zj6DFH#S`V=IA`-TG!A?Vc9vH8lDA9f0fTUPIy#GW)cJknL2IwvU4)I(`Dqzz^LBaB
zFG7dAD>VO0`wy1A&;40ymSLa*p6bZIYQNMj`amx~7;TCipj_C{#P`(}Q!Caso&jJ7
zpigKAz)RKI0N{Ltt7nXmTI-kA|F{DHy+JRKAg?rB5S<04(TBJYX5z-e5lxcPWKC?^
zmBrYQ`wU}g5D3FcN<<2ikWNV=Vl}%<oBmC4<%34Z*qK*J2iOx(-uQ8O#QE3?0!SB6
zpKkxI?eY<flpJoK`Zof}^UKEndhGGP{Q8@vD;s~%svPm-DoG}%w2j2AyluRRvp58}
z2E1+S7I_5w>Yw`a{ld|CTe+i{@_ha;f0l=S`zzVDWi!g3{f=mP3%EBG0(zL7O}PAq
zn`G8k?lNalwAIagPV+g6?|t^;56A&51(>%YdN=r9xy!}5+jMyM&M{14otF1KeMg<g
z50<UMJUoBHHo-u11FrBUrXDklPRm|-v#gf4^AnlGf~3Lr6X`T!ob<ZoJJR{mFJl~>
zt#_u0*zh-{@n<4*Ch8CDGx9@F^NaZoL*k@EcOORGnrjI+$*q7ew?Fi;ZM~BF4uDOZ
z-kmRibCXGU3^0ypOuh^0;!4M+<=H4D2$D2uVSXS<N0hsgarwh3%u*6K-bp{Lz#+}i
z{rlwbj;$#ivr$yQ(y4z~66`s2gwCWSC8E6X<MSZkoP~K_`GQxTlWmLIr~aL2a{0ab
z4UjK?<6fC@3HHHbs@utx^d1J_DrJLrT>&F-jk7fMb@j4w-5R+cTl8Le`iV9f`6us<
zOFwVD_>AftY=q7M6+yM!?v;}tS^xkb07*naR6b0xaevXDxi52{ym69PGWE+~>U!pt
zSIcep{;g1E?Jl<jI18|S*+MM8Jug)LbaIS<=zUT-<Hyr@wo%88(|qCfI8V|Dpu9oj
z@<=0((I`Q7Nz&30SBs7g?=_#x<{whqykK~(6oz-YUwEx_zx#hk@v!l+<>xR(Q(<om
zD9>%BMd=bA2f?%j&~`3%&|laAAk4@R*LuZbFDyKqAx}<Dc#ZiX3r9;_E;t#N7IwIh
z2XQf`im)F6qd-jhg03vamRaB>`2<ng^W3{(jU3s!Aw=he2cCYu428L0XNA!72jJj1
zgQ%ile0_a`Y*;j3R=oXEoUA>RC4s(!hRBWgd|S@C;36H_s(h`GLs@$mfO~%&v#1G$
z2~w<yu3oWB{)oo^gV$gFZ)yBpx!4JK|FxIoH~;x>vSP_%sdJqGyhZNM(dzx#oAmdJ
zNDl+xeRo2gaOU|J$t~adzVwEEK)cH=0WP~OdHE?>k8hFRq?4udjdY{*4)5MChGVWN
zGXQ9mv(kf^&x0@mX*4?O<N9|2?&yY<QoR?p4=k^Ae#|UlMlcAP2q1{#8h_`LPL&?F
z|4=%feYs>h#&*R;OaPZaXuk@DC<n{{-~kkxB1V_N7HlYT#Bi+`;M5D-crX00vFAcC
zx+87mXa<+Z&RUoCz<^J~Ir_B7H2M%1!sHW%35Q`9Z*a*NL+jEwpK0>CY&J^n(t96(
zsX)`YDV@@Y)ZkRA%^$v5@YGdV{~=KPn+2`^Xe3I0$-58p2w_t0-?2^RV-51q7vv~r
z-cxJ1!6V1W?ce{AoI3qneB=Dcqo?X*%9l=ITL2Fe?=Bn1k^i#ApQ6G2SDE+zJFQXV
zX7T*=;}0<#@e^4*f3DQH^;K}vd$IS>=zZFpDWMWf*-km*EV=WCe=ozwPiR(|j+aD7
z_wSZZumfj5W&ruV(0REhV2$)Yw!^^ZW9ib)|M28VfDJgB6PMOC&`B~E);HhgrAkGO
zjOtyw+8vu^@BG<j7J!+-`8)$yBN9K3E`dh5Gtyze5a~ASHYvaH+fvlO@|b1=s0c_s
z1zWtpcbKRISr{sB2Rc|0WvfA5z}c_CgdG6(3aFNxRmN5+3QxXc?<d8j7a$$$Ysr95
z4$6oE1R+fbJ0iuo2<yA*+XV6J;$5P=ew^5Ret8pUBva{y9|yZsTpQZ~CA>WgK4^5B
zjA=6HX^y$#M(IAN(oX$bP62QCAt&>4H_NI2MQ=PW+ZIN~FkE@s{YU~MC!8#|efMu<
z{K-@BeWPzp8GAXqH_1p<D{dcWcsTjfXWHuO8ksx$1Nqgz{WJFXFN!j10jLNHq}-ZF
zpI39-vITSHm;d@t^6A_;Qd5I1RrUsA_W{N(9Lj_F8Hq$+1<%PiVbUpb^Vh#C>`1k{
z+!ENabiOQxfgqaSrhJWyLr(6|I|!<XL`qN>4?5*cDejcpFq`A7zH7h(9>k~R6DNt@
z{TRPo0pzpijc4TG>ScNBIG=BfkIC7^g;B&6L;tD#^z)?KT|bi2spsd`4G0saz&Znv
zXZMXMMLeOyW!M2|#tyDHw}L}#__@sQwZ1(7B!?)R5AnSNz^&%=#?c^A5QSvu=u~iZ
zHBtwwOc}m}TGOcRG#J5Wm{VEsm2ZG^`Optx-eee77(eP;c7&M=UvVCe;_@+gw^`1V
z!_zSZX<ZuSVbW9cz5}d4mBL24-_n41?=)ZDt(L;02@uQsJFt13tbX>-Qh%gzThd(n
zABZh6gD0PEb_{@t+eSuq#_>Ml`C0LrXiRf$h7pqGuRWLdV|3h(SAQI=``vi=x1@5^
zXy2gfGlM{A(ws0}3-|_W-Vh)Wr1Zn*!thb7@y>qx4SD3ZzmOeUHUV?&uHT@cGJNbf
zHA2*@cOUe{JL&%ZJ-c?v8Z0raT)aqjY~9qPC5EjV*2(WMJ8|7t@0Mw2&yWrs&Dy59
zOIv0H!myJ8WA$C5Z%KKi@R$h`<*vW|AM)_8ekMyl!9MJEmn8wNkuQ1a3F$v}f()K8
z884Ahtfm~DOv6O33D$Vh;9~v2x?$Vm`LgA`mmB}SL9fbr`W_n|?zx3|85l9<A0F$(
zaNL<qoy64b*eF{b`K9!o^;M}DgBc+zkcTdjF@rIb4a9JkhRdKG1`n5RH{2~%Lq^Dv
zSD(PPzwIIS#$n9Da<_uEX?duV`70@H0btoHH7*aYV~FAmfEQr00}xnDIEE|=Ns8VV
zwKGFUA+W*=T`KP2emU}|pGd>D4N9t&Cbx=kDh0l-$AmDcTsUOzQ)eL!g6leXL6jeT
z=j?iqT5kiaYw3Kcxo4GhgjtRh=hL7(WjGFaz=hXHSM2H4QDTBV>!onQ0Ph1^Hp=ox
zek+HuSG5pVHn37gU2uh;`gdu(ye)6d)8*rctX~C#KXY*?$x)oI-R{yQaN@Kxb<KZB
z<p}Nkg&in;PhBz<G+q@TT_YHF1V~2uDr_;D{mz^6Ag0(4;k`dr*AF@g=fd#Lq-m$i
zfWbqw;WwRBc2gVhs@F?3Ivm?JZ<3GSe^=gm;ThSs$$V#p<jqdNpML(IasbEv&cLaL
z+}g+5&EBqO;qI9T*GPpl5u8CsYK+_poq#8BO5xmhUT;#T#Ao;g2dc3SJ@1)Er3X58
zoqIa_5=QQnrC#{)a`iw&(*X*qW3W897gp~MZCcZ~#LUYZqa#~BPxW2C)^~)u;{Y89
zJV=LX)UR2;T(&;&pVH$J%wSHPE=72+!aTAWm^X|xp-T<pK8m1>S3cu%DH$?S4!!V*
z)UBK!Z5Ip~q`(b0%tt!_h;#hI_d6v?gkoo=?PdU&F9-Qv=^*R?a6Ud-lqYFxIw}C>
z=?PMhzH##9FjzIc$VTYEZjFhA?g`rjIM#d*?%5`5w{4Wc*WD#O$4!JWpGX^2?_F=#
z+_SkMD1jZVmOU#L$=YWhmV-+R)4=D{|L~btOSi$pOpD{B1J>ba)8#?Q>)~7O0f3Im
zXUpDxRd%mz+39Cjl+U}*sq<52%#>>}`lWFjzP#?qu|lLMovamhH%uZrm30_skV9zv
zUwZNhdH&G{<>0=iZSyot<G&}Ka++NCl{;kg_!FUc?CSs}GC89n#C>$aQN+VWj+TK#
zhv^vwe|_kFnfu;b1vk8Vaoq1CzqwDiU2x`=*WkDhGp;as1i$untrwI7Adnu9dSc+P
zO1Tc(C~1{&!TW`mB`$$4c4+&jAIq|LUX_WLUW;Rc(Xe;{M)G9CM09vXbQ$T6(eUsK
zXUU@9|F{5QrSQs1g`C22Aig;^OW0Yc+qqeG{pDA37^m^|nmJ24_M?)hemL>_3Cob3
zeX=+vj7|Uz2X({@Lvf!0atKGP*Sz(#+6f5RrNW#6fbpO-m$-E$iQzb4Y+G}{Z0Fet
zQ0Eu?`t?(3-VJPli$In`Gri1+6QyXvss3d!kI_9&!!#Y2F;<%1eE|!j#sp(Ci}0C9
zR)1iR99X^xqprhJf>{wB%)_Zqj>?>?N8?+A#(-1)>tFt>Y`}pON4BiPhZTF39C?=C
zXX-gJ_R{O6155_13wYb_M?L1qD2_x8o$=UX--2U)=RW#dsouZWAlrXq5}0<urE=}<
zUz6V0zQ*ULPQ_?tX{ke07~^3Ac&z*P?3QOA`?Ea#(C_8Qp(>lY`QE8BE|A;4b*~H`
zoj%*-IEQZ(I|DtiJirb^RaKR2ShEtZTu9+kW&5?zP+x`f2%x4S1BVQQc0a}zxHnC0
zS%jQC48XyWPY7pTz?Q;DC<Puocu=;kUyIp_!bgzVCHw+n@ND*N+bq3DjhAwsHII*(
zl5>~8V=GvP4}GR7>)99Py?09$%;4s7Tr%i0ZH839z)tA+dW8J4U=SQ!zgiAJZ>d?X
zwpwb|Etf;<*GLh}=$68oY|?_E%QNJk#4#K?|61ezIVE3OIYx?xj*&XddN%Cd7LumG
z*kX9v`BKEA?Q^(fex3{&*Dqfvvc9mHT%WG_08cLZ)AsG#caTNc0T_w!?YPo4^AOQu
z4lhs9*vV2f?qoB44#vI$4B&JeUTPf4So`6tP=QbHb+uSI+lW!akt#W~e1YtNw(Gvt
z%cTm_`-iq|lB&(?W#6i$vSaQCvgPd;Wz+Ky%Yh}I;1COReEb`mzmTOp`p5}ix=XrY
zYEWBulJg~}=dLtCyC;IUBWUzL#&W}+l`VI`42$taaBL*cx$=6s=BxKe&%S*j+DMoV
zGAI`^cda3dipRjZ->#kV<b!{d*Pi-|?(sfWIgL7TqTKq8@5-Q|m9g>_#21Axuc(k=
z&}Z1bb*nB1G^G=;ZYAF5szWk#<S3n4;F}j#h8_msVCNI#UUS8vEM+Lm@G;}07CRy~
zp+iz<Pbe(tUXBBzT8u`k4jzz!Cr*}9?6RWVC`0urPloNK;$Xl!hcAXgXa^kBwi5%B
zT3E_UbJ_to^&F`fFvRl<SVbHYNCpp~ld^B#`=(%N%nQKP@7XSgq5N2b(=SVL7#c19
z`T9*uWbQM`DlAS2lP(NrFg0I{^HoYlPmnrH-PLbdoBPy1?Bg#v<s2CGp?;lNN&`@^
zYgqBAG~j%KHgfDWKZp*%X66@m0LCDE3$FOwAgNl~;f>6UKShdgT%)Tn!%8p>b~yU=
zTQ^GGY;*v)=Kck84N&H*-nw3@&>7hO=|{5nlXqm_f)Ax?)nYliWgVuOa13Y@96!>^
zD{ht{r((?vn&_0ByP}W9A_Kl`uvk&6tfAbp92&-}Uw@`xyW9b*FEm(!DZ`mJ+$xvc
z@MY=N(-_gD%qTeZ!@Kvmc#MWDiVf@5O&hV+{X2Q*rDs~C@$ZD`_nW`=Z8>4$6m+)Z
zd56Wz4`-w^8s6@`ddrdp^Q7uPdZUoWgEIl^RxFi$`}X1RpHV`Kh%tv+*HygECr05Q
zj%ggO6V`u+phMDtrGeFp7ZyA#5zF@r9H_$Jp#x?BdJY}wl~DcdTA5Oo$;<b)Pyux6
z)>C(L>_H>z@t%o!zx$keu66)CIuCD`7gN?@x_r-^cX5i|u?^rFFc7L<vqX+;S}!Gi
z2TCzV;HdMw3(Dhh09Y316b=zKLQ#0XGWdQ<M@^7S?}1VWrC6!Lp8uqSPFC^MbET+P
zU&KV;SPI*eyfFi?4l`@Z=OwweR+x?E6X*b}VFoHK9u5F_60R@d3iSdIY#o<588+xE
zNBa%{bBRP3!D+bqEgPinqt{Yj%+@LGe*;%H^kLQ^+=QZZJK+==H|tjEh&}%?;gSbi
zd3x>w;9y6~25Hy2)iURS`=t87UZrpUF%syAM(Cm&Z<Cp`uE(L4Js~n9PcI)EOkh>W
z2A7O!kj?AX>e~72*Iq1mz1`=R1DFDB{EKJZ0FC@(o!HB$3FDnRcF3wFpXSId9nJS>
z!z!G`zI(R}!diY8j4sXFX6U1eGEc(~Qui5<p7%3k#3(FlmCIUei)^0>FtXHN2x|Yf
zEz)=FNz%DTFEl!4R7$x;vW@}{ANm|TbjHYfFLs@z85zsKl51}$<5dh8jE<O@)rs+D
zPH}`UAlKSC%UQj7t;aPRfYNH+j!klS$vmmYsJ#Q$@5!HK3SF`&VK_ewKAa60I82I1
zo*?yypzufKbN4bb6UeIgWNe|-RrD}d1Bd*xV=<tGPD8_zIcZU?fn#x=L<d0E9JB*~
z^?yq1WL($c3c64TwT6ShGLz268p|lx4rwmoBTIuFt`0q>`h{3SvfB8qQN+(X&ysGv
zWE{4(^uQ@sUdRw2W$3T)BXPoYH;(X8jPyQv^!Ks{GZO7Cl0X?WhA+M4PMLA})w(Y2
zMCWF+B1%9u($V-hAPkPb4YGE{a(U<%Kb3_azT-)b73hFz(aUeVMMjJrkIb@4PyqXQ
z)x}1k1|#}8@4nfr4$5Y9CU>C&F>ok40XPpqch6`k3UBzsLYJ}=fTaaKj}5C=NVPqd
zHKaLS;TrCgg2M2C6DPs+x7lvZHj7U*d8v$o2F=Bn;QcA?+(mZcq|f@q>?7Z%-q0<o
z;L;*oF5Zq;=(9ZBGIs!tHb?O-;TmuvU-jxGQVrb&p6XZ3L66hLu^F%op$o&gU{4QT
zMcsNx@tBEF+Uq6t+qYmX<A8~Vl6CQfY3L*j^?ja@pXU((J{~|lW^5W3U`eEH9J78J
zZT@0(0!(9100_<iT#c*sI{=(onR1R4!5~etUUJox^C=SttB*IW9$Vk)=fB6Oc9%l}
z1JA!&hE2Z^+Y7PJ6g2Mg!elxXsQxGyJ_|?3y~V5Fe_d8V>5yAo+MSU=H>?X@bkl7(
z!~QB*vQE*Lg%F)Yoo|F|(#LQ>aogQ0j9?$S?>}Var>GEvirA!R{%?1jvUkNzU(v>v
zT#|X`<LoOaM+5{rIBcpvdi#xLD<<y1$Z!4XRWe{`r79Q(>>U_YqCp`Xs6J%m!X>DD
z2UZT(_3m}cmtxtZY0G3j(=Q-U1&f`XdiR$egDdgutYWIY&v=7v<Vl$t`C1}8?~XXE
z=ID_lasbPau~9D=a0Z|Y8$Hm)9k{p$6h?R)_+qPK17>dytzLS}O94I$C<xZVbnuat
zOC$puD<zzgNB!rs1z`v?UHG{r<20T>&fz|3y0;iRB{CSi)}yn*V}-Fb1v+h$aJ~Qr
zTX|d>e}0vmQP2)RSeQI~jxmbGcox?J-vJ;)bO26;cNMPqo5IMJcGv@-nT!s=04k>G
zzt16jl^pDR5)rOLPp_U^;96N=nKEeQ_s7&vzoB^OBc)_Or4;pq!U<k3?YU43`7@}8
z(0SNc8GAjBS4EFCXAjHDl9f7T>Sb(!JsZ}_+=qT8N1<%f?u-N~pyYEIPOCd(<|Wv=
z3#B6`H7~qCQbDB{i?#uJ^{6<Oz<lmse*a5Zvt(hjM%6)%S>TXSV`Tb8mr2KCoc<3h
zF6upOShHF-LIJNijvbtRyLZY;EF%o89HB=6yO{u&Pxx7T95X{iEKC$GnhqW~Y`Bzl
z?S|!m#qFH{$_kDhcb*p52TK8+P!~{EdO0B~l|lMAM`QgWG@u>v-tSqvN~(iXKRFxJ
zbIO_01)U4C#9(<R(&yqUP@XM=0$~Yu5gdk6AkFEv)QoNec2*rlhou(EkR^SwD+e8o
zu#@7-grcfTii60!IJ95I=v)+!ohS_*plAtwy3FwLQj8_-WPO{)$K)FQHgE=j1KPHk
z(XL0%&*7Sv>;Oyy@^W0Q-vPkOQ*`QilHr;OYQnIBY#hc60JPETmwb$(wy@)9xm#~3
zJz=VJKJOZ-z{yb+XI~=ar=2Gir%adf$!ALWDQ5vbTRKlZOFE8+nb$spP;tW!G__?v
z1Dyfx`5$#7wxf+cF`8nvGNx?xvSBa1ps^xBH8hDAKJ{nW1x3Wx?qvBge8z#!Shv37
zj&I1c^Dcz(oHBgplw|boIuROdgbynO7su+Q7TW7e=6!;Z|G&$I<x3#uLaK_U32EdB
zCz*2yxF@^?97|Y&Z)Cubp>p`}VcCdj_vSd>>%qNyU~TYI>DhmP^yxoPmDNHKIBBSF
zBVssY?C6Q7AuY}XR6rkNHTbsA1ehmN1Kpi!)KC3RI2nq-W;9HB`3pjHa@7>EfRS-2
z6yZ4X-MttyR9FI1hZ%()6Hk+_P&5qQcEDhe;Gy&>IBMFn6Hqo{JeF^cNX>RA*|k(1
zilv3xO{?YT+7+nNdrC1byu4Zz|C3Ut5anR!`*aFm;DnAvF}4dzpMi?u%mBalH2M&i
zgd1?Idc!Agwp9m!*}sTuj_&|iCBU<QyaZQNPa)7Mt{8U5PrCq`mHmBgVWw%Y$Ki#o
z<F<*F*gNTJfMYErbrP_y({cJ0QgOwXrQ$4{+%|HYlt7cV7|LEnI6;aZPX;d#{UVr6
zEx{~6$Nqz)jC*cj&!A-R2&p@ARO)d!M~l70O}sDm%KJ>eR4UJdMJpH;qRcqHca4*0
z=Y?r8mVjtZ{cl+`PnJIZN2xzXEnT1A=N#yQ_uz`#(fFTxkvDIvFK$wfyw3#A2ZM)D
z3%mZG;4q&@e(|5O6I0@?(fD(FV*jDT<&-n0OL0qd0Bo&AuWR@2GU|j0P=4$so7S$8
zqlXVQ>j_uk80)3;KM|go*n0r9xKU<TIjV2J?-&j_xz9e1H%5#GK*_KxmT9;<pr&0X
zK!tS>+UsnnyP~mmFDPYK$fXY!?=Ecv9K_7cp$)6e1HeP*3MJ!i!^gyw01M&iX$XLK
zDLU7kM~>IQ*HN7fz+kE+96A&A*u#Hx@my@>L;H{RMh~E~-y*YjE*G4PcXZCDg;^^9
zWvud{qo?m_LSzy~1<|m3hcwK23mt$q+118ku><gt?*LdOKz0CT;%faF08AqmO=AZD
zYc$sRiW1?xFs4cBmdr&5poJ9E&}f!mM?%H*_eeSRwU$DGM6GDyC1E+-#bP>G-yba`
zXpp`b26j3P8Ybl@Vyjj6-co~e3K|ZkY!@MuR&*V)L^1lh+oc@ZyO9vJph4K)2hje0
zP$n~?#mEe0pa0OWF)g>D6-)a0VO@?j&{_A~D^p=ehtuDYTzL;xh-tTD#qOe9um)S8
zX212S{1wywyIQI7XP)d-bi*{|DYVIt4s1(0PWg7iJ3kcG0xQRilijdez-fIhX*AVQ
zagQ?rU9l$I9|nWeN?el~e$yVYx@FDAj!!>WyzGe%#d_EvID%>5<K5{}0IW0iJz-MZ
z6u9e2IRQa{l%c<Zur3Ak=q<ajEwIkkZJh=UR|}@B1C6r@96#riVNQogRH((6RqH%#
zv~<KY`cZ5dt)rz^md}-uc{n&HuN)CjV64S9yXx&*v4q<f279_`y-n({Xd&!4rQu?U
zNJ#w(+sRI)cg*0Y#W(EPDGeXJ-c}s|mgZGlAA}tMHu~q_Iv-c-cK|qwKK(+;;G=iW
zRglSWh*y{$fJJkp0k)x={X)1*a29mOOKz5m%Wjko{fFuZ-*ygt<LF44x4T@uZ^Amp
zHZL(WTg%YX?f`qzM|W(8#X=ZcYVJ$xGA_{1bm$}lFT73$Ou=D4)P6<bTzR#GLD;h-
zfpdWCaK8KUSDx0xK-#L@F8j}-&ynP{-~6GRe8zNLXLe-_-x1=pt7zqG!j4iSeSl_c
zKYZgAdHgp&lYQuDwYKBP|CF<4NO{+;sab`OKdoX)O=PPu(sSCK)AwU0PQoa#ShhlM
zgw1eMI|8(HxDq3FYV-HU@&XlC>0Ft@Psrmeft$egcmV7~a8{vPpMJWv@=yzyQPu)|
zj(@86?$Ukoy+)2z`A}|@S@O!hMI%|7vF-pH4mGuPvJdqyT|J(8uZgE(07QdB(N@4D
z&(tuGNxZ;LMF%v{<>Mz~R6RsWF`(%*Zi-aE%3kM_&ydo=qs*E+Pd#kL?t%L48>D&}
z>_$*)pR>={jli#$<#5iy&Ug6G&ll(DLYfeE@$?msp9ahtH_UkxXAjurm5`|AVP^Xd
zFLVGJwCjc$0A|C{{|sDVy+C}+J5H%{2>?CH(1jVN!HQ!CU@2w*j?r>brlPx)&AL-M
zpM8-OV>;g{!}0E!kIUb|F3j>O4nGDL{VE=fZwGX2I*k}7M=>g@Yon2L7w995yz*xB
z@UdR!%5RFsBEumN3mcS1*`J-OmdMg4?uYfSwx7KS%kf!&dt!UjHQ)HYoH+G#(;y|q
zmz1RzI!+WLv4L7xF59scme4RFYwf-3oSGjud8+hBW0>~%^T}B&r;s2EVJk57hRSh>
z%*b&kO5edlWy=N_vV!HvrY>u6CSVP8A!xX$Kh7YaVqcRQewGzwbj4&RxEIVa_Zm1D
z%M`1m3OWbJwSzFLc5avMsF%ty^GexLR{ly2N1X&EgiJeOXUSfe;jP}eMQSig?=WDf
zRABj2jZBeQ(xu@%O?qSz^bN`eRZ97oll1hzGHBO#!byFdq1RMCVXAb10l9iCBiCW=
z9LgS^TS36#15&f{Q>opH?Sj3bAc*&k+Xd4~;&3tF1(2BoT_?1l{F6ke7aCBOhS{&R
zbqC;$<O~4U|G5khtGANnZILjS08T@H1AEooXo`HpjB~-%l++o3b!x|;dBwqKx#Q(u
zk<Mpf7J>?0LEbEn%iG~o!xm|1bPVXr!p=k~D#cFNDslt{Ie3UgYr3LNon`p-F!x(Y
zy9%zf!A)uA2Ji0AlpFU7fbfxhdu8!c56XV%SHx=G)-3pEls6mySzr4e8qaCa8=?h8
zBRl8CifyA}I1&bU4?@_qtv~MMQ=|iQOL)rO(H5}tAJ01qaU|Xe`=Q5Anj$4wt89*Q
zm0Yg0F1`e#sR3xXN8|Y3g9i@E?(Hzw?G(mxB~IYA6R>PC8vl;EO|TRL1;<}~{J6?C
z8*i9-Jb+@{b5C>vdZPohY3*us0-&FB9J@Mn2#>&!O`q{6Lq{ku4CRDoWs}u80G=eg
zN>JAn;mndfx`+P|%$0ADGBnPeIGD2ysiV#5BO*1<;<Xs8n843eQ2c^Sn97KySlTK>
z=OELwpH#yroGM^zq5^+#oP7Ppl~RKN4@^_4Mn4r2onzUW<I>WFxSa4lb^tId-*z(q
zAL9OA3ugd0?avv2GjaL)3UKQ<G{8lt&%}B;EvUs^7*2(uq*jMhuXG6@p0uzK){;uk
zzfL-zdj%T*&YHi=hd$psI)x3GI}9R29{sv>Y=}$HyX*i3k;7}23lIHiE!XSp%Vh95
z7i-1I^7}F%!+6+6h6MqN4aNEo-qeGJj(5dBHvZRs^KWF#B$%qkRI+`*R$`Paob^J`
zy*C=KKiRT2$*>0+Q>MdVoM*_Wv9Q~I5E}8YvWQx@6w0NX1}}vIXC2QMXNAhz_!!(C
ztj`Z0cY+>L<X>5iF?0X`AOJ~3K~(N0^2=KSM7ntHHLrkz;JA}9Z3}Ju?VC5rAt?Ga
z#Zh~I6_x|I=1iRc8Z)9ZVsOpB;pjxe{9PF$oWW3rJ^J>SzC$Zvk{HL_9?#1G5YC~k
z8`N4}cQo3$8f+_F<MG!CmoQ#*ZVNnw8I?opS4chd0S;_jBc+(S=j;Ht_mNyL{CGIQ
zCeD<MBbPgkr9m0=<UUyEqw+O1{TmMA8)~BCcEQ@!*e(czXT>ljoI%GX`HiqFbn4?L
z7FN8&D4G6bW1_e$h&=c2kp`Y^(>5Id76IG4<mF@s;4&ajXKbrG^zd~FfLk-*g8H;^
z7+YHEusy9|L-V#E6^)r9<yYT^lcZpYO#jT?vJ9>quF-U5i^W+wrL_r6ydNhThNJ_d
zQtrRSNahF+(rM~+mFJWjD20vc5jWf=ow=q(XUk*)_SfTr0(%0O4Mi`0@x#BuKHt_~
zm-g9y27x}qM#`+O|3F4h#6eYPIFe#BMK)NzBWcdzqi7372u((f_ul>b>lFPMG?<gm
zK2OfM;u<*<`}PTsnlM>UZ`_N0+{dz|jY@|ck&nPBdY#iuLZ{tC630p^i3`GE9N&3o
zrneFuk3$%7?nFnRDJS>UV~gZ^oF7n)<&q&IMtd{HE}y88H-!lC297!kq-DpXJEpz+
z45^g$Fcx(9cs|h*0yzvNyIx}_NJrStr@Uep0(rxrXXlK|oIB@#DD{V{qz)t4{a9P)
zv^)(D6{91Y%kg={_`CcqJ}q6CCKeB!0UmZ%1jX$m%b*nA47~uRsfRvU&8GF*0Vu+b
zAD%AAGB(Af(TBKPFe{mc1N%$|pcUGO9QQC6_!p8LfUAI<nj=BWqM<BTH0^xdpGn4v
zx-k|G;}qr$0F?ln(*eNDL#J7HNGUW;St&T)^kc9Mgm_m@N9V&p7+myA$X)DZ^I(o6
z(D<(1vX;qO%yHVP|D`ucze!f{&v7<IaUoYg4ZBVc8!D33V(oS5(|?xT^V`f6WmK-u
z5Y%&UrCj~>@5{&u*e^|u<D?8(Rx2}8Y)g<vXK4*x_#0yYei%)mvZNv%mDadC&=n)+
zo_+etpvn<4e)6d@2FnFJ`ED2V2I|ltHq~(kVaH~?d)NmxbQH9#G3(V_7gl0P9wrXI
zmWZ0+dX(^qCrc+Nk8ujVDW-aPubWn{l%v=(Ie6q4%mj4uD^so<-nW2j_8DZOLFZ`r
z9kLV9zjCB(!0v$Kc_yG5Yxi|UCDLp33D_b^ML6rcu#6;Cj);o+2r$gq%{nLn9)!Ui
z?lP#yL1qUQeI$oq9j_y{#Fg@39=zYNw3b)!RBXnPm!ywk3>3yI2Au$I*RDf-UW3tm
zv$kO4Wog*8MQXA9i4|rk!Y(SBDt5+$m?vG*k1!@aq=_*3A>~P(nGauSl>uUo+~))T
zY_bDz1&~v4<*L$h@M;E{O90RT$k0-qbz!D?Vd?-ZZe9nV_@pzX(|K2^Q45y`{Ztsp
zBtA84k@Q^S>h6g?@jPCWYgbkC-fP|q8Zr#va%jj_Lh-KzQ&${$nKB?x03Nnwa5$6P
z5HvuRTNloe)lWST8TbhJA1`2c9B6XwcYb6Ve~ipyb2$_wob_@CVg!av)1}~*zvr7m
z!2DRTK@qMeG})<T-xX`DYq37woY??&0yv^Ra<oSG+js8L1@8z~{hIDvC8(8O6!4W}
zj3Zt;ZWkOjdaMi@K1%kYaoCNHOref50UMSt#!Nu148lx+vA!5pyHO)=3ZlRGamAt^
z;<y~p71PvxVIM&i198^-@#+r2dR;lD&npHD(h9@LicP<hUj$@Ji5)yu2wbxQ+n!+;
z-@2ol*2sRC;uSpiPH0GZ3aS5kEaNCI^L+Rm9nSG_e(t!alcHO(u`F?98SKN*G;ed=
z(L++V>Qfvpv`x2jbGsmyG}PI$hpZjS`Dt;)h4CTm>D>}Q+sy!cjJ%&m2cX{V0-%2(
zu4%Z^Ya~Rpn8P-V40i!^MF+rFgmLa+Asnnej$Ulm3;;&U9WTB~N}y5d8cXIF@{Yka
zKrh3$kX=LgnwG7pbsCQ!gNc3>&$OfieF>&t4{ca0b=x=El*i^3m35J!IP9kz?+1;A
zD}m=~isFL`c$@(a@7W<sAN!pg-n=$WcN~TK!Qj(X82Jx})jYqSS;b>y6o7H5m}rX&
z0s$CHkczj+)VL@$mEi^tA1Pg+GqZlx@@6RxvJ<dj<x-?yr44BX4&y0h$5eZUwg7z3
zU0G6Vs(57<mC!)RBxFZNWxPIUXhxklQEKZOWDB&&*|-<tSne&*;y+YXg-!sp!J$0q
z_!{<6gB8cyvVw?oj#ifg(5dP>bcAfCVj%WlACImcOG8H>)86AJNeLQj%FfA2{bZOj
zOyIb8pX=uPmM(~G%d5lM`a$51K)<D9-$59l;F;+&;EX`@ywc=u=%TWOG+~^_+cFhl
z#9mVc4gY2Hd{nal)bkBn*GVmBHgMu$5se2Wl~I*3OA~k5n0S0L<mssdNF9K-=>YHx
z=X5VS0I_X=Gk|OxB|zu^WVi%?3N3W5?jbH0%!asr@h44I0?Z6T<$-<j-1gyk(+^>n
zug9UYQIAu#j;>xNhq2yu1V%7wcVp`bD$U|D@X^s?#KiE6jUUNU^T?Ez2(@qzV+*5p
zCN!q`KRwR5Tn1nZW09M}(?YwFTfT`P3qlmH1}Oe*c>guo^5%2Y0&IRkKF2A0V=3rL
zX!}==I|(Bdj{F1X10FDf3rG|UqGJRxd=QhsN9=4wj`*VDB2|jxe(Pm(sl(HB$HsII
zPBB|F=R;YGY48Ks`B4qq4@Y6vcR!T6Hljh?xoxX%PvmjO)PqQKzT!$mx(3*xLppXe
z$|@?f6VMxqmRmP%z|rc3DaNw1uyMr_)h8H)<$z95qU6JJ{9V32%mN?~g>9o_aV$$W
zEVuNA!Jw_{*Q$j(SLWl%Ke}@(rqBCI_u*zqG?JKsC_jH$+4(SH2zSKH)FCLE9!~7a
zYJfu9Q5?*3aMOC#w<4Vyd9nibd=h+P^3NG(@+J@O@UAwXb9t0YnJuAA2h;9#D;7Y%
zVK26;L(hP-0l}=9%iH<B90?$d58)UYw*hhqpe4#3W1KVaCSqc{09fsC7r<G#a#TTx
zX({JB0KH-y!;C|iL_Um%T+b~ii5D)$C?&x2nmbN8%fE!==Xi#G1UE=E%w8UN<X3X|
zrH7?v(QK(*Hdm?_q9Xu>mparsrO+IunPBCGACorvRlF^W&KzLo<KX-cq~S<aN(l=`
zb$~&Pp|ft2GOTI3JaizZ_mqDrz}@t|jq7Cjqra8feaGiC=m01|U3S-ZWGMEp7h!~|
z&OEyKgHT)$kpeoBC@O-SyyHv}0!cs>gMEx8FdjOcm`?3GaFDE9xk7fsWNLFAmwt9^
zTrbP!eJl$;d{;hr^+lQe+Dr1`E6>ZvFjTZ;?i`&B=?U$5?nq#VH*~JS4RM6iDmaf*
zz$|O<B*0<gPLRW}|4!Y8LT3ZEVdmh#fdeuS%L$wb;G6FF)Az6ijEBYofRFQqW+$Mp
z^u|tuE$h}8oq$|7=F@z^0NigCwkdbVp*Eem=Q%7W>$aUV@oM0m?1097--<<2hjRyF
z4)0klwm|dP-&!Q;zyowTVKxA-Q^X;bLh+1Ci_gLX5z-MpJm(#0z+V3raWEy^fbD{H
z8`ok<qXM%5u$SYO1QHn}%aMrA3dZPZ39xPL0KAO?#X0~i;B<S%zjns7v||V0)N=(|
zImx;uRuP5;@i1oqXbO1U(!xuH>Hkvb9Fz<nYo<Jr(($7o!eq*DEi~f~KJs%I9l~-6
z_KimKj;K(u<%Gs0>PulyVAz=0b}_>*J`3P+=%rTSK#jWHTbWJs9M<0YUUH-Kh6OIJ
zX~vx1i2g+AM350w{9F0_qq4W{&Y+IU^BI5!VjuL(TkercO#5?sI_9jrVq)_F1L&{C
zaa2v4_MBR#W<OsZ8wIuz6oRq*7zoI+;uK*C;8DY#TjLge^nSq&XObt&Oh=zO1ys(X
z(I6_`@j8ID@ui=9gf;s;YD|Zg1d}=gVFl*+$8a`a#%hMb#q+)8QN_c@pCmkFX$N)*
z6k@WM=TvONa=`xm`(+T!5YuRot3Z@De(0NgY|a+P68JcWL&v6TFPI=khho#J702ar
zKpjT9^{9_~j=|w!s3-YqI5~O05nL&@uGT<LqY8Cmni3wZ_8rC%?uXFX;2!=`?*78E
zWil`Gme}7!o>826t}L5#uADrUmov2uw7}Yu4*cp?V3z}Sv}9mBD1*)?-@C93Y1uUv
zuW3Nk0Hw?}?f|@jyx$C$0N9e8hU)@cjaEmXIW~tEEi?687;?ativ*`I9Ks~iFsJ3Y
z=Cl@yCWSgQ)TP)f&%K^}aE>qi5GFefV|}dZ#mA)flQ)P;cjz6~Zrup0R1;JSRe3pP
zmaF2B+M&6|d}z%wsloo)=DJQJC&=I{Zj#b+R?3EVEFaCx<!EyWgZS!pphv#`**{Bt
zbGFSix8R?Vbp6LnkeRoA4UPZAXo|ZrnK?0fIU0af5x2NK|G;l_UAq?!hw6y+RDHud
zt-Eo9;4{nX5TBO>49Y6XWyPlpWgnE4TFY_U-lkQ{F&pr)lwta_7q%=GV;L*f;D(vo
z+AeJH8J(;IHEfZT6^|_L0}Fz*89+llu5%Ky4q?V`#ZkoUoD76wU}qTIqQqQ2E`Qg!
zFs+XR;9<p6r-!x+dg>OzZ5z?)r**mG%pKXWRXW3bc{yyBQ1hKK@|TsFlbgmw0V64N
z=r{|o9}0oByK)R}uv4H0YwHIwQ&5lkzf-@#+TjRA?enzxr^R_(R=Kc}iF*6+M{l-#
z2Y{L4Jb{MQnB~B1K&C6~*I-$|%?5<x2w`7V03kkvNz<@vhcN`ifoAJFX8!`NchLb5
z3|U01DPY$DNDM1U(ZUX+F6{uIH%OPP@WOB!Tu%j!RX7c>P{$bnteF?%C8cvbLqCFX
zR4YzrI{eK2B0QrypM%zDre}ZY#FMNz8V3{dF_+_L7`V_87|l4koVzfZ?$|>gaP6Ja
z4T@_zB6CawR#B(Gbab>V_)#BpN3rg@;xB)YBO6!a%}c(D0i!P<*k{C8x%BRP&9r|o
zd*a2IY@K~XLKwhvy>ZvpE%MZF|4SCV{fewxyg)XtSuNc$ZQiA4Pu)tW$+LI_hyYCF
z5Cv0cIBT(a-5ObsT>-7_4#P;wiUo7!AP&{(4Mn~(>d>IkG;dD!`;)|II6wxV@}RLL
zDhLiohiuQTU9t-^Z;f>Vc+WdGt&`n5cWNh~4BHG%#{|v4&48ZEOMU#raF$Tx@Gf-2
z^lmTeCSaMN3MRadCs&Wgjk+K`$4`W%KVx_)?f#wo(tMilZNPHC0T^jZn+0(E>M`SR
zWc5<in=l*%bH99Uj-R7(4=xLjh-_T+oa>+jc<6&yv9G=`-4dT)QvldXsapg?bf{4?
zcDtZ?_u@=g&O%)S^vd)wptk7%uvqK>#0~>uH8Ty@MYvkO1AyEzr_Auj0VnIYFq{SB
z!>wPlR2rJnh(bfO^sI}ajM76JLfm7_cX=2;1N;3O<>;GF=Y5gMgD%sfpLB+OY8sDV
z`mhaQ6RbF;G<hCbzY@xX&{TCbm5nRJE61sY123E<#rW9#9k{}W3>24$K#*&#n?875
zw!QjSJ@z+D@<oSxVYkGEcYa3(k2%3C*|-}{h{?Pd31lM3q&u;8{p=rpA<JMvk&cbl
z9vr*Mt$Ou<*;vxDpLZ!d{4*p`YP?S!0ia_8Of$kOu!dhqV;LoG9#o5w6{pD8u2`l=
z0C&T*IrS0JoK}26?H7Pb9)|rVfRCmEO98{ijF)YjH_NU~>(f}raJ=uG8`jDJEC-B&
ztpu7PX6xYi(^ohPXAl}^X|x<DLl@i^I{_QHW%4*P7NiP+J^Jdg!L*q``A{zEJ2@eg
zjWcvqkfWmCL3|h0Th<~)Zr8xsQ|v(KGI5%)<KSGFm&4J|!UyGYbfl@lOvd52p4HL1
z!?%hLZG9d`Uk`=Z42%$ExTIk_GHLm-Y|e!+aT?yX2^|3J0>JWi8#rowKZi??0}dPe
zBS0q0*J|Zy2<(I>GY!LOa0Y8uO>%Cur(b$@$}kU&1%jp~3vms68L%utM?T3c6sNIP
zxGYOEwC;<#^pL(6T&3Fy8*MF+Df`MUZ&NND^$WY%8((_jxNH1-qVc~7BmZHX_D4r8
zE*JaU?DJzJ8<&vA;4B>?wxjWV>Q_IJ6(7B8pKRpq!W7|)fB3mP{_}sAjc7D$(dklN
z%9p&u{LE9z9Usz0`LnVqr&e+sI@<MLzjUEI^dJ8$FFp1UZ2jZ3OH^2TKjFQ_?k~Ok
zJ`Kw6BtXTm?tS~oj9EA6ISGZ{+73L68jN1!as^)%Y9fD2WTT?zqUFF>g(bQn<0i-@
zU;DoF!a4WHlcU!Drq`cA1HLg!E|ix_(f~QdLVF~AW?U-8-7!6$&!PUS;UEh$t>LrK
zBsPyMyi%Iy8WzLDc(&D;U2QnDKVQx*7l(UjSop3~|N4JR&ATrl-$=3Bm#NU)&>?C=
z$Dsy00qVjIfJeH>R`anQM1>9Wc{VK<wa$b}yh)A~74yU}%RQW=Pks(p)B}eUVPs#3
zE5SZjRh~%@lb2~mOoZc&{bmWu!h&6<&X6upV$8QjXY!2hBZO+9alPTK7o~bz<D;v>
zO7!`l>Ve~#FZk-WWGEEQxJ;uB4g?j-O524joNJmQ+Imd;Z^sn%Gr#?rto-<0D9lx-
z3W4~=@4YS$|HuE9#UFp5+v;rFWAbHQ?g9swllNVm^OYtj2NKt{&1fNZe>^kd04nWQ
zANiv^_>+H;m5UZa`3sG2qI|Kiy9eiI-EAZb&TI@GHC9GV;$&puE;T<SkMNKzWEO>^
zJd-$XRU3+q;(1UK?KWsw;f44DP#)d7UN*k-3Y3I777SfNc8KzF1K?rKqTsZ_E~lIm
zCQgOx_hFfJ{VEJbqET=7jf9EJcM)Pto({wO>(Brn#rE*#46YoXX8C)!OWk9?klF<w
znwKiUgk^Isgo!g@{1#{v!|^#rpV?L~T)0rP*A9RUwA~B<*0OO_n3I6sj}b<6YhgHq
zl_Honic;i((7UC*<$TWNL7z(nrITP10V9HZF4MJ_l%0HfjE?E~B0HyH7eEK37#g#U
z@%7{uDCs{;dgJ6mZaGXkm!HeW`v4-iL3ZOTf?e-pujz5*IP$;X_HWCu36nUyi{t@F
z8-!3skV{wrsq7dJr2fIDN!@4J_<!_Hqf%sJxo!1w?JR7?mOK9}m``|V9?86Io|?0b
z3+TASP=)uIdHi=cc5s$|{JuQ!Z~rLoz5JZo6JVM2zJhWBW$!g{KfM2tE|5nlzU_h7
z>)%x8^A32q=N6U2mdBSX2y6MxJ+PxV9Lowb@48odKsoNXaTwL^c<&|IgStZH8Oky#
zGsan5C?76Q_CDi$Dd{sfM5n_0p|Dp?BRJ%hpm4YlpUltGAcA@YH4ENLaA~7p4Vq4l
z;`1y6<SR)y8=jA@1>^h~%Gv=q>7<i5EkI-_?-tB2!HSJPwjVXmp{VQtG}1W7ctgph
z9;PpKsvdXfZZhe+G~C<T>9q5t_(bSMva^!nGT0YdcJY^_!{Fim!8?8=Cv3tImeZVN
zm|E;G9!D+|T7J-VJMDbw422mgp16-7;-6ADmp_QufE~sDTu$%RRpsvlrE~gxV!PqF
zoOA2fWY|fQ?Z}_9Fwexv&NL7SoXRYY(~<usjQoG|6InZNc9R6MXY+blvjkg4u}q}-
zXO$ty%jF%T2^&uXbIN-Q4A}g4yS>nP`0IWDCQttE=TLxLg-Jb3i>ChBdrZB*;Qo0-
z97W<hgr+#K&3?8JcGmND`IFvV#OYrg$K`-Z9LRL;SHB@$ps{|uI9l;r|MFjPJh<7B
zp|YW{@;EO`(6Ejw!zq2;&%UJ5I<9)<0@?fF8&b!%K%YbO45I8<0)uzBWSDFJhhF<@
z>#zO00wjIb<*@ORbS$THAxvB>%$dYsCd8#_C7)9+oDNqP&Hx;C$TsnDc!YVhQEoAz
z03C)y7&c6?1tYy-j=064y0yz2wRi9G;7eQ#<&KK$@0JcTX2D`%Uu?j(oep#eiiVDp
zva9cqinA{kfxUK@jyV$6utmDC3F4$QXdCyv@$1t0tV>~HGE#tvm)3^xVsZ4}a~c#T
zRp~1F7(%`Z<0r&9e(V5jpFdj;F2VHJapJlR7$P&i@^z^^X$smCjQnlS+{-B@E66lg
zV*z=w5#c)X^S{4O*35Z7=d^!5(QaIct)E<{CO^xQeD!j;r0?RLAH>sw-|B^Pf%)%u
zoQ3%0)#v1~`+h9*-g`@qz^b6XFIRTwqqqRGFBi{9e0wxLq(?C`*q95SEojZNO!-cj
z2jktvFbZn^EM9RD4VMFkPdr7=hyF+fw-6sE?%?8&W#^|jZ-tE#1qSEk=3vUo!GRAD
z)=6=O#niK<!_Y=%axf6w_xwY$@00f=c?`MZO@8WZelAF#G_}||df<geq;^H~c2<S_
zjs?zOODoIcTnIZ{s!zhU-Hy#1(c>^KT#%*~1A7M9T^UQ<Vjg=;JlTvjMKfHc42Bq*
z=o;28mHNHAB*Qg(WXsVw{`H}SzGsVyr5LALm0$T~sXP6A-5EeVf?}L<RoZ{Blwj|0
zCb6E+yCE;<cza+2XJYtEiVpn-N}p?Pm;IPt-1ox6QlG;x5OoWB&YY#429wtEH|&%f
ze_Wiu86N}7SUb1LmRFwC)4Brm7Z&V_(Z}>#zm6%~sd^BJ%Ek#O_HZDAFihdOm%>R0
zYyLYi?f=sKzm#=N9QivI^w%z$FS~bam%f9C1ZbPND;r~C<q1d$S~@nk%NKki`(V=d
zv*K8$^^4}oW9wGS^lNUCGcUPHc-8=2czdxh#jO<P$H1oHE^0#OUORYf$ZcKXczPdz
zhi!iUKY8yNW!G_}3C4R>g(?(0;X%TC5RTq^??oq3-nP`;)7>+3=IrdAGiU$pSu;JS
z&GxFL73E2aq9juE6ukuv2+#l|2m*xn-W5>(z5Tw(jC=Fmci*d5g{mUJP2g2#Mn*<P
z=DjyfWMm{!T}duY(>-2<>*JIJOkH@kT=iG~SzfsJpXDediC=Wbes0H0Ps;FF3vj*f
zSZzPHOZ4+?!+634a4vL4Ty~S}#@YWO7JKDfvAIe1)8HDe6&{9#PQG!7PS_p3drDzB
z4C@aMu^rFi$P153+uP6e|K5LCAu4uPxMefspV^Xe#EvzE)cQJ12|%PNsS*HRA|(Kk
zXrNEIz+RK!fu~wRi%d375+zEbSe}jE4OiT|4YS0L^+ho{=7(eqrane*UNTV!aq_^k
zE|$h~uaJg$XG$&Y7f=x~=))}^X)#<Hk0B~yz~w+AF1lLAe*eEp{lW`F7NT(d%tbN`
zM`cR(uSp-|(&cDIUkp7S``f+j4cO#f8`1nC2O4p4$0gtT8<~o0boEYeZ6kIfz9Z3i
z+-};22^jDIB%C69uKcOdzrKRPUp4J{5T`FbhRNMXTRp*-=M996AIv)v&lgdB*4$^`
z592>?KJ{pi_y2kQYaPyd^Ov{^wwj7`fzyI}GhTi80eR+uU&>)fDU5IR@h7Sm!f_hw
z@BewY8XW4PEKBCLUQ8>XOIn^@l&&x<&EuBCLji_Koq)-ZCSCr$e~>|=|NkKgXx^|&
zcD?&Lwzk`&_SH6LV+JnKwt%}fW0wWn3JcDbdKfP2$`!FSdGHTEkzEh|RF3jWUP^~C
zM)3Km<1<1)e~?Oa;)v!^nEX9(-@i)hlBcy#_n4oL$5UxMhU%TMZSjgeD+x=S{iwVM
zWd(^0+=LPUZV)rEUmRzJIX-0ABC53TNi)Mmnl?7Y=P<<69oPBZ>r%j({XEZY@+k!a
zID-Z<pR_H^LEEk70Ru1!$7B?jd8|InOJIl_rsuG4)Hr>f4EWmL%E2kK<j6}{sW&+z
z7Wu&=WW?n+`FpjQD|GzKtdtNQhbiS~!v6E#H=d1wU*OPSSTVccYcTJNl|Rp@YumHF
z3}{pNfF*>@7vcB@!UNt5ZT}a3`!m^qPVjggSIBQa^)T+DpC&V*T&5<2jSmv%!-`zM
zm<Jns$Bs718&5wb+t;p&uqy>9MjwQ;+2f{6SMB=Ir%qJMdAtRXJhip9%E7(6W&4J8
zLOc6A)_vNeEsl_fHfUpi@XE6?cG6V2;QCu2%8$F4xRx%Ye?8FBoR4pfQbO?9m2+Zz
zryIlPY=cHfFNQfN|7r+-qA+1T&N6KvBLZ=BI{@!iJM>Ck|INQkGmN)<(cP|>AD7|t
z&X6IKr)yQMt;+eXrCh5Jrw+CqPPyV1*?~)SiqONV=r9(v;4FOWNAE~I?`@g6Kn9GT
zDEYxS?urhyfQd*4^b&Z~uN9ZFbwcD{>}LO8vHasn<U3yGXgb>=bR}`V<FK>QkB)^!
zB8T|v#F`ul6b(3Yd40_h#X|mzOG{qaNI^H~K0xD#iCC3)R|3H7g|#0@`^u$Kf8jM!
zL<hq%tSs}1XU<^e6CQ;T2>FiS9*4MA2d2@vLx}FLgYezPo+r#oj=bh}sfVQDz%$s-
z+O|#xE<8_$Km@199t}D0l}f;Xm7yqzP_bs`n=eRPFI_(z6n(-42jEQndH4K4W}JPI
z4mjH3TjP`4=;2r^Au)pa>I6yqq1^V$?|<DZgTFP_5hyA>3&TORKlpo@GIzeagTQ!1
z*)cl^8C)~FNHYfix1W7dmOk}}ku2+TWzW6q`4?Ow({QA1*eRp*3gE=PIvR;(asVVB
zi>3eoAOJ~3K~(L8q^KEI)OJF#@RN7nmJeThUT6WZ+%d<p1^Wa}0+v4agv>klLK%*$
zcU|rLUltlcTsVyTE+J0nDunOHO#*-j+MayuE6hQoG=(|Bgely^T&p;kzDGWtIGoJP
zIOih8Uvl41<rr?$`yxA<_1*dAi!j?e0hjm;wC-B#uWe?P_YFud@x!wjJo9vEJo|Dv
z`u6ixt#Y{~(6aPJX<7C%Y_VWvji36I^dODDsvIYfm{d@SJBJI1aB+kiqzR+#7LGr?
zWiy~2=D#VGhD)?dHH@-eJywXXrhpP0ZuRr0E}Q_cWxJTB`CPr>H9_FOhtXZf{t!wg
zf)%nH>ZZv~&LUrV0+#~Kks6-y4F*tSgAb5Jm~U|UA*|Xk^XUQ)M45+woqa%!co;et
zNHm5*+}{BGf&*_nCqoyVCwVi=85HJdxV-w;r@3Jwrg?b78aW8Fm_2Iafc%LbY#2UD
z&i(2SWct|`s`63PK0%vB?ZkjKlutC|pz)63VxQL`#$LMwZP&|gH=fCp_x|5<G4{zh
zI5xm=3LW~%q%*z%rA_`ruoeFHU!IU<&pw8}i}Uns#{vGdISb`H?7`1kd={+h4O5fE
z`sQ(<472${IRT{=y&(feV&DE0nLK-*oOR`Ovh;<gWyNbR$T28c^~4?Ay;JW;7&dy0
zz4(dpLtZrO0XhJKCzSwHQE;RK;Bk$vn@G4=2qPNfAuI|5s$u-0AHxy$kvybJ)6cpP
zrr}#;$*=!SI=Gej1$GB<PXKv9hQIycGtSo=1Jl*iHo_nEk!XH|2S5#!<Az^wwKRY9
zt`rVedGjd81^m=@3kUs(V3h%!(5jg<TWV&^liJg!OP+VmurKAf0b-<Ez=XFGHZ3|K
zQRrL)3B^`ylLFqO{*nvQjHBskzBA)IKG<6mk?NWUGoN?@fN7F*xDSAv7~jHgoCo!-
zH+Z<@&b&BoICO&Pez06T2eC=<{Wk@dn|Gf_-hPFTw+52{z7)P6jLNn$>4#w!lm#Qu
z@Un0cX%TJ=WyoSV+>liZ-GD)uHP`c{MTeenK7W`;a~lDV+<}*S%i|A7OLs0zN)&YB
zM>s&#VE{e*E8mkj7vbD7udSuiwn#NdDjGF-oFRG$97G#%!OWop&@RTRJ?i-t_xS&C
zK;7`s2e5m;S8w&JZ)^<2<Q$}3H_?vHs0sV%tCznc&;RaMvf`zurK7@1VE}F@JNKqL
z<l3)&Po~eu^{!Nu)t8%<Pd7lBdH}x$E1AK=hpXgZ?Br>xyx7F+N^JxzlQj*dxz|aj
zFIHRq_K}4hpoTpl0Y`*a1b_U-%jk={-jN&x>Bjs^u0~s8OA!1!HeD+kU1L3pgINvZ
z4}EKM4QqnI9iqc=HDs9Y-iQg4qz>Zgov@Bb@$?tfQFPzY(J8~`F2)3VfN!t3eO%l4
zM)QrJF#K_8=+m$j(2DoI4T{)(>3A<o-Pu=2<4s?efmhy&<JOC%cKk$GCWHz2K|>{v
zZ-NTsIrJNOY>m|*trnAnx&<&vj4g*Etl$?Z)#;{9{@fUBRh)Y{wx)d_lu^lK3k3*}
zmKB#^o3{V1W#5F-e}jvFbg>^w00?j!&;fsa7DQ)O#L=iqT@xEEGo5=b(8lkP!_2a<
z>?LW#Wfb+$u;<HQ9aNg0m2W=NEo^=WvoL+*JB{bkVkkonhQEkV<e&2|QjF!wjS6>J
zd>NWag&71FF*!Pb+y0K?!iq1l<58nC?*6XKx#Sw$jZm*mqxIEB3tNtjf}cGQA~8;<
zFrVmQc?^J)<}H#D5PL3v_HkMH!jo!8!DZ;3zpYS~`{239<<q5a$QT$anuIL@y=Vs$
z5AMw$!Q|rru1;OQV!7<ug!A=0CtSe|hEnP!cYICGy5d@QJ09vq)i_qq2Db{?OOx;p
z4j4EPQi_Y@l(FOGnfvaQ_3tn3l8-c@<|eG(IQnv6W}<K7R4@c<m=`Tk39K5&qiQ6p
zwMAJj>~dO}R&3-W5QP!au!qHP;P?nV7X&T>4A($vGWXJJFgUi$2e@3T9h2@asyp(*
z64}4_d>MtKeVDCk{k1*fKM{-|Yd32TP8?{<<k)iPU{xyxu*}u?ke=4Uw#vXOZk0NG
zPh8mXeNgtukEdaN)ZeqO<%ttWzNoKIgG=2y&c0MSUjGZOoQJ)SYA1F$xsbLO6O~nl
ze@*8fPI7S-cRxCctfCofH~}CJRmy03fn6$az(QZ-&=?sK`6!tIwwLzVoB(iz(^H4e
zrQ<bR_5)WBC6zq(kagfi+{#G%#La{Oi1$dHr5i4N*9mKK$yNYUeb(qDwe5nChS70U
z93K`o-}1E`J|Mead|V36U)&Cf*2Wgy`5hhnYrW`=Z67&}@WBugJe(k^xRxnW!gDJ~
zij{|q8Y36o`E?lwt8}kF_zO9_12)pD9F&xH6@QwsD%x~#schz%YYhCg5G7g}T@Ct1
zo-6+=?)i?KdHJ<ifcS}!uNOUgzYM>-K9%`y`TpO@Q@{SHtX+x@9DG*eh}VJ6jVBlK
zV8oi*^2TvDsD|)3&7kFd;&KRg{~Vs?#~-5;`3abV+JMfSgecVGISfzVN9fs)Cn-+9
z@&?tRSozokU)V_ir2u<g`-=>rWD+Z9b!Y@@htPM4sWfzu15cYGgD$vMjy(IIq4bK+
zm3{p+cgsL*Gvv7_#0&4HzDe@rk*=(dZ=SjWwWpsYc^oBfe{G_4zWyWzXYP!5;V^mN
z#K@eLQ7&$9`bC}q=%&OW%-@4B$N1<Y4$smN$PLCc|2-(9iY!#ZNQ*QxN=}0`&JlMQ
zbO3@zucE{x3ie$(UV2zsp15B+dA8TDB$7yR%=j>$DNz`KC>+8w!r|<gdF+RvI*X_2
zMer~IIUJnbAGfbMWZ!#lNz1yA9I-Fp-&#!kPKRxV)33f+2H<MiuwAS(Pr!f?#o1nn
zB;pBJIFLX&6K8v8pL?;~`k($+nQ`Hjeb$;B{OLNdzt4fc+QFa7ewW_;ZCQNjRcbt^
zq+X!OL%&(@s$uxnP8l~ruKwzGWlT3O$l)X)tG&5qSH(Rf>d`>Yqw)&I$XoYx0D?L)
zzo$Vu`b)svGwx{b!0~IhzZ~HapSYG!ee#-uG45e}M^3-$CYf{nUBY+si|SfnwQnzu
z6epi4+cN2_T?h};c)8lpb1uPteDCcr(?DC}-G42EF27l7V7}e0#N3qE$~HgArH^GL
z;(e#iz<}%Smf9P?2}v_fjCJ8S3DINWUEo==7Hefwy2r7we;iBYjHc`aU{C+>fl^rU
z3<Vl%mx_GgjA;(H;~lrd%(nB*XQUbDN!#9Af*YOCAp{cv<0b90T!V$-0*o8!3JG5U
z)3b04-=)QW6ZnW&++i@6a|#dAV|Y=TVH{@v8-L+Uz`$QPfA$S`%lzwZlR8@73fe*2
z1+^`K5l5d#{7e)lomcU!-HGe)IS`GV%G(709>)xSh)D;;eJ6-paK#OB)>YT*L?x<|
z)x&)7%7L}J6M<x&9FFx(k*mM)0~vxl(5rE(zk<#bZ0L4`4fxKtc24=^nZ%i|%6B-j
z1HimKKWXSM0gIn0@p!6Y+0&0m)4>B7xXh1#K+L3R^u13h%)%RPms!`{;jijO!WYa@
zac=)>&&V;mEl^v{RWi}usd`6gc&7E^CrKl=0(!&I6no<x-&gxAIZDnvQS%wKaHbDn
zDcm5)jQ*we;%lY$mTy6M5c(yR9B<}C{pbP;neh@J$G|FdT{PeE{~>z^@r&3DB>)6c
zJP;)!+;^^sK?)a|@Iy;DL{pH`I2(HiW?kJh29zkrBIsy}>sCnXga0PSe)BIlCJ1fS
z1N)o?s&)WrZesq}`Ot)A2NXw+zWbUSe(XLu^yqJ;83u=nv~&o^+(sb^dw`2uYK*Ip
z1Wuf$L<72x20B?xsP?`E-G*)J4dn~x&${U=vf%nJNj>(;UA?RCq+Lhu-ZpEqlFps&
zibVe0fJuD*%Rw=4sGI{OyUV`wcT(R|{gYmNBEzACcJ{S5OC!XOQGLjN`seGTbz;5z
z&*~ZamZq!nARmI-!A-%D!o^qJSgM@L^pvAigLf$CB|)TxbpBks#__OxhlBQJph~Bw
z0Dx=s)yE&Dt8n)OwOkLkXS;djd-C?956Uqdc}(O-EY2U$X8y1&rAPYE|AI7X(T#V?
zv@5V0&Cm!3%1Q6qag*r2W!MHnpGTKyi=cLyZ~$q}eCWBCOU>BH0d^09ICj@?(>J97
zC#6Cg{4AHwd>3<n4VLyp919yx4$rX$Isy4B?<m>hH(WhtNV_s_{Exup0!CZY`I7OH
zy8g9iz(sz<Mp_3TF*_(%iC%$YM#&rca%==Yd#Xg29EWY(D-wXPKx_#VK7#ms^)ks#
zm?pJz7E29G_13_;Tplxgim+(iN_z&b^m&W~cUpJg7OIZVV7+Sh7Izs1R*Y>p!`gPq
zP1y5-Xm<EWtzXE$wti4;jR*C!I3JTWO$75i+n&F{kHP5A;pMNPhyCKM{_`-HH0hG-
zWZ_MBWAGp928i%wU_+%9NUUK(JcZ$p!h8a=vh71Wwz1+e!A0oRVWlzW{7Yr;mW}fM
z<Gs6=$x^CyTwO21-t%}E_)#|T4aL<@S0tONRWCa=3rZXP(7m|yYFYix8?pyS8mn<E
zCoGGfySX43;V_*m@2VXhoaR9W%jR;sfthqHUBea!61Dd~dEs%GjINV&Z@UNY7Pgdp
z(e!+<G{2`o48x<(cXQFL_u!q$%Uam;_`*5#EeCO1;P5jpkj9DAqPlB6(EwpvgmsVG
zA5s7q>}ov!Dmn7lFGG}Wh3ghyECbKGJi1GT<(ji_+P8G|EfEn5#&1iE$uuey)?Rj_
zv~Sxe#gB0EEbVgG`{xz_Itrs@D4FpzkjLTs&#`nC$T_gOXac}1fpIG!&OoR&z*wWf
zBld|0g*7foiYP77ZGp|WL(3?cy)_19s47>lshL5h1jNC!4HAKktE7E1E^q-tZV<#f
zc)+TePn`pZYl^(T`6x`C9)qG?T2qt~1sqRoe)6}{jthu}TzjX~PoAk~)L9;%fYsIB
z1^4R2FHkz2`LbXn#-`xve?KG;9lN#=^$X=Ff<F}#sWa~UrVPaW3)W^)z#4`CCUQWa
zXRVNkcpzcKV&j=p7$O0PN$k87q<@OodVqF3j-9Q;mB5E#;`j4#!_bM&g@!)Qq#N4|
zFdV-{eZ$%CF=J)kg_p}~yvyC|E|e?Db*kVfV$$(w_yIV=QCvJ1oopLo1)p{jNGBd-
z;;uY~#pPO=>SLg$!K{y-{v*_hYURwE?~;0~<mr^A4_G+L3&K&DxQJN15%1{y8}AUB
zMcxL9Tp?6+CcTr~b;3B%UKj^D_4d<XyM!ml<N8}0D2#CbW1LRY(auB8x=4<__l9)B
z;8}MUEV}Pc#cdsQ<91J%9hGP0nh!+7H9v;Lp*RiS)Uc6KbJcCqu?3UfwCx#6d$29Y
z@hWs-{t%uB(+JR^{yTVwvbj3s7$3QC3xGhI07M9V8sG$=-2O*K3noC^i{;?lSB{eb
zb}mP7E#}URQow|ufQdl?FF|p~dMO@;ft2*%AM%2{9V?c|q2K<q9KqgMhi-Q`1lB|A
z;w$9hKH}4&7y>RmemSieg`@Xr!cnoq@4RH-FO1K@f85!Z#DjmTEnNMR?NfH&HkDV!
zz}k_!&Rl7+?TMGdWm+T_M|cF3;>Jv$^SQJ$SO3$`JRipt$0yzk<6rB=dZd07#kWIp
zbp(6fdv|P;{kwPJ^wCi#qEF$b^M-M*mS^Cug@IJM>dIk&)hz%|zl1jscJ0k);Qyf`
z)jZI}smA5;j_5P@`Q3B%&&!t^@o(iRVN6W?1cnpnkDq-+K7{qcRvgJv`~WwZKjVE#
zmD31K`Ng+?L*LzM>Tt5*G(pnXwBgglw_<gO+A08~VRg7^br7`nyF2((>3hHh*GL_W
zxCN7U(x)@u#gc!kNz1}f7~aYJ<XMuNk1dC^!^wf1pERbE!no2&6`;2*at!Q02gN(t
z!NtB68A$*<U@v^06YL*#Rt};%0dU8cQj;isplO&f&i$Dj#Ph{HpU*1H_~^>#*1%DS
zyV^Iel_6JQ{~G3gZFOTWg}ux6RIJWXoB;qWZe<d$1II}AFL@p}9rmC8rj_5<{z%;0
zaK@LvCxdXaSX6)C7KyS;U;ua#k|ojHEmy}hbVFK^BLZ7i+c!Rz88vo@>rrc9r(rbg
zqks0s^AVZ;3UI)iy5J0Fltp<jEm^_f+gLAPFx`h+4L@4)imd-|nKbR+i>=do7_&J|
z7DA*y69f7HHHu|9%Fy)X(MH1fne$}bQfxU@aHddeY;v%7&JCh*%tCk)z;Oe54676(
zN&a-Yz`Pzg;iuqC<7H2V!z?_<|Ng_jhH<GuGVk*1w0)RvILeogMQ{Wx9O7{cV91zp
zvgnR)NISmIJs)I<j#=nQ>N+9e+`r@n88``Bq&NjZ7q&y#76!MfY8s>fgRp;p?A=$S
z1D6g}>vF?KW8eS$Xy4z;VSWpj^R)~-#5mo(>oFwe!f;{;LO5bubI#?`0W-yTs8JH7
z18FOO>HHc`14)6p6bCuv_M2-)Nr?i}696g!@;-nu{lXG%b<&Fv{P7vKQKAb1AiWh3
z;b2c*Xn^5la5!zy_RjNiV9Pogbj_VIXz>MVBGc+>?*<2`@C<7r9Z2bk0z25F>pzua
zE8adCTA^D!4xhbP7JudYG6aJSoogfi^y3DLX_mkMP*@Ig%r^P-^%ro=u2p87cL}UW
z^D5_*@Jn&=M;qN*J}Nl*Vj`J}h?G!NtF0b0dVC?SE=Qg^Nr`aK3ph;@w(6r1wya$(
zFaPcrvgM=qqE#=E_d$%m2@?YDe_wd>oiLZ~#NSCm*7h-U05qg0%$y_Zm*eD2rELJb
zux!?>0bQHhlZ+<@_Q-G)3(rRf^|;uwAy<Y=HoEHLPa+N!eqpXWO!n-9@{}nFc<)cY
z(OVK{!MY@k{Wx4VOhmL&bP2aQXqaVy_OJ;P<qW*T?_hFqXzfa0$``{s_Q`TN3O$e^
za~5e`UA^PFu{{Vgmq^D;TZf}|jTc@khj~+JB}u9gfL}Xvq10mgi_U19p9Rx2Dr&>>
zYv;}_Q0~Uqhi^8A1w|fG2$;)MT4CM@fIvu_oo{aZB*{&kC&e}I#b}%W1Qq}jd19=R
zkmA7*Ue-yt66D?kP{)r8{K%yz0G!%zDLEs;=*s|&EYJ!PwJ5vc*m!#Rf*GagM&8d8
zwXl7?H2wa^(!S|483JwL0i(z3Nd_wP*&dSXGTmR}m7RR}Vp*r(fn$pY-g>cbtZP}}
zpMyVa)<QYstA8aUCQikJ_HCgLoy<gmL@;7ANG6PmUTfccMc#ejryAb9Znd0o%U5L7
z#K~$WKRv-Dd3N`1Y_OIFA=0HwKMV)$x4*+MAsUDiFgj6GUbTtJmVadbetGqw-^k_<
z-_68n$1$XLpZEigJCDMV!W$A3Bdc;rMwqM~J#mV*UuT60fDQuqLpmWX4F>=VI=I89
z)S?;}o=Ydb(N54*IOuvHJq@NOfq=I`D!J^TU+Dh!G+g{+S0+b!5QxH_PB_?+drjvb
zyez{pSv%{S|3Q}D_hUJ{ZdJce7|BInxB}W~-z!haKv>?()0(Px);3ywz)It;eRzUv
z5bi#qb-<3*%Po6(pW=U9#m*yt=E5=zmhd56ZpT(d>&s6_VKoNrHY|WahbIT}3oej4
z+_qXXX@*W<ET7S|IDLcVs0=>$%;W@sO5UVd#%W$7;BlfTzCG#REdY+~T;NA8wG0yO
z5p2gV;xWSPivTq5izzM0l7ay!fsq$}ytoMFWOKa2vgMUO%Ylb}Dy=&<EBjhMUrBoY
z6N%EI`Xk`d;iK1STC-A`-+%pNYl4dW4#MRf3nBI&Ic>H+<EXxDm#F@(o7FVJBDilK
z59@%~fBo{ebnvH$mkM7SanaJt|L;G_)=yx=onqju{Jt!=f9*ST!Xh3p3ve?8K>F9w
zLLsdmS_{xuK2Z@}X<L2NFUtCl-j_`uz^rKn*M_$Fc*#rBgo}_!i~0_c&O?HpYikZ{
zgJ6h@`T!Lj+K9t=CN020TGQ#<kNB)dwT?OwoWyB<{L$wb(2LtAF2iuj+3;_LSa#`s
zKamZ~-^St;r<Iha4BCnE?1?1t*iW5;(;9rI8z)RrsZq6cJE8HQ<J7$JEjjY(%E)$#
zwiB6Vz<WOE<7^}6_zY@rgmvKAmth6n;Gq>f+zMC=3w_ao!043oQ9%2;Po(8H|0IR?
zUU3)hP|^TtEHB?Fyz{KI{psh@2`QMqG@xU=kz^QVTpgtc*uoVYLyY1uDX(J@0GW9*
zfiAn?yMwl<kMxVT3#DMi9lP`d0P5|sEl%#^5cfd14UlTOk~RY%4P!h98|Y~p%zeyp
zuaPg}4(L3!M?FRQ{3y(6+#>L!xW{RSmhnOC{dalKc0l7q4-PnGteg&!>8KfVomdfd
zwa(h=uW`b)O<afK1`UHbpMyWe+sl6UGpy>8iZ+Kfu9Y`&o$J1>n?c9XNYV{xp&*+G
zXgNW-{Vo3I^P`xa+ZR!LC_io>b^N&+@h{t8>zYrhT6OOFY&Gs9!KFV@{bD-l5X-6M
z@u)zA3Q)r7_K1I>Ltf)H^lgm9sO^Jr$req5dK^(b0}vn$qiyZrCPu-tM7D?*&s$6>
z8R8^h`5%5In{gil+cC;#G=lP6`vmnc9Qw=%oq*A^PM3vW`;jz^aUyI$Pkx61^#Bx{
z+XDq>Hk7rMRj?%Pao8@6^UlC=>zRgH*3XZfBzbT1f=Hxk&cdNz08g#Y{t=h^lpoG$
z|E2w<$J79v(V}m3vcfq^ox=$WwldO_5~CH;DTU#!IRqUzZ&Sh2`_LylTkzxO5xMjP
zfJj`HX7L_n>a_sHeB77m;$zG#k1H^WUw9PoWOJBF4m=NgjDG7QY;1;IoZX5GTY3~n
zyB&tXqSlWquk22yW~qTb$NaDVjf|gv77Wd}<84uW5s1RpCK1eaznV@MeiRFDTlIk~
z{q2wC*zVE}fCKlTji1Wu*PqAthr7W+(*_Ub*PoSRzQW_O@YR1VtGVb#HsdqpNA&>T
z6wkLp)4v+WfwTo8Nsz1fQ~E&St%;QeX|^%N_`3QJX$Jg;X;jH`|6KXi@Jt-1U*L5O
zv>Z^u11$dx9evh=?^z{xbjK!HdjC&kJETROsE@Xd@o!}**W|;|RUA!A!YC#lJ8!Yf
z`||gN6WuS0Yx``a99ae35<Kg$4OqXhEf}-7)t&Jg^x*@~y@D^4fiwLa`pWQ<G$Jv7
zrUN4#Th>dV3X|xCPnJnx?=Iy%O)HZ=kDucvTXpEObV86J4b;3T0*NSJ{{BA#xD|Z!
z)sI|a0^pAaaF#$xK;JujR5*{so~op*L}M`(fHW+J>o`vuMZlnjHPh$IKwLTz&Ky}c
zt)H)_t84t%g@{v>Hdrb=j2o-EeT*jH;Y12@@Sk(fkK|O`JFX&Ke88-4;)h5g&UC^e
zxXaUtj%erFPvqVEe+tvcrGtN1?=A1WEk~dcAJeFABEWB#tIN;BadM*;_E`U{pYlfj
zkjQ;joJ+69QTv_OAV+PA{9)MDIc{$ijiaqAxkyssX^{rm;x8WX`P}^TW&)h|T%?P?
zROEA$0MG!#%Co0oWkvM>TqiJ0M`8gh`>tFw?g?3ncWLJu90BHphI#cD^IW#f2-oFd
zdrVk#uFSskJHmJVi{QAWd5BVggZmQC&D!48(YF;NNJyliO$IJFM{1^>Ua>iNjV~t&
z%u83v=X=nJ$y-$x_F8Zh77BvqjIPDaS2)(3YV#jkaO!XbP-vLUkU~Eb7$9)$;~g|r
zDnJG~dm7}cyE!}pNJ5DTfTz3@J~m7G$?e(h4C`bRSJH+6Bw!Rl_U3Gwvrz8u@B)Zo
z5cR;`bgyqQVBfR>`(EMdKdh66J%FD3bmEVOTGvOg`tP9j>=(f0ppY~Dwr|R$3ochv
zp{~xTFFs=TFQ_{bD|NOUl=s3W!m{7rD@V7Z1L(pv@7pE&w{3QV5orV8eo;qXrp(Vv
z2jD1f5Y*Ku_=<Q8_%{CO)40vVxeH*t2pv@yZWNTc21C3V=4Y5?WR=s3<8AFwLM`XG
z1rUnh%MJK^o;oprZ{^YFin3Zqjr+3iMVc;Y^T*D-3P(xC5gg%t58DBIH?2oGRuj<h
zw3QxcsZUr59B(p!Oy@P$r{P-N>0kOL6b-A``>uk=&l`n(5hapEDBWor1Ps|XtRUYm
zmP}l_8cb3f&beF%cm-tr!9*eb%~}4mui2?#--T2`@%WzUM9@7SE81u>9)&d!yf`Dr
zVNcHM16alozY>gP!l+U|I*#d^VeBuc0EV{=2CyXWM_T{~_F$$4?aT`Mi5WaP5Y6*K
z4<LF#Wf8kbz+j)p@s2#q|K`U{gkcAWb|}`tv7o~KJ<_@U6DfT9ff@ul-Wgkd{8VY+
z>YvI>V9TC{)q!yh;}2PIaO!+JOwP2Ay#1oPtDuW&o#@FN{3qZ1HJN(Z^*C}x#kQ0S
z8zM+z2g|kz9q*7oxOEdc>R-x1C`VS~Iw10HrX6@Ch#XoT2nVzYVl+bWX+v<7s20cJ
z`uiUErv3YHiDnBFnK5{PIc3@N2ruPwGJeJ!nR3>JvbKWF0^V(~_}W|43Lfbh&4^eE
zz^?Kz^aVQoeHRg4I-rA|8v>Msr;{R=D39$-S802}Vfeq;N9Oah>4KGGWt8|Hfq5ux
zs@5IAJGK15d*z&O{;dr2$1p?M3>)tn_JnQV4{>W@O>*ib*Ge01Bi!^PXxHrk03ZNK
zL_t*a@9`~D_xj{@)I&P*#<MaA{Thw@(785<2UWIB*al&k12y}^=2NGup|#AG;B!WT
zev26h33|k&p*XIxyK+!2%wZp2Pt|x_qg9fXh4boO=x@>GMo&l_0VGWGrU;~>L~}O)
za_s9r$JzR!v;-h)0szf~{<H<K4;K`o6XqUIMq{w?5^w;bqgybAD&r=(nO-#yJ53*}
z{ruufq~_x5qy`$MwEN7F#mZx-1}mew1!qHH<7R39;4SHR^@)m#CFvp(adg@ZIQv@T
zS6VE`UXIK#5^bO(9&hA2vI47rSS76L<xUiSVnsOkPq^|{nSS*xFec(}^9mayWS6~%
zJ`{U0Yz&V85Lb&wv5)uupMEX-K3W#$tQh7hm4vn9j!1*B()NG|?nx;tINmk>R2hsj
z$p>&3M1Q)2+c)bCc8z)iSzIz%cC02D9yoNETzL04bv3>Y##_>E==h0p&TU_nsSCL!
zMaz9@jM6xD3wCeDYPiBTr)gNVkzAT)SVR;?z=bhrFkGbsAi52ZY(_MUmiHrgFd&sy
zt0IK;*}wWj`S8&PV4Ui^G8nfaI(|`xrys?Y6$d2Dek{OnYjJdL`n9)7+tI_a6We(O
zYNwyXu5-smY5Hin495+66q8$9uuA%U`MM?Af@vO3T>$ot#~#Htb;jj5deqRrPt0QZ
z%=cuR2mAcBuusr2a)K21@lacN$8-HTJzbEE6Vhk6$Sdsmtk`$(7<YOS8D_{PsZicL
zD@T&b$raFhBZ<fVFxVzt))oMk<FW(4Dyxzt*zFkhVBA^A^2L>;0N`L4qG=d{;-T(3
z+)G_^*N>#`?!S_n>2vk^$7r<mv|M+A4wdIdA!(?`xzUF2{a4A)I<vc_DL(JQu7`Cy
zduhUYRSLT_9BYBr=+U>)iTB^WQIG1`RVEI+V=lT@X5RE=8Gt=Bwma(>{Sb)41}6+X
zNg7Tu^D&6US3LHh?8cemN`q3GFDIskNEeToofKD*F@2VWe_Cz`cj1B1NS=Nn6gh1_
zFipIV;?0l%?Z!4oBwi<fo^SGR0&35_rkyhWG`aFye=Qe(`|o5D#LpuzsU0(Gfy}<*
zCb{NE|3&6sc8xQ7<7!;-FX^{Hv2fe!kGrfP_sq5ZJb&afYGXtq(SJ|}t4o)}1B7zV
zD27{WxV9n>I`Io=R1>6K|DDU<kPrWSzgkn&_c4R_^6>asv7Ysq#Lc?-9vOMorPUOF
zLgP>h(Dc^x(xwV^?kR@PG7PgKjGJSaHw97(kROfyJmqqb(ALdf7>V>PZ>A3*;WYG9
zd(|D#5kvn{&W$=%YA(M;a`=|b8BNB+u%?qX758`t48|NCdu)Z4g<l4yw0JV9C2=B8
z!F~8=7ie>APq-`z0OcDS@w+5}*;f$`W_W4X+R@6s+OlAfL`L8k#z2UBV6(q!hnZpR
z9Y2s74#wD%OFKUJ<T{G%VX{$E2Z_K;Y54Mwq~(!cNMY5|bk_25?ETkYa-**P!@Al_
z#_}@5zFmr)1!?+lDOUe$%9n8xq;Sw3w%|OOej{%7gFSf_y=6Ce=|f=s*sBL0T^sIo
zUx~qg8<irv>2$IHT2!jb^Ih@}z}`d0mH|l|I3A7K_%koKOm^e=+?J)Uc5C9%O*Rwg
z<ayJ|_hrV}7vVIL-$V8+8lvOdV(_uDA523(xU+u271!&@hkQ+5&HvIQuv4T9@XG|P
zm_1uI$$_mK%U~tJ9Bg%Zj?9+dFv7SC`w5pJRN-^$hk5O%SrBp1BwWkTG(Y*MQpymr
z!Ik<p*pkRYbi4re{u_pI@Q5d{d_O~8EX>!IE{gj|!-$bG>q}pUmC9y02$R9xnZPQ+
z6X*|h0h&IB6adl@zH?e-{INRwDmyqLX?P7p@%86lEzOT^bc-DH75VW~q~V6I%78hT
z0QiN1(W&HfkyUs8l`1vuq}28R#u!ShxN?Wfoi;;iuKlvq%w4Q>Lt2WE`lEFr$F$u7
zI|8aFMjHUWFVb{}6y;1sV>n-iJy>INJE4CZSy_)?$&sLv2>|v8+Mp<~8pzy0ajk_w
zpSqoBR6ZOpI^tlMcC0}H4gg_7Q78=pRXYK|KwN{FVV?W&slh)i!@~TW<4plFk(WH~
zVz0mPYtjNGvf{2y<f2Q*z5jZYX-C{x7b}CAD~6HS4qb#}@4V>Rsmsz%T!g{17Rju;
zzbk{r;4&M1puXl|0~q^+(Ip-{;=VU+gB8hDPyI=@V({-t$LaEbc+jzEd8u-ZHGLN}
zjd`%m2&vFHcYj;=k~ib#x1R8z<#qGVW*GL_vt=Xp_h;+iot53Hz%*+<?s@aJJG=4D
z@`bntGe4cy4*i3*?=F$nlx+pWH=h$demTs~$CaiN$6cbuP0C|*s_~gue@euL{<usJ
zj(BkR;11t%PaK~!-#Knwoery#18C0!mDF;K7f;ygo=)?xu;v*A>yA7bunOYk!ymuf
z6P8YlJXp*fee-!41g-u$P6AMAt2Y_!GK~Je9@YU{A>}OW+$go!o*j7I-BLS#qK*w+
zRx&IA?_LfHdIK)INjjn1)w%gIY~4DgyWCjZWC&X$IW8W{NRLBOQ5ess`00mk62ZKb
zURu2(B*$ec>VWo_W8F?{b<poW_c4lc!mpsrk_muM`viW)Is`P1KS&7x6z=qhg)i7T
zt&lhwDuF{0ODHztRgG1++@eb)e>OyJ{whmm3F(GmBWII<IE}gi({WEU^a39FS=S<Y
zOgaYe+`m^?WF6Q6aPml+bP999(lAykO&`E2*-5_o9|T+8Gw=SM48fioHMe8uTQ+Xs
zI0+$Zs}RUbR@T1oglv5FPd(m0)hz%Xt3v@0=#{=);ll|F=Tp-(=mJcbC>MVHhw86+
z=_%pKg1&amI6C|3+po&V(<VzD^;Y1b){Fu%7gh~}WT045^gc#_Ai&l3-tC*^v$tO9
za<Ze7Ax^A(Q#l?yCmv>`JyfHdG<3(gW21aWk^?YlDBYkeD~G;?yHi$(OG&_{=l`sO
z|BNed(o2MlrqO5J=`0?F0dPr<XNCu3Q8D9=Z^>#XrXE|ril`^0>qI}?^x-=)45rR)
zwOvwwU$X?<HHfGb;G*mFj){hIFPA(Pcs{AJ52R8&K(NTGIc<vMd4nL|5k3^ZZ*TZy
zr(8IE2t};gi|m6raO3ou>Wqa5RfM%1DiQWWKM}CQ^R7@FD|O|jz#D;js1&`AAiT#O
z`-(ks7+jqmKo!D@x(3O^=mfR=>AHI8VY*>QFl-0ZEjSknB-6TNJ2!eFX13==M+%LG
zbr2yhOpDTexD78$^U|05d&byhy}E-i0G7O_-tsjWHf5&Hd{}q=`8u*I)PE&#*B&80
zFZJ2*#tZV<WB2uV@HgH&uxjC;!>KXL(0%EMr&QVG&8I28a*Q1)h;bL)beCNC{r@b(
zr_M3bed@1%`Dxj{4p&rjpB*JReq0@*wj#e7Ki09_FALvbJo@+1%g@R&zmn>zf;K2S
zeFb*Dj-QCvknb=IylS1=ML-LLG_4%<L5Sq+r_WdEJLyEV<z(S;60r8s-^%7?OVsF+
zl@XO6l&fj@<9M>S-Sb5_aEC!RWBMK6#_D-OR&gf{?ASXmOZ#3PCX3rWE362_Vdd%L
zM+xb`^RJS|OK&)?!CwjbKT4hp4zBjQIrw|l^r&Fr{kLGZ22un_w|Fs-U>i`=BP3T~
zDjKm8!KnbamuhzX=Ag8Iox|W7U@N)Y1b|Pk|0V!OQ54N01}<u>0LEYmoDcQXDemE>
za7&`2CP;4FX$cx7^ipM5y7?i^JTzBp=0T6Z?<<9AQ5b0hFzLuc^PkS>L_PvhILZ{j
zutGfs&Hv7=YlGC2D_A>xv`oJ38*<8A?Bn5ivA)sI*FTCQMZ+a<mxl&uw!Zh4ta;?u
z$36ISmD&uY9=%Y;$|Y|o+a>}wutYxjO7X_0LHqoZ7M(3u{r!KFnb+OX=gNU?Fm?L=
z(~sapz<%%=PXdfjuo$;-FNA3hcO48Tt$Fn?tZr4#@!+2)axk9BAKTM@ibKq59dIdW
z0D5<xoAQBntHx1MR12eHL#ED^(Xin$76a5U+*Ubw%4`{R=0!4y;%+$OL4Avx51@l5
z+ar9JIQX3c<;-b!{XqE5oUE>M`#L$g;+=${CDz@Xh1K_w5T+|@-uCKUm_|^!xZyh-
zhh?~7z7VfcILeEMRK(tY(e7R0n1kcuMfwqvqm+t9<P&h5dXs~0f)pY2ZGeTr<Zh`e
zw*_zzsO#~YR+^;`AiSlCtBR?!Ks*)!veDvLTy7GMy&fFLDAFWw7uxZ;Q>QwO&n%)K
zAJPrORx&?blosP*Hd!-uwsi1CD6^lF8-1D#z}?r>ay6Q1p9!Jj8OtM!#A`>poXo5L
z9F9JohO_=-&$<Y+`#P;tSU-lNhS5j>u!iz*4%9nWE|*XK_zUSsT_P1_?PlO0j<dBv
z0js_iMxPSgl|~b!$(uQQpYR?G9e1jn_m%I-Xk2Er;_(NiY1>A_>UDoBuH#*St*A3^
zx)b)R21WFZHD$|qi&DEEpy+@1ruDMyk^6<V6RL3>G})Y?NMHFf=0GF}#$k?#OvAIT
z#_2W=`19E!I!3z`?&-5ruc8cI;4|TzOJ(foXUGsdTf6^&k|Vy4HBh3g^~PXWR#YzQ
z;42Wr*@HN^rs0ppiOO&eBI_}W&yyA`h_*iQfOPinQ8BV{{0?o?{LV`<5K_-N>iT$!
z>ADhJ4rXaSYvdWNEP$oCR*o<<U}=nWI}BZ;0`6UrJ=nLWqwN6b5oC`}ic$U#Uk0@R
zNU40kIhsUGuCRU4<t6|;3BWyrtMKcEF2t8s&Z9OiwIb=W<LIt~ArqlhCTeGvbFk`{
zTXcbnZHU5`z$(^NIGG+!0&s6RFN3IX3ZeE4Tq%kpDK1xBZjz?sB@M$x_HqpSY1~&k
z86B@|9(Th%G9Jg}*s-yGiG~j=rHKI8Lvh%^cL1LE-uKxm`Sg+BLLsvEX3qyebKm9-
zGH&*K$x}?I#if`@MU8EOiOz4@aS0!RI_Ra$y7($N1$*=>o_<)iEqh&WBD8$H<x_&O
z>bb{c;P4SL_mZnst3RZzY<u2~zc9V4u*+YB!r=y4f=iVS!M=L6j=b^FseT0rc{ZZ#
z<>G|%M~iu#tzAz7bWc|$0L&GO_4!Qbya(Tf^e_I<uVe^_b}Gi5ce%{I{!ST==V;2i
zMiT~X8B{u9S+0~c+)9t(2|T3~r{%EvJr#z6+OaLV<H`F^N~2%wvyQ$0rVP32R=v92
z>T7MLegL#!SH5p5_cVcAif@q8w6N?-VJky@O!A5!zAeRfo{JZG)H%yAu^pG3pb+t>
zP@Mo^JZ^7EBK2L2Y<-4bTUHTRx@J0z#3})x-}jEI=WQDz3rk^vRW&N_qdv8Quwue=
z$=~(YlIO8MuGYN^X_pIU;o7UEpEZwB1$R^%KK&ey8xDY;fGHeW8KEDAeSn?@@uz*y
zPHA~Fc=1BwCqa1RWw*#_SKbV5=|;AO)=TS$KkECsCc-6YXk`rkT&b`A<FDixlyFqR
zte5KFe&nF6fiht;ufioiC_fhe^9gf*S)a6n2k8mEeO)v!6QE%}3KFdgzxB7W@UHJl
zeIH$2-HLnJm;dRv^5Jt&$g!p)W!sf?>+X*Rf3|=2sl5K{f0tb!zYhxCciNuF7PghP
zv%#!Afv7qIh%*n5y;kGY5D@Y4ep%ah`TSTm3n}Ahr+?P%-<C7J{@1XXFg+UlnIrLI
zx%{Q!j7M<y?nF2dJR@I_R)ao;-_EEjZY#s(i4SgG`jT|)+pX<GZmkV8%m`cp=0FL2
z!zuB7TZM3+T|G}e1Vwbq<uT+aFW&#crz@oJ{GXD>iN;QZ5r+mtS3k;=fV%o6K+qe}
z695TdpGT-wn)yM+qhY`Ulm&?VF@Bk|h5)tqg1oqe$`Ki^%f^K$UadK$r3X|HTzIkM
zzwsZT{CByUZ7fHN#b%|2FbkW{K}~;U#Q!z(&Vq%(Ns426(tcR3^-07jVD;Y&t9FIm
zTZnRUIXs79=Uycfu@_#amu0XM%;*SFQPwqV6O9LOt{{)>-XW{8@;|b6MX$F5Clfnh
zTKS`={-_3pRAG%gkq7%JkEuFXn&*`t41y)U252!axbAkj^zZ(gjKh9$9xKb<cD%aw
z{XhK*tMs4CzHOVGLR!dQxp2sD3a1rf&$Ub6kXP>gCk+0}do<~C3W{Z(I~tdRu$x>t
z9M^^pUUeH`qNO?z<Ugtp={cIwGfbpATou=(3Zi}f={J2vW?p@>)ccEGGM{Y*JuRPb
zO$&H1zJfd~R`Kaac>)+x>u@>K#A|Ptp=V#-Gs!3m`5awg$3{7Z(@V5q%DS3ked!V~
z2Z~^p)|KzGspp<}Hr)^}9kwzEkHR+iKlBrb?1MfSeOqqQ4BZAWI#C`2cs~<PW%q6C
zQkZ=jrKn+zAJa<;Dz^ndMD81KM0T<+Li*C}L2*!M5*k;?aBR#hF{Z*f@Sip{nQQnM
z$z67<<Y5d#Xz7WvS?@wxVc62?hww0LIDFYuAE3EOXa%dpVauUz@r5cKu>5JCdD1X`
z9Avcv*Ce-KAFZ5jK}mTh3INYy(A=|R(yd>YdbP0~SCTRSwpzkj10;Yx54-}7hi-ZE
zB^a@OCymjo@eR*CqWiA%Zn|5B<H%5r*A~`7$RnMyZV?Ai_6_8#rZCOm{!ss8!n{Q?
zY}^F-^wsC&(`O%%wl2=m2idC%cH)fkx|g4l-D_9Ld0+j3Oj>XzPSw^`&TD)purT3*
zo&OJ?`LlfX+Oyy@bL%jXqijS)^Jo<7@qri?8HP!N@#t4(Qcb+jsSzVQ7&qLy6s3zl
z>I0PJ^F5?)L)wj6biPc(-4wOBK#8gLBc6tR7Vjm~0d#OT6h$}@JeyvG=gS}#VQe;j
zLz8iF&^j2rI)<xjPb!CJ*aF)n1JAlxYH@dl)roZo>uhyO!^*{@%n3S%ZPem22nkcm
zg`=D}?NZ?4>*?QNYdRSGiGcloRXPvGlPF&`0a)@BOxXL;@dUv3a^+Q;06;5G_`@c5
zKR8-N+O<^#N_F92U3JO4go2v02XVo|wE2?5-gAD&>F($q`ydeV{c{P)Fs-X_A|0aX
zPOMIa=8RLWW)4>WIM&1S?kv~xnNM^Jm-v`{wqVs&=--)Qss=ra*2BWq#4mkI8lf=7
z=g7LLvp~*jYYFh9v;gLV+z*|E{ZL)0zxbGR(hO%GI9|xIeaUlj82jC)<2?2R44`#^
zm`}OJAN8a6Dap7_-i$Z@vMIiYHKH@04{Lm*rp=O7&ps*#H*!0ppcWC?R&CghXonb|
zCTDx%*hYt8@Z`<k{8(y#_+R8yp1SbwU$ykwVCd()C;lL7Uwm9AU)API<54+}?ZGkD
z#EjNjhO2Q8jMLmZQ?(8Nh%ql$>2x;Ni0Q?zm%{Lez7Dap{unrF`p<y0hL<Bb9G95P
z7r+oyJVkIceK5`sfa3UaqHq8wjLxOG1Q&L&Mx0!lbo;kt!_gzs%6mXgB3IbCNhO(s
zF1bFEVubZ&RV*G>D+{LSNU*fn_aQudU10d{)94u<<K@DdhL@FR{R>N;mEzmjdTpXE
ze98?SDY;SOB49`_0wRzJ=gY}4uDvxx?dve@|MzGDa10qY<F}x%IaK<b@zcyAeH@3$
za%|M(C+o1Zv1t)-GAyH=d70#JhEyd9sSiA)nWh!S%Y`k!r5AA|t?=2$rKb<D`ma3)
ze9%Zy85hw&I_nh2ahEkDAuX_|b+WDgYetNf)9!+yA3yP7)vay}tJ8||4_)eMS|hkb
zkCBrG7*Lu4vFz|^b7aGl56aPXX!AaDO}zT`m;WUDuDnHNUVeiNM%frclg`*D6luQO
z@i-2d-+CgOkJNH+cfnaQYRU}NJ0NWu^T}htY=egV0f_Lot$a_m!RCA`R|`FGM{&RT
z)>R+MxLKz|r#5*pOIPH0+u+s@aD<D7xsJn`o(9{7&81Biv|A8#X}&Dg10a5tIsnY3
z^gThNoA41y#F@tcBml<=%jh#M)IEQ%cN+0*sPq$IA8}q#PvQZXz-1wDgjv}d_AsVo
zr7;g*z#*`oaoU~Vk&VClC-e_k<eV%H{dwzqZ%6|y{MEpEUf3qALb<qAFOiN&BF_9+
zgcWhDt^*e}6>*v;5AFQic--hpy)bMK*|QAGGTQ2sCMMiP^tnY`X<T^c1&l)*O8a!n
zG+_!%fDW~+22J?JV*<zsmE5;&?C*Yk4NA`5TSr3nNQ(qGPE)A)b0dC<z6|lcaa-0&
z5uIQTGx2hcjho2~mGQ9Z&ruTKt)r!JyNZWprg51T!Wb?<Z-LhYr(GVa;93k;cA~-Z
zRpWEX)VlfuDQsSyCVN81^Ee4H{`T+4uvzm_Z+v)G*(|PoniJfno@SYRymV*m!gFLW
zBnum%w6_NrkMxx^pdI4*bx;0Y_ODwlr{DH<89jZr)Icje?UYsiF^8(K8;@(`LP<PG
zgfKB}7&by0ur;OEPW$|gG71(2C&|P`=g7WGu91)a@`&t&CN;(T-F2;$B;X+gGMK7J
z@OWE$8C{&J2n0x!ezERpNqg92L=WTIdL=WifM_b{6bIel8PZak_+zvaKH5d&7$8D7
zdfs9^)~9Ls6XprSOkmu>l4UC_ksjhA?9+_bkVbZzF9#Ep;kXcI!d>5&?SHseIuG}3
zav0XPzrqFF5zz9<2hw=KRc=uB1-rUiJ9gox+D+RJ19!*zPo?9<KTF}0cio^p7~d3(
zv*qWWDS7n4Icz-$m9)92^!I(}q=DZQY-tp*A}_A}NQ$eL!#W=p%3Od}aJh-oRRPd=
zPotKDD;_WZ*}gHIr7z<YjIG2E;`MA-X#&8^OYvjo0omDm8M=F`<PIN{A|?QFCt6wt
z8@VK%AM>eGlE{2%fEePY^M>&-91;rQ7Us2(9k6&+w6md>0Uv73IhVUh43Mq-C?D|1
zPq}yj*Mqh$eZ{Dq96sti>ZY&B$TOkyfPH7yO`TQJ;_$8R5mGm{1b9dMAc#X}-}!AB
z1`Yd7Pd_BBxJSZPn?W(h9ptKD|H`HEF3#-Ey#6kka{gsd3L66cF{q{9DHf(xjVcZR
za5yxuzI3iBT#OyP3xO8HhD1a}XjEwIta-30FhN#BnzHI~oCmM+{5?s~xtsXn!O20p
z{;T=8QaMiNwg6Cm*e0NviYC%E4H+~Ko^@3YnV8Rh3@~iY!m;n#M5jjBYBN`Z72^<0
zz7+0}<2*4<s}HG^qyta_Lji=jQwMHBl*DnF6vs1T;Rw&6=(ja;@deVlf3NI*^jBRD
zR#vyq+b=>-sudE=dYp)&X<xdiZl1Yn<1TYS3Rv~Gzx%3mzVdkTdUlBIi)-GK&h;y$
z6Lv>r1SEJofx|^5jSKMsVk@Oc-4@zdpfsh6LEp1TQJu)dY4-6(;Hm@E``NysYV=+}
z<jP?g6aeEFJw>$A1c0dAaN<;RJR^PXn$SSB2QVHVB09pbUrd+H7p78rgr9+!0m?)V
z@e*Nl932oBb-wvb$;*=)HwAZ5FLtY7&!gq-(#Ol$3Q<<)+ES@P#Nde*z~Da&$Nk1!
zbdBUOaIuaF2LPW_D2hv`i%tRvO+8U-utWxkt+2In>iL(;5S-86@XW)qfB9=F#!I2~
zO0)$lgjEmSEBiNnCUdYqJPhK+yeSBR-7FRr#y{qwYK1^1x&-z~5elH19{@@SPQUIp
zy{h-a2YyoZL`Mf-4B{#QNYOTy%J~I!hMZ^}ud_)RrxHfZ22Z1%Yz-TjS%0K-V-iBT
z`tyX1Zo&sb7}r=Z^Qs$mie61koFtwjYP=hj1Rf$`9_C1<<GaRcvjtWsY4hJn1|6lC
zZjy%5^K?U6c}O?MUV6PMksf^M(UShhaeLzZrCoqFth5`jNU&+K*3q{WIW8Nw1mfUy
zR0kx*?JqtGMLj46w{oXC!$FdzhT(Q@lp=n;;;5jGEe7L1O*3FKorFBdwF`>w{d)y4
z22@#9!b||LZ!-Y7ptl=LCBT##WC?2T0r=21uZuqZN)1}B(5yUJurPl*J&dQrMVLg@
z!T*`x<96lL)(Thu=U(ZI16h~u2^gL7K8{3D$!FPXC(TFAj%?6bm&y3+?t-aQ+=zw_
zmGukjXmRVHqqxV@IR3bF-zjFMIl7jgHob@8jP|^*|461lELw-lIr_?VLdkR6D^JSX
zKmOlk<I>mB=Nwg~GvztrJ;|T($pO&tC<?cBP`Gvrtg{`5i)k1xr2#W8zFH<xucb=I
z!8bb2h&(JS>t{UDkJ3>v6%%{ISzYOCeL&R8jF10W{Vfe~B6Y)Ya!HPjcI=au|E1GY
zWzb3`uXv90dU^mv^*}1q6J;?yP21u~phV^H){U~}p`Xi|-~K;xa03)Sm8Xzy28|S5
zkc`Ty!CfZfuen_s7hFK_$>DHPss;C%bi&>S9ovkqD?dU2ZUKX5+gmS6+b{pS6qdhS
ze(+byeeh?(RNOv0Jd?21BQudeep580)qe(nSn6i{u%a&S%1!`$7OJ;%Iof6Y$`{ei
zluZyi1jp(s6<jW@1P(wN)}6TG@}s4)2?pqnhwp`LXgti6%bhY#YH<}N2S%gs@+J`z
zX-LvIUXZqRtFZe2Fo}Eu$Levr-}swxSNBLN_n;R>MOc@zzpB#N$-0g<L5F!u^5>)u
zALNv)ZjsY}_&>|w*=MLSS6?;R(XH#`qX&N~EB<`H9Nx9viP^2b;LQeY@|_qY49DQU
zE+M|lV|91F8zghO^)T<cFUjE3rh!8BuC%?9&xSmU(0FbD03ZNKL_t*AkL9}`o?~x0
zz7k-fbg&PeFA9y?0b#yJI(ey9EQ?8JIJwYv=eMdqt5dd5B{6eFoI>iv>eAXF;t2@x
zQwivhSLHW=DXxcWS`h>OTKVMX|0w(4#3f3ft&nxU|Ct=wzS-5$@Y8-dx*m`6q5(Kj
zGM-0mXDk5p<ZuPlzkSnMeKzD6)l`@EJy;RKv;ww=JJKTm2)T~~=+kqPXGTWd!qSY#
z5Eh0tojM0w*N5Q#2y^vcQJXjZ0y5a~dk4#qRCW&`Bir$Tc5D*q#u@2yjb8!>APq~z
znN9#_YKa~N-4_(9I$;s2{o!9q=kNZ-DT`#(GJoc!lGh_5j<V5LAAc+!W;Iv=XHRwY
zpOz|w$R|*^7S^!F-TF;w@Rut^oh0k&>&m*7{Hjh51_@8cb?!-;Y!d1noC4*;g+KbQ
zaw>EYYKM#<xKCW$fjzSMxrgQ5pZ^oI^_Sxo>(<i2-s<Rm<s00Tv;|;Mol<!W*A1R9
zWikFVIqjTFs-EDeqLU85{&}S7my3hT-q-?Q;}`H9aX`1a=zEbWx1?=|j68g%)i~CZ
zPTxNipaVbRM%Vlj9(*qK@TVP<d#5<*+Y2zIsec*vKjYuxX&>oUCa<jC_Ubdz5_J5{
z8$OW@5C0n1M#DlL`3>_|LEC*>E??tmQ)Jv7-xGd|Cxa_Ozo`XAx44pLz3I$%G51$t
zYzq%GKYz+7$)A39h}wT)>Jv=D1OO9(&>3$bEDT5K*!~gTdfR`F1OM9?!z)ezy3zq4
zyVN4&MvFW9KuBLY=mF%mZ<3;3w%`h4BUW0MluIvxmjK*Lmg9%WV<6b05_IqaBOrQZ
zF!uV3xQwUB^V;i?R_U$*XrI<__3v%o8^2bh`uJlCWCpjUY{wpRVfA|ej6ie07CoW;
z8b~@uf9X3iX!;y{5N;01`p~hvH)#O3SYvo9oNfS@J^ridVeU97LDYk(P2YeU7iZjZ
zk17ameCCgGv=1x?vN(#^53YV+-iLm`l&ilaQz4>n#FfC#C{6sXMpZ;03i~#(_ams4
z1|vKMyi*tk#BsQgX5I6TVz6>zR7=nD-AdX$4_8*X5|g<(z!b2})mu)7s#IM<+Ch?k
ztjvLb+zzb5sf2;wuP0>m5<Vh{IOtm3is;1l+mRhxWGD@ap{XoA@)3x_K2sPE%Qrap
z{f|JZmrydpyK`j4Te1oI9aCW7r*0@Ft1QoFqG$ONVMH99t>eS^_6Fn9sWF%Y?D*9`
zO0j?Um#yi#<#)oE5v2eF<}5<K_?>ih^Yx1AYIXKS;2Wrg5@hFF&t{*|?-nQBM5g`!
z;QW6zxvfsDh3@|!;EsB~IVu2ld0x7j3BXnm;?(8zeqo&-J_bX<O;Vvf05)d)y7Zir
z5<31Ye-TGXimP!H#6*u=fmGQEk(>Oi#gbPoV#g;xQ&VHKGS$bQ^dx{Y;#OGwD`pv<
z=y_H9Bxepb4u)TQmkh(XUhc!QPNmM**n6ev4#L~msIXS{!5Z<blL91xbS)xyF}ROA
zX3@Da7%S#YFFql=-}sBJILh&GJa9?_*8cf7a$w_HnR)G(WE3VuHFf-?0*2BB_&O=y
zOap2Z_PFV|k>E{(jhGl8>S6+5N`T=C)0JYBoF8)O*;3JT602u1<pEhKOfxZ~m0=X4
zI08`^i8_Jgdtu+AWhmn_ul)=~>EVz1KAmY6=fss4{zMLC?fqnhjKNV;-uP#D9GIi9
zM-JoRz|CZ)X*v>)?b#(A`*-<VfrqjVyzz{R@h9N29J4w|j3|E?2GGHkaso$nVX*LM
z`_lJh-y=WIwn`cl{kaDr;cUa{soKf2B0DLrR@QFb_w_e^-Lwbq(s(H0&Risg_g}T7
z{_(-D_!A6Ppz&?-&`+fCBiOX2TjNPctA}CEHa2yY*S^h4csvEb+l2bhVXsvnK1;hq
zqoxwerIo+|P#8YYBJYBSa#!Jjf5kaaoOld7oNf&MJRXu?c)sKs1|_(%mo@~tvXd`)
z$Ifli`N10@+6fyTa_P--%K2B|c0V4e!GCK{aLl@C{nTge@h`x!bo!kTo$tnVwg=a&
z)D>r(FQyaWBjBki{RnPlGF@?e`RLqvTyW;?-;^2O{0A8b15thDcwBJLyRXQ5KmQ-H
z{*4!;rK!p7@ACb^&&0vxISfa2@Vx7;lMk1}<pnVf5QBE*OaoubFq#=Y%d}tooB;Gv
zovzBMlujPpGjq=*s=MbSU0;Cp*%FVFqV8-%SYGw<$7n}odfE{l1DIg&G>JL#yMM(}
zIk;tGls|l@qP#{6fb!`@=z2BFUfkr#$$h3nd3&JAzVnUer2{%oCG=TNRED*rYa`;)
zX&(IHcFBnIE|<ZV-r^EY@V}j_-jxm*t6~Mix-eq#unI92p!JQChZI1t5b0M(tFr9#
zyvyRVY#NX7!oXNRI<m*rKh8Q<cGXM(T0w&L04mkFaw*+S<phAD_zYKxiE?QraIE@^
z6uJNI$5MRk7igyA6V2qtPnP`jxzSO#usnNtlQ35?!ipFO+i~5b&=m3s?iyfaaU?9{
z<#A?Oc_;t;;ZGuNaIKGPfe@z?ldF9z-j%Ir{|&$RN7;^j(zYXqE7D1KhMDE1_^1V+
zJT5r*+y5XV&bdNr1`Sh=`r;3d3x53Tf0hp)`h^_ah6{P1OQJlold~Tn;h+?Ti5taP
z5BzK(v%2SM^0;a^Ims+n7cCo!-Ss*8c4zP{SH4PieEErb02bBL(!H;|;*Zvsx;Rxj
z=8MWeI9+EeFT~;XzI;DI*S2qmY{9!oT>zz-K}%`lPr3{j=ev%7C}{thk7Peg%2sj(
zoI~IB^n>~>@ba$&O<x8}O29*&JPy-o$6(aex5>b>udGz$36WNW1gjmBEgtEkBmZ>f
zhhbNHO?K&+9M(*mD>;hf`^$|wRdRa%ABDq(d{)H*?sbtJT`tC}B2^_4UwMw%9J?#J
zY9;`zFZBQ_Dic&JrMrnovBwEL0PP7f@>Y5P<<cTJlzobCza)kGpv<>&33`ssj1sy5
z!t6W07`MC)AE}wF9P<gZmpB3QkxslE9Us2c-{PTeRM4T;PM!l}KVOx)pq^GA`s}pn
zG+g5Q7C<78m>pX4v26R}&x9Rd$G)Ai<4^a>dT2+}j(vf87bW=vx}?Eh^e;$bz9`+n
zxzeN2pn2c;TbXz>6a<I4=LFPVcU(nof8_~T_OpMK-D_5PCAeU~Q{KQim~`U#<b(jp
znS*0IfWb_(?=&khui|%<!F-mNw5$CU+K&HIR|x>?n<_WWkBf(G;-6ck3I=KJdGl>>
z`O@?iPCock9JUKK8E`?<aF|NAiHecjx9nBf`sRx;*WMh_boo4uh>p>t@Bbl<$Nr9N
z+az0Ivbs>ky%qchwm<wU{U+216B&uhi0c*c;2E|0cyv92%aZ}4Zn{V6rp)zNC#Z+-
zq+{jV(z$<+wz1ZM74*)6uJ#USFvfD|gYpZ`S1FFq(sv%WqNrpEGsbiwA6bQ#q~m?a
z@v3{;xamK~K@IwUD@)i(v(V)Pz!Uid8MBw<X^OoR&t=)zuab6Vt?|+oao0cr7PN{F
z{TpUv>#L;J1sY7?=3)4!XvSdz^pFpGnG-N{<{da)kaeUmAoIBgYsO5JkudYyfLrqH
ztUsAzT@pV;N;;+phb>T)CS10&{juLlCkB3VyiM^iF5g)HtACc=OJ9?ATt#bi67(Zl
zaXF4^#y}VFLK*{bTyXMLH_O}~{x33g{&`hvnH!JY@sDD^Z_U$xkY*@>8UNwH6or*X
z3`nSKrAYy4Fi%H&hqU4-R9B9JFP*j_GIQmd{#jb+>k1k9dP4%B<r@$5@pJW#>l)WP
zOm}>DhX>M5|FkXuYW<KJ|8uz9<`^}1u{4}E9l2vik^Sb!@0Tra;Ji6*;B(K#=)~nj
z&rm75^iE7(58>F~y5Idon%6;TxJuUnYogo!{A+32x<Mz%X<k`3I;~?=r<j*8y#abi
zBk%YwP9sflnNHBZ#T^@^eHE0R`L0?8d>zR$+rV5L@~9Y;^YhP!P5!=<=vmq7&zP@@
z;R#qqB;+$n=7fD6hR^P7DMy)m9N3MVYpTiJ<pjVJp)rA~2v$>QmpFVWHmp`#&E;@2
z8#_Qwq+>QOyqB7*{<r?(Ub+DHc!D`7|K-Le#Zh6|$*_wVtN^ih$NP{%oWL%R+pmV*
z@D&+E8~^^?H2DvIWIv3%PB(^WIuM%o?!w@IpR|_g9NS<se9Qg+Dw`gAK#su#FQo-(
zS|#NGkkw&EcueOH(mU!cjGVhj=6&ZM<kXwL(Pz>C4#0;ofo;M~ky^I$7`F#`iw6(~
zkK)R2>7;-IQ8Nbr<~{MmiS1g>*+h+HW&K!Q`lszk<X+GLAYbH}t8MiWjs{a-cF0$v
z{>+1CUzNi#z(S{Ox3EnAWBK@}<!hL6|MNJFqsPgl8}636k>e9ZbwUEU2~w%GkKTuq
z0b7MzR#9G~q10I?v?G4h_}}r?OS1Of|4WX2`hJ35HIdehtM%L9H)3TmpM}-OpD<pM
zP5@5BG-5k)_)TAjIr6?c4$GpB%i$a8SpGVsfRM;~La}clS6?e9g5q1wqtDIF#U!Aw
z9q$pqmIK>0DnFylvT1lP1V=yn*<tW3e*<913ssh@aTr16P5dsy4>FN{aC^2nv%nB*
zm2+%#ybBc^FnHefbqxATp00e1uL6~_NmTwj^I|CfH7ZKTPr0yrrQKn<j*Xv6fyWC^
zREO=2#!GILA!lBMr|xf+3o6F8XEbyXEWl%WJ3C0MijUEJX9dTjO#7ezqa4Fgq4DUP
zN6c9W&HDPv589Z(X#rPk##`ZW^td42si`pQI~0}#H#~N~G^6wFZP$qlbq+w<F#^Z5
z@*Gf6zT*ugdG?}snZl!V=EZ=xZ~Yo+!39*+IlN;WbgM)5Sgw<+dhqRvHakr)kTsNt
zd?mwfQ0<DerSr%l^XtH`Ku67JCVU@>VBl~3+4z2Oba&&Q?~|6``fW-AcE9wP9Kt0w
zBXP6m$kWfnt(2pMikLZn`lS<FC9Q|{%VC@X+4ufi()1DbwF4t&#$#1J2E^u%-<2KD
zjF1Vp;dme}i=rd1$}j#zd>bs~8y-(L3`4!zU{<~9xrh3D^$D)3bG#&|14pduaEhTA
z8D+9s#`Pt&80y2YkeOd}o^-zVa^KePR7i-%Oh}ZUu3gAmI!*R$hd$e`5^x^^__@7~
zUm5MwWXV-c0I&^ESg>HhtH}Bv@f(sP(MK_uOw93?rWx~e@F`ac8$YAFSM=hhbs~@d
z2C@sx$SGCmWtW5aFpvFZJJv_?AwOAR2SX<ZE#Z#$u=?+5htbP*DIo_jTf;e5$?(f=
zlzcG3As$cVvCg4mlywW8;sMZ!y6%4EDQV(Wn^iuCmNg&9W@ri@z2a6Gd+{|=k9|MA
zIWJXiSYE_{9vfsz2C_1l(~f-f!n0)%RuY?DcwF|vQd?P#?L;BfM|MLC{Iqi~k$RYJ
zHK)%%-B3&ftD0tr-Zxk)G>NxkkTLOo3aupS27fmRC`qgU$YQMmdgUZ^>XbyJT~vk-
zL~$VM5x|T*X&M%%A{j;Roaz`I^NGWWf%?uX!J#g|*v03|K%DX3@YF+ccx9luk9W0o
z+j`lK-;O8mm-<tu$pGL{d9VPfKs&GP-mwYhZJ}&k<$LYf$n<FY;K=Jw$!=^{jm6}*
zhQ|>D{;gi2ABI^u#`(()Xpj+C+=63>yJ3R&#a`hrlj-9D!j6ACqyROLF1iy`Wu9SB
zhSirV^8EC9QkXJNil2QLVDxfu)<SGGB$Y+O5+Z&=poQ^n<~Do^@etR~{pMKMl4|z<
z$x*di0K{E|U$x5*;vc`m3OVaIV485*hrr_(8^Crie4Obr8PD<PpSKMi^3YY7>7Cm)
zp3sJWYNs!d;k5A&LnY+b>SSSEad}__%fREk@_V6lc@V4m?yin_<>{WM?w9os{JR{&
zKALJuqcB_TrOS=t2)O-hH!MVO&mZHuD$UhMBaaK-@hzG9)&C&%wDsLfjsx|<kC)4i
z4{>Rftx`cd%?tTZ82+$c$-Qfr)(H{!jup#g&+={@6-5V0+F8Fe56L)&;NIE-K+Q}F
zVed=2eo_6ScHs60q18Jo&y~`#cc8S*!}^jRDvA!7I8|nU?Qdk<^<R;i3`J26&Mh!g
zet7w-vLA!=!MC21qcCdI*`3?us;tt%mmiaTZ@+?rLCLKLW)FF1n9kbP(iDb2HA9EV
z2yEZg&A=dbg1Q1G`kgSq#F|C*33xRaLFsUA&``<EKR3Yc<sgn63XlI~=y#?0$t;;i
z+1EmUzK_PA%rc$*e;xs>%5`S~KqbJXRZ;CNB-|h+`>GS4gfB-_{P>9?<0ePZUJVR`
zS;~25C6xa{9x8>47!*4`fad=ZtQ<~2mqXo#Lku|pt7BW~vp(UEY-=2U3?9LJ8VBry
zE0@WBT%6QXD`o6>kHSX6hM)g;+41^wP|U(T_oN?`Yvq^t0N6yp_JT_W3eeKyf)`#X
zbN}jp!g=beboIo#9Iq=ty0adu%Kf<D%B@meTcvp@8)qF+QQkzj_DQrMYz|cGXk^Jv
zf8yt3?Zfgie=ILcYEo^X8F<lv@5?kE=$ET^rsO7rHbEUYQq}=G>q?jW+Yf09gP$%Z
zfoph>Rty*hMbT?-m+9a7Ptq_IlE=@<@%r3-kNrl!9rqmLx{!A|tDAiX37Ai3I}U*O
zdibs1z@GVJo#+tngmQ;)3JN!?rjG=YN2_buFea+`xo1EoeM;X{iQ4~ak+xKdRaJq!
z*>=aqs!)3giB0w{eg~?h*PRIf4{cHpp#Ki6(=y)rPw*!26YkoDFN|Uj9x5{TtgbWm
z03(NED7i6Cc_=Kmns5P%J_Q_uIT2kBnzci}^j#S^Z4NpNzbEWJMXMYA@W)6P*DzLP
zP0)zm^YAaEaA5awSG8mBcG>ZVpUTER{!&j8=#eRwn^ks-zj#n6FA<=Q!_dhyWcEEj
zlu37fA06ju$IUYdG{dIFr`TUUfbA%q1bCj^#3XLF^dQ9v3xE4Jt(T8}f3F<d@>%!z
z;XbvsPc>}>>YVHWwbvZa!;>C=rS*&JuIcy_KFeyEP_a1-X<6QMIaa><Rt9~~SJH=A
zxuHQuEjmZ$U@|!J$}dU2zckHL6)xb|*xo<?N}8}o&PgC$l2->Pfq6WKkM_qm+%R>v
z47uSRSl%ly$|nBj<qGe=A)Qp14H&2<%(-d~6P#RM^zl6YcltRc*8hyfkUxVZe2!T(
z1C0qzKRS-l6cbiGMx&P1x!t>W%h<7FN%$W8ARFl)m#c*W7#>6siaOQI!xA{Ee1%7~
zYFY2@wNv@;>N_N_cEeqXiE`02VLS|D6oBH&8&Y`hRrHGNu1+9_eZ$79?~<VxU87f{
zlC$J?tgDID$NaDcijNMf9Tz(7!EwL#G8+G3o~px;D73<&*5P%lC5L_3dMIV(@m@r&
zoyAZV@dRERq3LGsyAGW^O&X!!(SoZ>+i(|zjxJers)SJ)YaeVM)L^@4AT0TD-#JUG
zSUVN6gZAry_;4pK8~Ws-d!^|!h!MN#2IJzAaWIKYg|+UuX6$Qkd-DY;z(CdUIG(Q`
zhU2lL=FCT3lj{sWo<-#2&eVmPFre?ot(&$gj1V&d#Ni-4V)p##I$xs2G~>sYfO%RD
z<|Zndj{v;HwOBk1n>kNvM~;<a+qX!8mvp5W_cZ#-D?qx@f?FpWpw(Z)#f<+L$%fS>
z%XhH2PHg|W(c`6~6Ymv`taU?@)K_&&(1k8Q4o8h^Ce0}MF06jU55rL$@0p$!;)1F-
z`%{iP*M1oafL!FoeMD3)1C<=U-yD=kWjD7s`pxY_N&g4-|Iukx=epH9U;@wrvNzxd
z*+@S*E|t)c2()68kD+||3A_P#kT5sftD2a&dp>{7U6=+9v2RkDNt6pn7`Jc{cgc4=
z`G5#kv?r9qhcw`fOL64y%jj%kr8V+slK`tjvSzLpahl7J%h#e~9)baMw-gTHz3j!#
zlS)@ju%FO+?3mPJ1)wHf!$Bs&jN`BD-w4-9JBY`@t8w&L3;?G~0UbdLjwBY2N0A40
z?>KT$_OE(hj_lbjd1x@#;JwW2$qKyR;DNW=QKOy5$@Z=P6qo)yCL5ppowV-WT9)-n
z34^E1)(HUjFWGUXJI}1V95R{@9?%H@EmR(tL!EU3Fna+TG(pPo5_1%X+-uT=qmH|v
zH&X51X)~Tr<HYIGh<Cw`Fov(2(NFtq6@}qXI*oDOD=`S?>IdUJXoXFHcAmiK%|Ry7
zD%p`v+$GT7(jo(K&jjBazAPcHVVD$b*pJ`{Fw9A39rRt=cJGu<-bxoX5Ho(B4sA+l
zQO$g;xY=KOXLVpS3@785wj)pB6DR`0s8X-FY1sR}{1%uVW}C+@%}1P)3PJln_rk-_
zVS^r8|2eJ{evHL>)gNznCjgx&U^adi;1_kB2=|?9gCfO5%nW%KI!2;u3ytu2sSnR$
zLfNEO90rFR2Fm=I7h>}mD>=BRtW>xp4If<rBE8O+9y#Gm|JF>JBf}v2t{XKL&FpFv
z)+<p-t!D-fD-6dJnyszJIqSyR3vripjq5zyt9~z)PNhFZ&}v@4N{(#VD7C{!xl;ld
zP!ldufka9oq91hvS8E`3kTML%R!GCCQ(%{1hjbh~K5-s(KPbxI^WK}X`=bwFcYeJb
z+O}B^VUK_Brz>U0vN!btqirugA%{QxK+Qxa80|)6(3Dv+7NYD>0>FA!`tiv%@82ui
z-+J-5$~HEKW8ywiCjfEdraREA_|aWEaKFN<RY?F?7TdLH=XPAKGX{4hjP{cNS7u1x
zg>8sTj)8`k_Bo-bhf?4$)&ti}H{)n$@pvYK);Qhp+jqjWbiPgo;+fL!f11ZQ9@I@6
zCLTD6lZSMx7J5;wkf0TzV0%J2OptSP&X7EwAv+MOldndC)kGQ}GmZ%tsYtkaO#-jS
z5%lqL5!Si07ey0F(hAG1M4MYSxsR7gZs`k^(0V(K?EN0UzhDATwP?9p695v16oBIY
zTk)gpweKBfhq(cbQp7o2;b0CIcPEvLS3GV5@PXoZPp=%g!yuEt=5EQsDqgfSPVtoH
zFN#C_-?8L5De_q23FLCP-ggKF{|4RncdIqyxx_bs@}G#Lo(m>xSozi92n`LB)Q+A2
zX#jK|cx0*<9Zd-zS-nC!@cP$d@<I`Q_*^pB?7H-*TBrlwxk0#vZ#XA1kZK&o1nziO
zPu#a|$7F)E4t?^T9DowkL0Cm=g1$=|>O<wh<8^~M0l+awN@BX>nh);lwFv+v0H^SX
z7r#NcbO);O0BFHucu#iW#yA|GsG9W-NSO|<{tyzI0XW%ls@uZCMAm4sbPeN=!ORbN
zGg##N09W6GU=O}w@=R&ox5rHe`)d`AKCpeuIw|7H@dlh$P*cxAdpZ__!Qb;7)xozS
z<N3kEB!@w^4H7hn(0s}X;Bn6!M#u8hy7%u(7FSlML>loaMOcA8zEJ%;lb{hsDE^1e
zgkbx}TxPkJ82H4?QT&gKo>ctbU+)Muc2M-cK>Yu4z)qLJZcPA4&2IyI1;JrmQtvGU
ziX-P?0>Hboy^H#21C;R<Z@>T?2SmqB^RvhMK*mhM{{QU|{|`=#GiiRpxP^=8Tsxn7
zpug=xmuVRf#!;8X8@?)o&bnA78pdl@CQD0i2~?8HFpYy~16CdbXU@m=BL+XLXnIqW
z$`b}hF_0dGcyj>uI_t1sN(n^CRM9HnD_7~G)-;b#i3n*9n=x1Fpd3hRe4V{1Zp>=z
z<Ae>uK$VsNR6~+F06Tg~0x%33+BN~u_6!<42u5rftQq%X?8XFu6Q%ArZqppbc3(4Y
zWaMP9PPek~5b;0!?5&)%&$1$z4@7aK@dBX+Yz+;@+3-Tm0BMDt3QD5-#o@BBwrv}w
zX53`#=Z^z3e80)B<1peg;5&kO1~ra%xdwLaivtEq`)4phcA{KD#s`G$(flGPR|gkf
zSsh$meMQ3hFw71K+cibq2Iz$a1}zL;e0{VX5%Q4aAQ>~f9L4|7{Q(-l&>QJLw*^K0
zpID?rbG~}l(+L1Z3*8FvU1aqI_6U<R)p1iqypo8~sJ3ug`V#D;$?E0DJ@Dktx*S^o
z7wXy2bomwIc)>eAd0z@RKin&`RBMFe@i8zDIPV%6d=0dnF%c*o*d6h7y%d@P+9bfh
z<{NvI2Grs{?M6%j@{l-Cxvt1l9=+(=vA1~$`|L&3r5*-bxX)hJr5P-X=o5g?Jz<^~
z9|DO+TPv)<Veh#+tJJQF=*{#&&;b~;uxCnuy)gmcDs||r1#(J;4gl+Eou$<|jJM*b
z=kB*K0qDu#3aLRe?1vo2=?SiO>qp?YF5dHyzJ=31k<ze|I6e{{8y$>yfP3mKdv-}D
zbzJ(v6|tY(x_z?@z_YC#hNEwIClmZt!$0`swoonfB|4zj(8<#!;q0g%>QT0cmL|#J
z(y=^`Z=;>9Zp076S#iCp7j4rk+W=Q$fky*$DIUu59r8zsHO$WE-hZ{f+x2CzaUUiC
z-I_J`WCB1vfWi1-iqubLf$@Uoa7L-P@I1`)k~<Go_2YPuT!qR<I1SKz1Z?-vfkuwv
z{|S@z<0F-H`DNoU8`}BeV<KBV?P1})pRH!v0vUpfL%4^ICQ@hoSM3{OB6l{goFwEi
zC=bNxiF!=t+HmcvUJ8Vdrnel=P#;~hLYfa8P#pxW+@s3*LK2-xg8$NvhFL;<N&^N!
zA$1r!h&)8H$8hsoZ(9)TjkXwsqhDhd=0Dsa001BWNkl<ZLa8cH0%SeHx@46@3BXR=
zhS#IPHzbH}b}05xbpntQ>85!oi6ifx58jcE<Jd0hz;)sWF&Ts{Hfew+w`~oDWm(w9
zKZ~;(7S8rve=-mgfJVFr?d_e?&eJ0Opj}^t<f-kzeyPU<B;Pp54N{)TY+keLl7m#V
zcHBg1!|~MOfnDK~`~1Qb<72y*m#f)!Z}=>XF{@`H&UXwCvbf^y<6B_C28vt<?f;>e
zU{&c7{6Gqof9_$CU6_pYpW~qa@A$oq2|$9Ku2|^y1ONqa8-SC5yYS;gpnn{#D$T_<
zfWMA5EHu@Jhe=U5M{Q0jiUjt)qr_?h6J|&rXM=P6@B)`EKPz6~O@uFDU+CE3Am`^7
zq_Lktuzokdjxwg1?gne6lLtr4NSbdXb2yt^hn3kN3=jnzscgqlr($pJM?!Q=6RwBX
zu5znDDmHqBP2(ZcPcxc<#IK8!01hZarp%B=h}v7Ql4{$vH3R$e12y6pASVD^iKiXw
zQ0~`qV4v*d7C=u{->HIz=mcPXVo$fEcLE>{<7B=0&;e<}MDBPT>u?m8G9B5uLrwVB
z4ILiy5|nG@o6j;WobVBe;|SqBs0Gcz&~u>jS_>wF#VW1<KAt);Zvk7G9j)z{1kA%d
z22g<W1iS0!24b+qB%qy2fxLqKL~z_chk-S<u!`@|>SU~yjk6QN;-U!i@yB)c{_HD6
z&b~~yL(^p$522sN$zfY4_tKyHTl;@Ec>3S4|KIJITxstR)~-w#698^*oR1$*1oV&N
zX@K!lMWEc2UeS>OJpRfKd%`)cG*`ZbFQ{iLP8I)SkBY0Rba@ryQ2r|{Un0d1mmJ^h
zv~mrrPlZ8{fwz2H8XzL30UYDKbRc&mqjX<FI<8;?MqHEtq7;2veh^g!!SR!DS<qpa
zRo&a;XA=;2L97O-aM*-ZpdJ_WHr%t`osztjSPzgnxDLeRg2x59r`ik=WN!?dK@mL;
zatmM-CjfX?yW?7Lxy{Zc&!Zk~-N}}TJ7nepoX=kvD*>i^OXNy}7^l+U08I1`;yC2-
zp1k0<-UgkMLpWtoz{H{f`{&%s;X7z$r+ro?0Yk*aZO7f>&d*~tJ@C{iG7t)EZO}jH
z;Bi3{E09=kJJ9YxoeFs8>Zi=qXPn>{<#ib+0>42_U<#N-bl}v<39+3;3GG<uS)pF(
zdnBw*)|~0MKmk;6T1U;l8&Y?CEJoz&J8|M{D%!8>PN1axLZ{@=&#U;qJLMif?&~1&
zv+j!jS#0-u2hS)b0Ms}fg5M4JIc*f5)|Xz6mc@7vGz`{cxr&brFS|+s)~^<!{qF8M
zyd1gfz9Kn@{nVkbbb00CMcfQmc<~XDotwH_YM<cOU38-~UU{pwhw&WwJ`lw{2UW*Q
z@;gA;{1`-emY)iOop_bnAt~uiQ7X;nw&1v66O6gkK#7!l!m5>SvmIZ*l8+g1g&E^z
zo&==<v_miy3W5z2rsy#`YNYq+08oaP5ZpL<mW=Mn1OO6%-MH4aHzqQJagX{bxPF=X
zA7$G&U^>Qugb4fWR2)6JW1CQ%f4r`6^sqERQMCEcA*qLn>l)BEZF4Kve3oV7w}WL5
z{KgY;_)gW~xZog6cm!KRt$5#hRjOr$nGaouj%^zyHwsFxXeYjh#($T-M^F#nUkxU)
zokw6|d;5mon}8diJ@NAcU}hcC-av=P>SW|H<CJ!Bakm<$ta@^iX3AU<NO+6>@-r(d
z%TJfDIM~w6Kl7jnY&Z0y<5*1b|C`+v|C7g_P5{^~9>ebr{IJQ|PY%}Q)U+?p`ldQ?
z<Dg=HjctJ3p@aT{pl(V5aA$b#%G=Zeot4EIK)Sq=IC_%e)(ujiR%k!$5k|a~3FK#;
zDT8kRHZD9lCF0$9PWTonL#HCRByR~InVo|uwpCObFm95xVyi|)sn!c8v3nHj*t<iH
z;HVw<gsCB3%a6RwJ5;uSa@7DGYKRXUJ3)qE6^L~J#K9Xs*A*2f0HYQJ#{kRmo~rEs
zN8WpYTT)zko{{&ta(Dz3wy;8Y5FUi^Mj!_gaxFKluY0<;d$)V0r+25n-EXI7W~a67
z)#_18ZRC-Vgg^)o-h1!8sVb_9f+{GWDEG|0xxas8M&8K0nRzqsz3;t(jrZltu;-kJ
z8yRup#EBD|&;eLApe=y;+@rqj2M%MR?Hp#(185XV#nGl?eCJ!R$G&O9Mz&a%^*=c=
zIgF$9_72x7%aY_M@Ffj!c<nn5M6d1>znaf=Q>|FFH8c;C(xVtA8fUNG>bPXucwj*$
zxhWJ;N7-r_Lcumw578APa&JXAzyFpY9Vy;Ttw4gcIT$Eg^D3A8a2f!snR1TSxH|b^
zmr1$+58u_>R_pQSaNPWZj0?c1>*xdlcYXvnBmSS+abDcUf9pm3uPSzanH4G?>j9uv
zZ%*OayF!t{WYHPVt#<$;8k#wSibGO3*73sz68~{an?d8WmOB7(D))kGpieoFW$~rL
z3_79An#vrp8!1u%W-g%f{_{TlJ7xrNrB-Efj#l^fsd4k8OS5n4&|0_F=$1d*mYV$H
zLLKioq8%Uk+Tj#7tEf4~Kr|QaaUB=b;AZcE7*M<EHo^_;D{sKm><DLkrOfBfsQZ-U
z`Q7-UH0zHm;m2#>kka9n^iOL-RtkbMuqT{H?_4ne8708HeA&2h_TE=v3V09_fVt>L
zY>WMl^fpA)VySi`kP0VljKU=o+m>vx1Q_AjzyMqKM#*gb6xI>Wbx%HICQ!^B<JjmB
z5*&RAZ5oOv{&t@B=j`I#TU&&q+wWlJaa?dJ7#_G0EWb`NN;G!Z@wUGy-qFzUjw4)r
zHm{D}1$+}z+C%S0QQ9Z2XFp>Kc0(H2CF!;eU{QFL()b)=Gr>rjQOD^*p^tpt7$k(<
zoQJNRwFTRM=d~ty_Mvv%^!r2#+>ZGd=H#CC?0RAVR4=vxq<Od<&*?lpuuPQd!3CSf
zO?WWc&E8qjJTPvO=|~%!YXVl7=9QN^l1d{^Jl6zhR!h{DbvaSVq-Z4mm-1haCS9|*
zdJeN~GIrjV%oryroI;$diF*sS^C$1v<H9YDXsyLW?Z$`hG(!v+vTyH1skyYdf=OaW
zL>ecJIfAHOmk|Y=SDw^GFNkjk=3pi!QP_J2<*<-FLs=_qum_qD(F-E4O6nil6J7w5
zwE#wDg8n+mjh1!KwD&@WU&cxRGFt!|ExJA9=m4z34DTQ&+A*X#+vzCcus6&=fN03N
zY+MqiJ+-P{u*cqJj8*kUj@|XWB|smrTSFWdd}sMmGt8hr%+<N>yAW*-fA($D;>c`T
zDhx9yE&cgAErRWc2`ntO`m`jOZ8ICDedZi>s<q&m!td9ifL>b{2UPtQhFIT3^ZCbS
zReEJt;4JW@4CtHUb@g*3Tl%w+k^o3jEX%Lj4yfu5Io^cFoNDa}loiRMOY&m7qVXHV
z|1)bJM9TQz<hfIe@?M<xW!5Y1NddGCz=qlkxsB_M+2j4#1z<0pPFv=3Q_%*u@$3gy
z7S*6M7o0{lw?q1X%Y&OoN}z$})#avj!zI1#NtIQuP8uK6@G)naxu>y(!C)%q>fqja
zaW2ii`4^6(Rejg>X4AD7vtRg<8OOL%2xBpf2DB!<QWy@H&E@AzB2u0PjM^L>7ewiE
zl1q7-17@JKCoJPZ8`r*LM)_SwSZOA$(m`vAwC(|wXCNBedRwFc>?_XOl3M|n%$x~X
ze($-M&W@A-GZL#V)K9E^3nM%*00S_0+u*K@?T`FWtaKM4&Kp3pad}}$5$2*RBHIF5
zRgd#s)wv!yx7th)P4t1*z3>#4Btv^rz#bPQv!fyPjsvN<oV>zi^Jq{&@o<c>YL0YV
zrdlZPvG}NA;ZU$j9TWDPqfarzY-?rdQbaZ`8y0LAC#mWX%Cb#PwX_ChR=1S+f<%4`
z&Q?aJ0pe3%35{M6Wy?A%F_2ZkM>!5C#qlam%75s087w`P%_%wPBIpnjJpG6X?!FeL
zLtFAQ=GK7e|EY8NPnNQt82|x73cze^?*-T|3wYYXG;lCH$Ar2Envbi@<&NX}C^1hP
zJpW|%3xamt#{?fb$C!BX6wW-@9ZUc{ruE3(#yp0UCa<@a5kJ7R#y*FcIiFzPKNfE}
z+TGi)kBf8fgbe84^wfi9!<9c~f9)L`ZO<e#iB4g`OQwEx`A^vgWbwp+9elTe;KB($
zJkqisVV`y`$E>7SHHC@TfgZDB0+`@-L0wyH&<T)kK(q?X5a|=u#h)G|&}{&&R<9C=
z>vq9Otb|Rw<F}f-`+jEIj0B(xUfE_?bqD6Edr_jwAZT)=Yb%s?$Kt(QC8ygbDv*s!
zg$cC7v?p6ETW~SX@D96}jnWmt3S_O7UWP`M6*IWunMbU2LAT}&&qu8(K0V=owvLXX
zw_iV-hky2sG+=0pEv=%f%-v4Dv1)Keuq4G20}z|7O=ycfF5E#I5qW7+yc?ozr<S~6
z!d{f6v+dh!n0@pB<8J}_6xnS6TNj`B7)KH%DFC+kO;rO;d@JD@EbvN{{}R}F_0ie?
z8`=9`&Nwo&j$>u!pL!Mli`0G@0Br+k)8tGZT78Bb7e^G?1jtg5H?iorNT7k^X><Xq
zxI<4cfsX$%A^9#3c8Uo={2$(c_<v@NLii*ao%bI*|7&K12}qN(quITc+4-~Yb{b-H
z_SM#1@~<X*ZD|U=Rx`3DHqMbPnQE3e)rnH`;Mu}1A%WD6a6b1Ib=srVMJU4y_pnA#
zS{j)AkvW0Wn@5)1)}bIMas8-{3&J3FFfwg|Y9p}<f;;SF_p)X8U|e^f4`78|M#voO
z0Bk1)Ak$~d$|!A;EuPi)+=6i<@%H^W=@GQX=9{hdV-Fw6Tizhr5l2Ke&JW8k#l3mE
z?qTMmYca8LlbKk#wEzA<f12c!j_#EZqc2O6(s9Y+R*See_wI-z!KJyk`mx~6*?liF
zy665#wK(=F)8uu;)IyYXI@);DDRw)~eaP<9aJb!DMV&wU_S2*w8AuWUQ#5P$1*lyx
zw;brym-Mzg=V<q$l6u)VF>mPKRI&=F@8c9K{~=i_+RDts=i?4mEHS}VEQ|(VJHv<D
z#qYHL?|=d5Mq(kT^o&-REk7aN2GDZwvpmwInHeW7%dOsL3|huTKblWS$Ji|nQ6~a8
zBi>cvMN)<joo50}z;;XuAnAauxHvMzW_)<#FK5~)M7!$HK62LQ%qVvLttG@b#nJ5E
zigteY_T!oy4O@TN_e}G}$MXkTMx5~N*UiL>Pnjkra)%i_8d9us4N-tMlk8Cu7f50l
zJo%`lur-H0)s_^iR<9iFwu+1gA@*GN@=Mk-;>gx02*#_xcI#v+5(mq^zIGa`SN4Qu
zMtEdLOvvh5)~YL%c5_tr&DnMDX#YK_L$#t!M6a(uc>BQaIv9U#g=t__ZQjnibt=%(
zIPLa{=&Ky2^NetkWr6nCIes^eF{wc)T!t9x+JK~MeEkM9Dhq-hGw5h@Z&B?0_RT*R
z?nrZa8GB^LcMei5nXH~<^5|>g;2R%<0gwcsD{c{mbNSr6BaXIhuzl5HP1kzvQ407u
zEr^-<hy4_56bRh}=PV@|ax%eaPJod$Pu<_0!P=U3I~V0Y@17ZlOYaWYexm%M@$MU#
zOYY02Om|q~|NpyJ?SDsHUkreNunoXc+MK|%7Y{S*3^+PuuyJE#8n{Gk<5S{KY&IS)
zKVWb&%eshdwnV_e*-+yhoAcqy-vL{Z>_df*(J3Cet$Qa_{%LTHLryev&b|<3B&}#8
z1ddksR;=^8w;v}F>jti;oxJzD?t7Q48mE>%$E77NGbnG%mcw?*3e<-kQPTeJ7=d=4
zwy&KF9~mVAmV)3ATMiPXwgx$gvg**PY#leHv0ZB!4tocCikv8r8W>XPDT*@z7#UW=
z^A_%E=A+p@IXPt}v?WmU(whv>+~6Fp(B78ofMw_@MQd*EcBD>4tY?2+_VfqgBn4Ra
z+!JPsTM6fKOJ8(9LrxpU$g;GSh3&CBbVU|mG-izbTUjxjTC=ME35$L(fmCaQ%;W-p
zWV`oS2HK~^`R$v3F05)efBu_TO|US?V@TzOcG-(l0xT4yJl4xZE5`WfQzHq0hr5i9
zytIxu;5N{?XrjCru3VzznRl`dioRE{%bvE)Y<s#!jj725qgV|nN_ZFvc{e?PqfawN
z7olZOcTqeSc8oW9alu>TnxFM&eJ}x5*(1_!=lK?ka47=z>;}OANY#?%o;i!Bp2ktn
zWK&QgR6ZWVv9at*vj}WzoYoJn69JDiNtcOkcG(;Dh8>RB_)rRlho~c7d#D@>sU(K-
z;0($e?68{|yWneP2%{%7P&CQML^@jCTR3z5420t_G2>VLFlz5A#IYqHQ>Eir7Hcu+
z53_2w2AJZq4v%{$AiW6Zjj2wuIFCfBGUhUuNpuRaeN&U@02Qlr>B^=T9%mwqjtgp~
zSuAOC)V3?wb>Lut8b#}T3+UJC*xoU(EvW&zF(d%n9;(ZLqEAvZ`A;4yrCX^7TV!ux
zi@$FryBLY!Y<QmbT)oQvZX@i6!x?rAuzBs~$0h#QlY|?x?XZ(suzzG)dK|kOl@)yR
z8bWbQ#*)xT8Zb50G^6x4DW<xy#^UB*LW7FLu(EFpE>88+^xKSJJ7P??WP+o)oa1YC
znE>ekWF!C%M}#*b%Eh_2pXU3Mba}?cI2yPElE0^o8Suqj5mjCOt1U(tqjff4ro0p4
zqH>vF0?fwiHc;t#y@8~#$e~vho{jJtiCoqd!A|94d<?kYEx7I1^?$b%pxOaM;O4J+
z9_&Z_FRXnt03rY>!0W*JI1eLbYAzu-O^y|Iz^@eQet^s#Q5nY6aE(YdSiZ!V)kp%0
zKD>jDF-DgVd3&iT7#^}zJjba*afY*D`yX0IKK}2_h&~+rjxPI-11?VFJHLC|INDeH
z{u_SwZ7vI8RaM8SEty0o*%Fv|eN}W^5R;?1M<`>s3GT$xMwrJ4Xm49~*mb+0F7B9k
zWhn|_{qI{RSoyf8Fh27R(g58tFKdO7-Gd}YjwhG+?6?(|({aHuvtakVF@SV{8J7v!
zLF@^~(8o9hu#Lw6WQo-Pmwlo<Vop%Fq*rWM{LJ7OE3K+uSz^|rD<UIQqgGdh?KRJd
z9^WP5*pq~9ruJEV1(i0$(O})uH@t9>8Gqw-tKo06_WDo#80KYs$urm>SZszk?c$h0
zWRM9|M_2Z(435fFS{$%1Ndq{6GNv={oEDi9^HN6vla=~tjs(Eri)e^Qts1AsjPmm3
z!K`VkqV)s|rJ^x10zW<fr|5}?9mf(ADW>QAx_Hqs-NcCTUG|bOOX<T!?tr6>Iq4%E
z^G6Zv4ltZZYg~7UF)NpJBu#S!6*GU%^R~9(`*D3U074#b1MH6%jScV1P~vnsbw-&8
z-5&;k^Wu&(uYxZ5bmRTe;Bk(OFhF%UP5Q?n*g(XXg`dF46ms$5QnnWEyc)POdMw0F
z_>JSvHlwFRrhXlHjxL3*pMM>3ac0H05N&Pv<#$bM@e^@u4=?T-mwC}~?r0C^EI=B7
zVig~zV+4Hs4!Vnz6ff&K839eAbIcsXzhiqNQb&Wmr9Lr8X#gi4Heo(`<C@j>thKH*
z&h~{Yo$YW=C6wq#BXYME?=T@N+wS8lIo>8a{Cy6#qfCO^9*#A&SOU<dsk=}5BJ<IC
zvG*G=Az2#+ebVEwHo2eSohKeNlYDP;kPbC;vL^nq?ZE4ezMhxjZYp(<+$0r+U0z8r
z=CIW;4~vXb+#o7Ze!p$0v7w12$qg6}YKpm*j>{a5j>SKu!|mRp$Wfb$ivupsy_H|q
z_(ti+Vm7C={USZ5DlV1)$R>w#4z7DE-ud0zk4yX{cBE?o0pk;H++f1lI2x!Uefw~q
z1o{}+_7>f~^J%wzinICViF^GlZ9mGm;YU7)-G8LW-e8l0(axRg3zlF}QWjpzB*?iX
z`;Pnx5H4f?zwgOqAPfLpNDC%l6GUCWGun6cssdnw(HU!N8Bijk8qSWvh#?Jo$^m<Q
zxuT-sv1tF_`?!1*{y3hB7c=qD9h@?Fz>l60f3W-hX7rO^HI3xRUz^IdFaDI`2p8|(
z;rJ%A@y1`7sRwQz$Yd%*K9h(Mb)J8SL4PQ7T+rclZ@;0uZ!?MRU<5QMQ(svS)M{ly
z8o+f{Q3>RHkM^-ARxIYc_|qofh*<l$V1EAc*xXvOdevU`erA;Y&P^z^HD%1Ck4blQ
zr`^rAtekx1&vLrbsnWEckH-24Mr=07l=Zr|(;4~*X-i-uhM3l&D>9;0H40}zFyu`>
z(J-7HjLX8QG&+rRMXV8?_w8aP*kiW}f_=27s;iS56E8h&HnBA%r8}A5m4wa5U1j38
zu;TV}W%ZVR$Ow`q>Cm*Qo*a?{KwAKw9e_Oeew^=j_*IF-PX^y_u<@Z&0WB;s_H>Vm
z5ccZmE5S~Cm_YV4a<+{e*c82r)WD%JKzab0C$etugN!-(qbY-O9Wb(G{ID#c-g=b@
zp68^*%sPFDI{W|JAkYqk0T3ZD0B`X+m1lQ_XUYZdyp8>41P|7bOFgW1C|2i|KEX2&
zbq=_?6Z+(jVK-olLcn>$xjJ5W!==W|v|Vis7L9P^ZwQgHTV;#zh(`Z^R2>@=S0H}z
zu{6#2!*`pB-&{1<(+jkT_BbbA;ObEZXBiLDfS2I)S~xc@C(>sGtOY(!cFf&#KQqD+
zxJkAiT6MQBJQ_N@Odh&jaJ@9dH;$tqxU&^G`>ThJG9?l1!KPg?t=4s)z<jnfCOAzY
zi-o;PGh~-xn<Gx($Xr^?UP4kwl9&hGc|RYG^~nho7In+rprk9b=M=gdc8djFkx?cv
zNpt)T(Qc!Nw6d^G^D;<8FD6E}^v%&NeOz`kwQ^}k9cxE0nKWsKjaI5P-%5onlNJAr
z9tjEmmWqoJ7REty$fQ2;*xmV3$t=P288HAum>yQ+<-t`E7w_JFoDy^6iFNUT#=r$z
zaVp?(CRWDFnRGJLBkQjPTfL6P4w5j>YaXQ?v*x&A+U(Ik?oe>wZy}5hpm78Sof=oO
z5YNIc%0IYxCMxrnEV{=B0dimr00eD<3D9|slX(UPw`(P(JjF#lX7_#I##zzVbk-)m
zEd8OW++oIXpF>TE{eN}5_AuRvpd(F3)UN-<%zh|z>c+{RG$SXRVJB8crB7RG!gLvU
z+dTRwQ78Lm<G=V0oPK|MOCI>P7x?zL;1drpkF-#LLa{0q0sC~i0=aQHkx9Ma`mJIW
zlgV7{u(voztQ*sER{#!4-8UNh6FM%46-2uyjHNPr);@=>x}cR`jEt-jE@0AX0DIH2
z#gVa_n!p;^&foT^ldPUW&7$e-d{Z*bEQQ5@<93@?a$$@Z<~~=`4oSFiowdj~jxi}&
zWc0UKvV(F**o*MI7IYGZ{zzBkKy*d6<5D3^OM|m7N8KgW+Qj`HlblA9qN}}KP^(Uy
zYnp@x#o3hh+vdxOvl9~E@+OXARyu>v7Qo0+C)=a94o4B}j&veA;u4zLDb}ZNi>=lW
zy9?pV&sJkjVpx5@wAw!GL@TY$!fI2QO(Cp_UJQ$LynMIw-X=Wj)5)T-6oy~U`DOS2
z{##KX*Vb|0Qg{co${UWxe2dlpO;s{i$uqEt`rv~PR_}j@hck0CctapxTd;xsse@7I
zsCXnW+c1Gn18^U`dEv2i6852uRiuj;i?T63Nz>P_3pFG@*H*v`xnR$O%m~*0f>;ug
z&;$Ooza47(l!p~A(v(fV`o0MlKgq~Y`?IKCQ&v$^T+u60ePf#)qMHewK1L1{pH7z?
zkF_oszvG;U3Uz*4w+l890Z+cMn$`OonY?`j#V8?NSpW2+c28KwgY0oZzoqktu7J|D
zx)cQG?YhWV`}eObuWvJe{qHT=0!W!Su7E#3OQdTdy#N^)8pm9)z4JalbNyKQnzhLI
z;xl%OMT~$})vhfZz-*WF(|y14`(YgyY%n&=Md5OU<B=0<-r)B`S0oG2A*%YOA539M
za??`u3|JixWARW7XbN`>D=$t-F5bOu98$PVkKJ#X<+yn9OIrX|39wiKkb><X5t$oL
zdVAfU&Ld6y0Oq;{Q);&Y`fWc)OSd<80(5+=`FHOd^XbomuxXqQvG=~b#CYtSn1bWa
zHpUuu>pY3#vX#C$Zrb?u4{3wfO0!KvqBxoV!eV=1tFwVI0HO&AfLQCpdDvi?L8mjc
zC_Nd(eNLoP3%e#C28h7k61YApDzVeCr+3(gE*sZv8Y0s0zFRw)iCP5J%*?*`Fh~9x
z>>+oG{v%jE-Fy}ag2V@xJ#oi1rg{4nFfL*=r`hpQx7Z?)f}j+iw5KXXDEIq0y4+jT
z_<l#7&j_^BRYU$5u*P=Y!;I;QUPRbax*=?UgO=`l-zXEZFc>2Yj9O`GpEB3AiOWsS
zi?j-DC{B(p+}*54he9T6t2&*C7-Ii^KBiQw-gwv*HiPFFle44~R$)=nm8!~WU4hf>
z*kaj$ByIwRUbi(4Tg~rw!(|8jvap}#{F<D#)gWDwCVg&F3WEJ^X{aB=3{IdZDkDlV
zQEZRBdL7f@cW*U?^SgH{4$b#X58RF^-U{P<vIVeHDNG-}GUnlp^0ZUhzIJ}y8Yr{e
z_Ef+Ce|zCBblSt;mhl0po|E$Wv}MaBY5WF(<_4|Q-FJ@^DE#ObxmA{T?ue3wmI(tV
zU|S)$>*_YlOqOX3UIpwQFxL)D>@Y9}K$V8DNtgi59%xt0pfaF-6!uJYmvbl!e<G%)
z3v?uqqk9I9-gXw?jY@9M001BWNkl<ZgxddSuR7~W;iEujWEYw{t!K(LPWzM@I_@;P
zY7$PLz9N5=FHS|%c8W8z6PNyLHL>F$D~33B5}N^&+?}qANE#^F<xN;+^|0i48QNY3
z048LKmFHqHPS+t%>1Mt`o@u7<>A2wf=bws>3+kjp!CqxYv$YBBNJ=6Y#74MraSEeB
z8>OdG!>LW@G1*0oNfl(p!2Lm0;_ms}j4A2FCT{0z4)B&c-9ccF-L1fw6k87?+G1gn
zlS^ob$t(-!rrAiO0nk5>{xG!jo*Yws4P#Phi}&fYtuTpHYy8z$%<#^;N4I3gOn^^|
z^SiguCVo8fOG$G4p}S02WelNhMyw9Nj<yB~EDvrH7sIz1y>x~BReu!L|Hvif30i52
z-3q`E+v2BOmg#@bVSJX9S2_|U*iva~e=aZ!?!UP$sz2&9W7skY<33daDnAJ`^o{F(
zS$=dpzhu9$8v*d&d7c=c0ATQY^)LWhrXXW6JMqk%la?~#y>O@9>?*SMaHkF-5to!k
z#M$b8=ntP;r~p_9UzW&jzI?C>bS14A?8N|&DN9}D={ui3->*D=SpF6k^~Qh6<iB#U
z4`Sy0h*DcCmzoLo)pZ%ka4Z7$r5TQxEbSffeg-d5t1=xI9O2l{B-=gBHHh!PI}isG
z(1NMh$kxv|Hr}Pl?e7WK!jVJ2bPS{`q2qIP_ODy4el}srZHx(NSl2ek6H+aD$ebEf
z<H8cr%QW+R6se|Kx?*`5-%XCTbzNl2PkSa?Ec8}MSDdbh4=ziWA5Q$SCkYEYkCg`K
zmOe>`Oe5OT=yye{evD${INI{Mx58e&Rh0?w2y7t%7)N_OtfE9L27oPqh88L%xKwEm
zMaJJwY5Ss<_QQ!EiD|%ZA1+_QLT84=;1lS)9m<w$iL!S>UqpKJU-|=&-;c5$(~=DT
zocje6BBklc@%skPJc{-|<NM4W{ZrN0mo;B!|G!TKmUPVrDgh8^7y!x8nT72wfd%qV
z<s7g>OcYEae9)eKyaLM^OG}YT(>356wt00)bmg$_hn85n0E<9$zrf|fm+_RluCaqy
zL9xL_Bl;gg>%Xzr`|Zb{rKc?H(sbl+;^tqQ)_pe&j;>xHG3bZv(@(yD*;qut)`Fn!
z6F`Z}(OLx7Pfz@K5<dm4UkYvZcELlq_k4^=i!C)Nv<=EJflRD;$!vJ(Ijg{@qls?y
z+Aj)i2drgZSQBF%H^uq&^&E4R!lE_4qwTI5E_YCM<)vW9H)D_6A)+1Eal1iDSJWTa
zVi{*uy^+h4?3RF-7;rk5r7a1^o+L~G->>pE%!E0_iIh1Q;W1pAHOcWl-38E>6Wv@^
zHTm}2W(>=O?)vQnr^6j1A$#JSS9TZ1AF9XzND1)BljF;P3Qhq4*ufUE$nXD;Na)Oy
zkd`WMW09EJ3H3=P*M1qNHkx9ewgC<}${5ccfS=i?-H#VDDQkW9nD;@)MOIy_O6XF6
z2%vD@xcXvl{d*ysG85tNg5*k8|AkfUg@}5iK?Mvj0Lmqq+66od6qqrm{T^&bha7=&
z+^|0hbftq;jh%3G1ZSUvjgbW^DUFo46nq)2;KMb~(&47tX;paY1!m~jQxW}Rdch;a
z^ZL=2B0o(l;Hf9>H&d5?ufC={_yhLSf~~QWj>fs2=rlM>f50Er>b3)%b#w94W<s_Z
zq*x_sKrF8FY4`nIQTUlP=)+jd;ke)sXXUMe;2^I()hf{LWj}7k_SS@~PCE4ILg2o`
z>ZA5iHhv3<=+~obp_Q%_7Kf}!+iC<QqfO$;mP4e@fI1iZ1#?+VPhy&Ra^=$g`hbsu
zJ^HCvUq%Pw8BTSKm{C@qfsQu%tKFEkEQw{|Bn>#yJsCs6afDm?rZ_G*h+FzvZ@y+4
zJ0o#I2gT8<YB{|AC*tB<dc*+SQBeYbMNGB;8vL%#CGhYheh;_BqkaklY>)TR21WU7
zUI*BRp>~t45lk3|n9ZJc2ffzxJHL_Np2F+X-a&`xlqqA5)Q0E&mI-&=v!i@RnVg7_
zAFP2@(BPVj1}8bp!BY?=uKz#tyf#Sjzi^e$Zpu;9i9nbDW@5t(YS7x4K?f(waKu%?
zha=8skcgc>{=2x`w>pcY0E?eBA%mH*#wWU$PI5?0b?0?6Vj5DS|Dp4~z$A?59|95@
z3hL~qTR&e-i?ghgmw&&Sy#g^p?5E4n&@fuGqi0@d#xSHYdcs*|^w`rli_B3Z>@ft}
z?}E`4gg}Tf`w^2#0c!G@hcQbKVmwHe*N_JA`^a_F#l}{Mr=Tk<1wl>DWBZ~IMxSY}
ze7Qao6yxo9F<3|mZ~Ubv*&|<NMqo($-G{dfz>^P~N!g3<!P)x_UVPGQV2|2vQOE#R
zk-}mOzjR>D(jaL7eNi?80#0^Jyuxw8evjLEIHb3+2`0vFv51L*e*KzR8q30dTIBa)
zpnrtRt7Mm7#-ygW5UDTe5EE92BJmj4*{ZKOOl1?ltFC1L9=Y3utD&Kr(-weq0AQ5$
zeK<VwBz|C|{e+-z@}8TliCuScNT|~J(#ZWZn*wez0U>6RO-;#E8gj+Z0>-)nk4TN}
z9W-S@=_CM#wd|q<>!`W~wyqNnT_4}L{!&)|=!ng%6Z*?|zCQ@de_7H8&HxAjOh6MR
zKzkJ*=P8z<EAyb83<K=}m&m@Mn=pjJ4g6ivNj#*<j=?PC);79N*CGjg6hzETzvAKy
z@juh(uv^gh_*Wy*KONk;wl9h)4R1hciMtBI$B<Z5aKSb^nvv5#ZN@(GSu=X*F<dgV
zvsKaxn3$y*++aYKInoiXXdV$Gu=V!r>n}5=pGg2|z!Zu`6U&yEhAgk~o7l^0VtW1h
z)%ELVm5za|63*p_QLr5fg6x-D1wnt5uFy7xSr}xeRxYs``~gO#?CQ0q2;RXCn=P~M
zNzR>1bG=vRR?}=z7?i4{5pP%11@O8KuGw<5r;bC;WtBC$$9`r4eF%G7W51gA4i94B
zNo+7|Sn|9H=51lO1<bI9u=cN?rMWZQj%oYc#0UNK=P?u<8&*2B%8K(H`r2<K7IO|i
zA=(B2nZxJaf|utP12FM0N`O@u0Br%ld?ykB4^I}pusM8UD4R(Cnq1N(!(p=a=R23r
z#TA7E#v(CHA<X*pZw0WplOBLhBH*$#Ia)j3k_@x&A8M;7UPN@{DTuH*7!M>x2(J0b
z4AilM5Y3~1HYm$~S?JTk00;>TfW#K4ZJK=*o-rpYRSj1E*jD$Y0K(rMCQ7KGgIKYc
z?g2+5y>dChe`P5WfZz1B@-3k(NeYfX#|)i#mi=h6b*dERobi<Ie81t6?yFvj`WGEw
zMlbyL3^W*)K?x@^d=p_xDe9^1SV;x6-7pGwLrkppI#DSK^*X6)C51B71d2T2$e3j^
zq|oQ%&DJ?-s1i@R41@kC3T?YCGNX&$Z>BKp(nRFkGrc)Db=B)8Ovq}WoU_X!<ZeBD
zc5JO!8~V#%>YKLKJ6JU2a+gV@G{b0gXH7G^DpVd|T><x|exvAG%->)48*t}6--WdM
z2j!%-FH3wA*ry-mCbtG=l>LF-r#teuW7@um8oyh*G%=Zyl8i86s6VtgIns+UDKW=$
zn4C39I_Ge>x8ghebr=9>)fRx205HOJz={#Kr+yc~*3i@3*m*xv0Q5H+>X&@Kaz2c%
zVSV%b)*<(BlwQ1JA@})DN~Q-N%iS+X9V&v-sRjKRZN>0=)Nu}nUHxnCUj~q7)`^50
zdA`A-dSW_I_b?JwBLfBi8L-`A_z3UeYNZB~D`3wvl&xo0jak<o__HZqSQmYW%haBB
z?7Ef{m-y_X*q*+<?*ZE3%zeLaH#3B-|A0Hnoy(&w8|Q~xE0&n%ufAW&+F!882h7-K
zf8PviJ4DQYKBm}NUmR@5GL9&nybW%B8|EDP6b667ezk>}K%^k3qitI4h!L@ve8f?V
zuv_OR75QCW4SvJWE3I&y0GXtX`Vs*rfFqAY@Dne;WNi{y<v_0;ZH|~gpH3fyR&48@
zddN(2Gu=QO@Wz)u$5q5j%n(QIM3e3B@gyJ|ZUC%{&z1v@H21A(X0Gj?K)Nze)67f;
zY71SZ+`vNNFm*7x0+x1-=x$Tr_C+<xoAg~Blf2MBgk1-12_Sqy67_Wb?;3`0Oh$T;
zG9_?9)Xg6vF`1AOU_}YQFib`R36^s{e8u^bf09NcOrcW}V*ISd_E&(;liN-#hT~G&
zZwt?E1;7Nn@YM85Kc!!^AJ$pLtW<DGUA35#LUHz+D}j-e)wqsgcW}*5XJhrxp0fGx
zto|P?A+@ihX=4E3SaePBt5C;M)hz6b%DRQcDM}YWSH<RNd=?F|2^tN8-sJD%OUt1E
z7$COmuqNmV58};$5}fxX6R@(ftMClWEPZ+5kp21Q)rkI|rBC@IVFs2Bq8UB<xj!&N
zh(!JUVjphek3C5k09vK%T)!r44K}(WxG%@R*h0&G9OFA??iSb$VC5oR5B*-a6mAcZ
zAMZt5Z#GRL>@iu4lR_Am7uiXR$#M`*TJ2g9&)@&B+}|%3M@*pA0njaaz1$g}3z$gi
z)#R-CdYNYCG9J4{p*_;LJyk3j2#a9k#3yBdV~^XR!y(2>whSg$F0puXiq(r!--Z4b
z$8I;F<t_S0P!O~h8ELbGh8U{f)jQHW%-J+an}%6EPI6RMM^)>%fQ!oJaFVD210d(a
zF7;zjXyOsJ09IAd0igd6AAJf806G8(^JCGaCjJimj8{!D083zO(60z5CQL*68}X?p
zpT2C_j<9}b>0}_Gvs(evWgb^LD{Ms?+3?R9pQBnw|5Nl^U6<^a?&nVX{jvd9{sx@;
z57bUG?-(@A*O^NZuS}1dHU>cC!T@aGrQUxE&$QwKe%py_<8JkEPgZl%j`apKm#KPp
za3!L5VYyA4On@alvuatoz#u~hA7_S6`$Vz_mPboAE)~{*k8)A##!D(~Qw*K)X^t43
zl<d3vtAAC?hi(0FL@J)Pmn5J?`?OGs>&kRgX)i9|n1l(?1U;nt1TgGUbxR;cTLxE>
zCJ`_L>KyFf+xrA0cGoea0k{@g)AKl8qLT<&m*CGP5Dpoz*FA+2;B*W`=vr*T$dHWs
z=<K??^WKr+4~Q<#z6%r5lO5cSy`66!6HMcMyP63dw_E>q3RKSlzI8EHlU$*@39WV=
zcO2rpx0MEX^m*P~(*5+TUzZd~&t*c4XN_Z{(o-1o7yu#8!glpe#p^g}WeLED89GuD
z047H7i_Bg1$H*)$+O3IJd*~z^ud`O$erFR%RGyh!ecA*f8@6#`0@w;L90j$<sAF6M
zeTj>k&u?3DF_5LD52UHOX;H_mm5pmJt~6fufi|zG2Asd;xlxPhybObgo7PDg20&xl
zYM%3Ww&5uo<47K$(}@7MT5|weqd8IlVd|Bb+;Z&m2Dkr)+Yr_auo509R^tuK{RS8>
z@fn&tTC#CAOc#=<ul1|%<zId5p|aksIX8~U%s^MQX3~5{pfiokab%LlfFdSf3K6!c
zVa_&#HXUR_ZerSZ0)@5!*b-w~Lr&>jjuac4(38odU^dN4FJLUju(2?-aFMkcpuPOQ
z9Y%BJbHS9o^ri!AF?2}))^i{I<kIQehtzSqjhM7;v3;Wx684t6n8vyzP-lL64d3C|
zE_;|!q$|2arv;PVw<%uNWPI<<l}lk{nAF&M5Cdl|GJ4E^mL@;!`vuYuTkCh6d*6hJ
zyOMF9m?kj|W5=D21OP=j@3&6DcJ#+@n}%-2gbV>y+5$iVa8#QC@F#wO^l@dw(g6sa
zoqWEhaP_MuKx!Ir{ML;zW#wa%+c=N_7`9_VlnbZr#y}l;KJ++ydcooM-&uP7v~K=v
z*#Jf92GUZqZ2G>r5}Fp1_FoYHzh083?<8%SO`C&wwW%udYo2WTP8;3?@N*Bt!94}$
zeAM}|N$EmQZn?MKsCJyL5Nb&R$BBXy&&9?8`jp;)rV@FyWaAVLImXhw^-2>~wDuQZ
z$t;M?AlvdDdC?#fVd+e36P2V%3c!Fo^!~#<C<E}a)zez?lv#JtKbW;w{{l0=tNE#Y
z>Z10EC~f<*VNv2}&8F$1sQHH<XSV(7pK$5Q=_p>#>5p&*+7@*C__8>&X;Ika>JNRl
z(#=<wnzvvQU%mL-W&^q#t++i^E}yRa_@eyM4VlZ9()&L1yJm}zewoQe>w>|#)*D<g
ze91qXHNW~1W_daL4ddkK78d7st?9zu(qzzQ2xYmtF6xgFdzpvJ!ONy)zjK$b<IO77
zIe+r^;VHc%OuJae?~%CImNG_MWp8`T=2srYWnC&x)m*f%2~PTGhXQuCT+d<bD;O^0
z$#W@M@-mdfb(E!j0+?a*JW`*TcPKlU%Xt=0H|l9+07N`YfRq8zps>b)6g6{>BWS@r
zH<(~uv30MGAHE`W>2ic5LPHceEpB%%`N80iPBo<QM%WaWjZej~>TF7jUK+nvKcYL8
zjV?!nBKU2rZC^atcm&9+y~T#EZ1(Ikbf=<P4qY)ke#6hr+Kc~*v*J&fmLxwQ^+-tk
zij%97=JION8s%u)wx9ZKGymK#Vs@2nr9NE93NOOn9<m)hd2gYzv}BmSK1e7ns`L9B
z@43#r_Ah^7-hS{7EHkbHzoo#I%cC(bPMP!K6(@zutxx@^+3vUhcQbOp(H8EY{%K2K
z6Q^<3{OB8I9sRzAeGW&5a5%r-axU!qvuRqv2eL$1$JxE-eE1Gb9&VSWe%IB-``eCQ
z<@f!CVb_=Zi@)%P58Y;3x)e>CkFoP<EQ_;gGN&#Js@N%+7RMHhws*6Ox@?{6;La->
zu+13UeLW_Gr)~Saj6{i%f5D@<b6VZBGXOF5Z2sEg4AWYfT;R_<h$%=!&yM5G$&}Xt
za<X+qCFR5|%B<{kIQBCG4DJ|?Ygq?U2{aPi9?sl2B3oF&YUu)tDhvvPPO#g4rg88w
z?4w2oOnkWVr^D@-wl5(y`c6r(mb9dgF<lPEX6o^~%sb!vE3^J~ZZ%y0PBKO~y7ZQF
zVc(xk%M0srnk`Q`&usOD|J4lbg@S31&X-bXV$J_+w{t`b+U*6BtRBheTCBNpiCOcL
zZ<^ItT*UtRD@X&P)wBw_HthCJ=S|mC26E=1(7OHS{}(gw?9W-tlFC02$7I$-yuJ4O
ze`Vgj;aBL3py*a0%@96U58ofPJ8AN0qJ`dCE@>~-yZw6#h9CC*F3noh^e1N}<T=J3
zm6ywd<I=L}mLkUl*wXPoOd&V9%q(2J(gO6$yKF^qww;uS9!YTG*@)@4bVUaDR-3R@
zfoLaznMY5O*u|4u797E|j~jyoc}8wVP17inuHktomY}Co2OOFy27o1*`4^s<XQ!C-
zg1fFW!JFk<DY+e?LSx%<Xzd!bgr~(F$V4p5hS`r5#CbG##BE})Rn`etJYR{tVE+%A
z;m`aYW=wZa<<G+P!}3Q%TvQ|qw~M>5-ILWm;WRo~5ZrkAcg@>B`wn*bmqa392yk<!
zqeUb*zut0XVV6gejJY2;%xwMX-!VflO0}H^Y<^48<6!!D+y2OxOqt2(S{q|u1*ELE
z;g-wIsvrEFS@*<4=t6SqrU$W2uj-Tk*G@^dv4w+v$S|ilwmJLLW~<Nqes68+(UbK`
znz7-^ADTCR{?C!}AxItlKJ6;!!q%^R@#E5*Nos{Fx!3?wcK=^^oXh%?aFx}+fP|73
z`(IxKIe`-elRC%2^4HR*P4muc?N&fGV-~K`ZJeJVB|?o^vfV#ur*^@Dsi7ar`Dp8+
zDk>YmEC#n<)t?cwy2P~eOVQ}ZJk!4V7s?r70N`ZQOYh;imZzxQNt!12;^QWeVoDc_
zWIYomBPUgk?9{CuihsdLm{CAuJeM{i^Wqg};}QM0xJ<>0{=4CZTW_5G1vC7GKQs;Y
zXl1M>ffJYQ9*!mehsx660*FvMhp8lSupWMosRwV4qyhIM(nSA3E*a1v%+<xwSQhTc
z!vHsmeS`Vue73$$fCfhZT9|rgAJJ*4jo$LR2QDy9nc){JqA9+iH@^3mX3e#~G!rn>
zku)HptUc|wX>~Naw<vc0Y@L-Rqd5z#uEl>eV;H*XTh~HBorC_#2W~QJulTW<l8q4J
z^~gED4fD^@7NvUWYI^;4RVQWvKw&L{8})qaj{(c?!oFXTHr`v|#zpd99DlSf29|<F
zLSfh@@UNgg;e9tUc07|vPP1?vF^W$r;v)6d$(&O^5#6fl$M@@(1mH~;TU=sharX$X
zuq<;#z!6MCf1d>>vTo<Ob0${*s^5$-0768CHu91b;BAFx)Jdd+hJGN?Q5RR(G0Msz
zZZ>bfQI?~An)b@2OtZ@(%C?n=Isid%F3pNx`=)8#gf2<9lL-s4+V{o(V1~~6RAk#b
zBW=jSSJ;p147X#PPeWkqZJ65{$EZ5$S|@_vytU#*v+?KOGVfe<v6)0i!->!>P5jef
zuZqO4q)vWVemOtRMlc!7;aJ=7UI*G><$qRW8$tD9CjQvtCZgmm1exEZGR^^Ilr&)7
z72h|nqae8PrDshG$yZd92!UURgl;08Uzx3+>`C6(F9@L+D~_RUbN*M&7N7d}D30!2
zI6*0YT{nr@>kSWazCIS4i-v?I(G~;rX^XQ&iP{Fx1XR_<lemNHV7aivW5E${ZDWze
z`U722(Pp+BLxh9t%9MqZw4(YjW`vkE5BX-3ybf^uw(&WMNfakO>=;(SWMsfq4@w7M
zy)5MR<`VjHiffLL#JJY)oCBxFC@HIbo4Im*kL7C@n=u9;rVQ3<mZSh^xCZy#TuBM8
ztb^pXuucF}*<a5sTo8!`KEoOO>=8!M)<GW;?ZG34C!;y{--=<P5>8g93r;!T41ewa
zV9)<3BcmtIW$|Rg%9o|X4@ddE7zW+eD=*LZhZS<{aN?$4ns<KuO^%2?%A^&EupMQV
zPX4L=RH68ls#`YBg=K$WM3w{V3~(B-<F?Db)uwXUcpJ9c2J+3mn|S1Q^Txk^-MoF*
z4QBG4wNc-TiFW-kw+<fZdFd`$_ev}{{&cg|SN<dSO0WesD2JZN_yf1a`T)^y?poBR
zN9c0Hbr~=>iR-tEVfwJ;SAuIZ8;+u!xBHv#Dx$WX)yJjSY}n;ge3=W`18>n@_F^wD
zqlK3Pv?Gc|OmNI87-Spp=^sg4dsuLF(C5|3dQlb)RA1(bS#Ton1|A0OnR7GE0En~s
zF3(#tSH&2UqyYDFBH-m0E1}k}QOW7+wG4m+90PK)9e&cem@?j>5MVBSMA~?03YRZ7
z;a%*wO!BehIad9R3)yo$_w(2m*o{f7Ju&&&vv~5tew_U2u-5*p{yB-!#FX!>IDY#k
zmJiqe;IGa4TYqDkNJd1Zqt(%C!~D}vs>Jw}yhVE|j)8qh%9%y0C>1DhDL8SSY+NdA
zX9>k@9<GH2!L>+N-e7Ni(~2eN*rGx1k(Q#J_-t5NvvDqL!Ju#_LrhzL?)S{x^EfW(
z+0(b_J^s@%!KS`foWrNLb1tqU94N-m>2j33V<kXWDg~Q>{Ykyz>2yu(6&&BKRZxtx
zI$W+~Hmvx(IF~>5)^XLluQTDYmm*?a*&F~lQ4uH|CFaIZ!(wA#4#QPOI$c$_NgUl}
z1n^@7^y7f7kE$o7%E0xICdv4BVo7-q#d|9<qYOa2uW=8g-o#VbXL_qjg;FSpS!;dq
zo^ZDkl?YTPT(i2TNuUrvig*S^Gkw@)G~}icDRaN!?N_5MySx(xtJUCx*eCzeADf1b
z7GmHeyS1E!tFRxJ4GW2%?!tatll??%c2tS8<aAtc(`Em{Iq`op6U&z{eze88u1=0-
z8|I&521If;kK(j<T}uMsiJu*=ENmZ-pJ%qW07PfXF+of`aI;zSLyp@$c&BOdUHO{!
z%A2i=A9k?(IOlg|hp;ZU<(cQ3Ex!7vW{69v`gI}4x|+H%)C1&jy13l1BHfDKD_iQd
ztMhgn*u20go%n4gxQ(i~@^Apd)xoDP6<1Z7@#+#gmW1{wXbji~nje+qkix4~2*iqM
zt?wj(kmJ#J`<711RdcF$S4ZCsZu<?41$G8z-ibubiFeO5>KSDK;>v0B=AU?GUKaqQ
z0piOB7O={W1;%vRSJ%$N2N=9fXRIRz_7P<L+w5eFj?l#R!<Ae{Lr0n>7%c9E49uyO
zsp!MHUvU2Kn8v5DD2Tm#cPm{7i~^k5d<y$<*|4L%#foc6`)YN!Nkp@bLGG}d33kQ6
z$S!+x2@?Cl+=<Y$WAKoI;JP3Fo!RslXT&pG0*+?CF4oUKJ8;JdN%{!78d`-_b#Y#m
zmveCP-cgQp9v8RSylKxSTH|m3;IGV^=vqv$hw7LBS4YvBS3eh5l%CX4Coc{<(roqR
zKQ^N$p4aE^&-Z}{Ig(37bY<~7yeax50Z<31^PR`XXe~U7cANMknqtY678Vt8MI{{7
z?K-t%I^&!^jGw2-A3l1A37>v6WgEcdRT~w#B#o^yquWa{jXV%XyVx<8TTQ#Ugod(=
z^x+2EgTceMrN_*&GJ{Ri-v76FW^C`@kzey*t1H&~8!15R;DZl-00=kpe1gXc*LsIo
zv!sp%N+A%7RiQgu-vxv^Q6Z7+8yP93h$|h0JN!grFqN9cSVluTjiCV1Sg6T1EBfE>
zaML*JLKEmtY$mOCnTTkG<@|cqi7P563xtz*Tx(j-=qIn}IQ=lR{}E=0qeMdscjxYR
zG>SFRa;iZqxE5!Wb-7UU5e6oi=dIiJ<ZmtGUiqK?gK3`qc{BGoE^J{X@9HZmU407U
zYy!EoQVqXJ)Bpe=07*naRI>v$M?ot%r+}ucK5V~e9_|R8OYw7WCVr#=o38)4waLGL
zem2*;SjMNYsLn1=QMwcahZpW<w*2Im&3cZgZn_Z#HN^S7I6L`)D9mZjEdC^H^XC*O
zBS4clvwk$$w#z0kld_p9T%3Yjm459ppPg{?`<TtAep^)vz){NZrprvg$rpRKN<>{@
z|5b7aEjn3r<SEA7hEdom^@?%izEobfi|Qy~iD9u08ghZr3@ADVH=`__9Wx8^PeU|&
zwdUSfLOu=Pi$Tsf10YhU=-V&>{}b=YJlpWhtYbeoc;I#up3G{Z;GTdiLF!EHPuNQp
z10V^&ARJfy8Y#_;jpafsq=DSFvtwb-+>0d1H($x|zTl*fnE<6Kds#<jz{u7q4@Z?a
ziyu0Ccy{tfQLK6WFRJaUVP?01Rk#s;m!VzJQP71su_)BS)xT}FGec;KkH8!>k3G$d
za{*KHp<8=8vm35mW5zinuA9u}e(;23#U(VZK6tGwjjJ)B$@q<(6dYjhEgW)L+%`^;
zZemcxX6l;HKWf%ucxsX(VDqtqKZNn5RHumP&a0zerQCEPb-~X351qqJkUN<Tzx+3h
zTrKsBb@!|P1ILH&`yGI6oDKKT{t=w$m(9Wy71=n2t=PQk7Jx3PvP=dAT?dLQk%g`3
zBrax7;;h|Y%b({s@vSB}<9rjAOu8u?K2)SQ=GfDXd6I>|>ScaPZ+<cU8hdqZdyY%$
znUj`^(y>1-UNVcHOhwON;B|0)i#f6PV-0-}%hxb#?rtzk>v2|GaOX89SoyO3c&ZYR
z+o`0H%9W9QJFO!5Ktd_xWxr$(xM;|wL$NECptJ)ssR>E&cIO&jj`sy;T>$64BXONS
zcOI-f9JS(f0^#-7%)}KxG0m%fRE@JntUr9lg=Xxtzh{PZAqlJg&>I9T{)7ldI!-JM
zu_Bqvk+IQF{I=aH@S3TzH^lPUIQkMzjDI-i(CF=4QC#h_;o71BsOAy}GY^MLbMKNa
z;filI?{MuKX2WkTGH+pwX_GD&N=zSDud}U;+Q@(68tRgwIWT~8KmH{XaNTrW=WkJ{
zeVub{ofl{GXvJKE*|W?mWgJ|GN39V3`7u%3L@_=E?L4`@AtYmVHQ!F{#MjyG?c5c8
zQV6{38WS?c_>}sk^YFIQX}g7tZDInf#H^jtlMkJQq9esMTF(T_7MtMK0Z1i!s)RvA
zWNzWPx3}W`m+G7m`iEH+g4EMx7eFf6Gw<L+11`rg6%_&<fgPQTTg__kZ98E88wICO
z$Nm`HI&k>;Vt+@TjVNGAi3RO!Yl8EHb4~D-|6~I8POVWD3b;up3r?^);FZMLyi8>F
zc#tMEy8>ZI!v=qgJ>aQ(Z#I)Z_*>Ju`IpsJ<_rkKn1UTS{gar3-I@Wdy_Ct)mV_-4
z*k@-2FpAV<^kZLPHLxICwMyX@d)SjOgKki^pyQGbU$?kQh{)u&04%&1sE;G-cW`aI
ze!zE&gE5|b=oa(#zkS`TyYqU}lwvC6=hjd0d5>4uj&gh_WA8tNts)d=`*1#72c{^_
z66rEkd25xOa@{6=FLOs(FU|MrJB+_xN4K9Wzv8nlFD{#>Bh1)h#~7~m&blh_Bss8S
zTrU<hvj{h>H^GJt+1T8=c4Tr9FcHCRSFwfL+g6eT)8kuBrd5Yl|D6rmBhb3VW@QUN
zL{e$#0?01FH9Qycuw<QC7d(tY;6X>3madn~SsfQqqhHQVQGtvAvEuE^i6cJdwA8Ub
zA4d`FB#$QG=N>oazUzUpvkA`moH2(VZ;Uk5vyMXA`*igC$q76!QgL!gel7_KUs+<B
zPds2kj`jsyb!sPGj^>2A58>q(SS36k6{_-|<3WvM&osjyIy<pL5aDzNR3pq;I$T(k
z1#BIRa>Z^7{fDU=FF`a|^LrwHQ#Z%$e<-|18lPYHHqNMGc5SECSDjU%9oRh_S)hQn
zsZo|>KuhL+^_4pKy8Q;)cG+=vE;!o3G`Q?Wx8CVn2w^B&G9)Fde`tc+qftHJ4Vg4H
z{`z}nYWYiM{%IdK!#kkF=}C6-$jfPxB%7aRnZHAiHB)t!w`f}*j(}&wd2v=WpHNcG
z6Yc+N;!nG5Sg9^9`K{AM@<aNqDCo-ineyV4UKH<_E%ZNzA*Dl(F#(Tb)T_Wt@^Grd
z9t-5w$-Wj&SOPRK0lrIc_>o0^7^lXwDE?s_YL=YHWyLmotAEvd)))XGhY45@6Ywp(
z%zkDE#m%UbLg3B6=JK0;Oehg~4X0l((3hwC?R74-AGha$Ce%tjGcdXi9nS^17;GM$
zYnL?Ru#?!ML)_2Jb&jF2bY@Eu=@g){u#0fofeh<gt%vR~E#X@El7;H>XHirRZ@Dd#
z|2dJ!KQ82GieQ&B0xDwjac%D?#~PcD--``|8VpE`(;l7F@9B^e@4VSM`tdeRld_qN
zA$564GaNicFjd;7bz}f*T@iE<DXheXcHiHOVEkzeLq<bf-qPUIiM4g_Gs1}OTWoJl
z!30b$dCpA0^flQlm3{p>&KhI7{R%U+>_s#0BcHP?cipMb&1IXw&u`QCUWVSc(CP(*
z>)Km5e!dRBBvx^xd;58+#`$Hs`F)ta-<9i#)9;)a3tZm9w}7~giMIo0HqMi>6~fF*
zV9U%%VNN%D(r@zc_{BQX`BuUMkBkiNJok{FwVq$P4;<&T+z)l>z|#d<@WyL)>^C+0
zau={wlSM9P$IUmH12<GHG#&Y7l>vw=bPw+z@%#~wM$(ye3~15^2+#RUef#5<0YC!K
zk7ETKYF|vE?*gaZ;(gocT#`QMo`VCi<i{%5Y`IlO?%eW<#8r|8XwY1_43Yk?O?XeN
zV-OYZ`+wum<5_{SD)d}TT2kjI9Q|j#Z*#gl3b?k>Ds~u2%H%6BCpA~Aq1q9kg6rV<
zID9<mctSOC34xDCu+uOV({`fAGGOX&{Wwkhdmm!v9Cw--+Yj;iRw(FM=A{5A%t`}Y
zi_xvOvv(iNJ?bPgzW6z_35%LjQoO8L@79v1%=(MIVJ1Ixu9<hjnPzC~Z9yEhc3I8J
z(u^1h=&a?KTz#0n--lBa@8>D=`{jMVD^nP!-?`2fK-7d5Y#vM{6vaDQYQ4n-a?P?i
z@yycxQ;3tXE<E}a6D)nEKPiA109+xSqDsl)-`zLPrs5w;TIM1i#J02RYJNF`Cl(H9
z3Ms%p0r_J*`wkvM7l;gE0m?1GeutWnJw>;2?oujFrt2Xptve8=V9S>LfgddWkd$AY
z-22YkAf$k}%bs@CuRXThJaKsy>PQE0Arl~^+$I=4exGUGf}#uq_&}Y+|BLpsCozOd
z&ZjRwE{b)GfXXEKm<Wau<4<nE#D>wI%1)CY1Fql*zk{dpdGz@4Hg6pXfC^hDDS!{%
z#Yb;HML6uERhw|toOlH>K+-aH>iK3a`VyM>gSsnB@CFOEGII_-(v0r)ezOq<V$-!h
zuYD9x#+b&hK{*s<vbo$nF}mAcslM;Gebf@^{~hV{`C6-GNjNx((E%q$lZuZ6Nt{j$
z)o6dUvAy{*U4>lS2@dl5{!G#QAO(ub6vm6m=v4}ULZFf2+<pfev(v7*G!@~snbn3!
z0n9xN_gvZBOMkXyBzYC1<Ss<Yr6d!{VkUTjMc;rIG8rsoK{d?_JhJ(}u`J_Er13Ru
z7Ebcy@9@k{gCIU^NUXgs;wUS(h(02Tkkp}jaSUGJac7jS{(Z2yAC->5XcE;xh|A66
z0m)4#(k?o@eD=&e=j~hEpw_zN+k>C{g-d(RnE^!fWogWh(*&AMQ7B-w+Sq9iL9gzZ
zP*s1qG{kl|KVH+cKUG^0<^Pa0XySM9{I_4wk9U5X-oxbIz<|>HFZ_|2f9l7gRd>7s
zc5th{Bl-fi3$`@#I99sgtN+Oi?R&USb~Qf}$kfBPn)N^a2ea`}n9CevOahcgmybZ{
zb`p#GzMod)59V)W8e44_m5Vd^cpOsqJy;yd$7I>i{xw@oRb8mbDFM)~k6+&5_T#L-
zE`!zqAcZ=Wnvmo=eJZtLVAV2X9=J94cy9u~4Ag=xOnAcCjGcW<K{^S5ZIC)nSN%4w
zM>)C90-+9q?s>KP*Me6}z^uDIT7TfQ{}hN14;*S$fKT3I8oE43+-+4SOH?{V(8Hi?
zQS5W5F-RT!<8IwhcXan0@n=V#4A8=K5|kE>kDC_O1Y1A;23o(D!x&ZEU(Mht4RY+S
zar9}3|95d?ZYsN_BNbCNfI4P?0w}eaiUyui;28`fh9Zh}`1SUkAD>P0^A-B_ds$qa
zIkK?*u+6QAn#^Vck^lV9|DhR^j)^q@mCt<mxT^Rib|1yK%Yx5ypTvR3c2=fBObcC&
zjhB4Kj3Z7C`IfSHeGu6+g)P^niL&Y>0;4c=99s`CojyE^CysFOow&L8VbS|d;}Dc<
ztJ<{}ZSnrJrPl+RheydtzN%XQs(WT7Uj#dW?~wGvWN6I0=LTbzY94a{eV?$EIQ3(s
zb*2{vQeahH3_#U(QW?hf;Qm{XI?S5nT@7^~&(B!>w;PR!*>al&0}waHN*dwsdH7Xl
z!O@|E>wac}7oV=)sTjxujyLt>wE92#R1+drm8;Vml($>{Zh3OkwIa~<pR%&{qrZhm
zeYAJx#@4Ff-xk}N#yMXw!>4{cWr!({rm{Gt`OZ$@4K@d4K&Z|{>GA@w8@?1yH<8z2
z0IdW-RF_Z0e!b*R@YcYkmH)g?e$|ZZiG;{bk~O6j86sTUByV62?YOI%k1d9w{f@}w
zt`^iO0c|Brtyz^6NZ=FW{7Ir0XT|H8$<NQ1^79)H9dWW5`|!EehJ;OvfvekR@wl+w
z&gsO<D3@n7bo9{m8JAe_wo(8u&B67etk;jXrwv3@6({{1<&A&ZqEZ&V{nrNSGraBC
z8ooDQjSP>mO(<7{I}f5I1qony)X9nTGB00YoW^TTAyr;{(MAC_DS{hW{nuIK6%x=>
zg66ir<5}HP>1immSug;qSIh)lh4(t1I(<pS2jeg^+u#mtO@fu22IF3}NOcw#bE*F7
zrEaCG<nNXzN!P@*7^5v0{i6x5xd;v0HI<s6Rwf3`V6TJC5cUa%5l0(|0doK-E*qa0
zr=r>TQ09VVBDBUt>GE2fF+c~`y?ruWoZgm#ij#rO9!qR|7!e$sn*7U6uR7TQCEyN)
zv9mvGSLxa#&%)~^oDk=Gph+w0Ip=-B1ekE{#kEk{oO~X|G6w0&ZQ&!Tu#ychiZyoD
zrxE{eOG%h75V<z+LFLDZu86h<H*^l4c>(uoupLmzMKg0ATouoa7jaelR4n~)^~obi
zI4q)6B6L;7kt&x7Jah}&gIEddM3BkY4qAE?RDb5iN7L&iPnyUp+y`J$VXd`s!==+R
zuC=RH=2NwA<e9zsEr+_zh5-<5FabIe@lBpL6rORXNduep4QYsK66xmPzKg6;bt@WT
z^FOqMQ95VxaipUQLsjyZ=i$?ZlMb=hAAavIIZ<%e^l-=+=?P9bKe~nR{fAmbELSPf
zmq%k>yo<}`ck!0HugbtV0=&0_qXE?t6(jP4aa2^wih1jOMtSGSv+(_}5ZSOLDneWO
zpMiZCQTNy(M;Y1B_hC(kUlWO>45Md!y0_IF1NqdFXHCdEk3PSyx#``+z)0JMkNA*j
zV1vNvUlhS?$466s$HXRvhl{j^fY)^bwK@PD5G)E;k2b!@r}(VT#pJ#<1{FAqqX3cZ
zgPic_+i3wLv3f;GXuEz9W{rUw3!M&AEqY|{qY9%>zY6YQOn>f?THptqSz5_|#~imd
zUhEDSd~e|Dja<Fqs9WlO3P>M-*?1P5I?Jt>n?Qzjx(&EGIwpJ6b=~&6L|U)~9C*Pu
zTZkq5QRQXKg{hBc`C=1Z{sR+UiVmi%2oBn*j?}mD`Txxfo%=a%_FKrn8HvBMsB&o}
zQ=Rx0hMB_GUe1E<8qUMv;!@0jB600Be0A+W0MM;=6F4zU3q14B<+0HPea0^mY`?P^
z<DP_Igd=j(;2b^vTLbvm2TwE&Bs{&ikQG{}yDU8C!*_l!+5QH071^y#Q2ZN`v~7sK
z7&`|~@3zxq?f%-a@}=@~8lZ6i+W>Rsr!!?klDx#Cd6(qixUhTs@s=k2>sBunmINT_
zpblC@Z`45TIOntQp({WHKM?oCJtkQEETAmpLXf$sl87CEBIyph7nUnb(AGl<17yq5
zHo*%|Ve#(@zEc>6*>U31F6Pnx|7PVjI|cymNSo^a$g_CXT5A2<rg7abOz=i~Uow{#
ziJ!W4z?_2N2S02=M2X#8?gvv)sA}FQAOEqW6+VnrFHH6t9f^VQ8MtFo2#!JN>UaMy
z(>Uz-$jY3DM6~45-D|ui)s`5VH+$J)izsopvvm3K9pf$atnBD74pv?nmzI6oyb_sK
zSn-TV(M_ve@@L@;BAiFJ;sP%I8RdL`rHLy8BvgO&+D3F{U6%GF-Toj+sKXO%yQ67r
zw<B%QZjW{*H{t7@c0N8oMe&j*1Uhco)kPeDgO$x*6mP$b3cq!B{IT$gfwt=?$rYDs
z>ALN{os@*{z9Bjiodc|d9Gg4bZYL8Sd`wQsE>T*5bvXqPFcxSmpGB>IRbna6cbMB|
zjRPra$<2-dhzWg>_qTbbVOA<?3NKzC-qL5eHu&mt5x<oH)cj5L!5w^bWs#RYo~o|f
zhi2g*mJC;|G$F_P%*F6ouh7(02AZlwxP07f*tp<#P2>E3X9BKoHA9go+9mt%BD%Z9
zXWK^RYnu<>*(0aV<PeS3326?07LPJSY59_j1VElA)&Xe4aIn(vY|$=rT#`M&6!eJf
zO2Cx(^gDl&G2^ik32EXZ(UJ~@)yfB{D_7;M)u_G5Y2l&_^a?@gpjd2C-aLFZ#Y<3|
zDA>&fJ0NjO-TGNP=?j)ak%gOzm-xKf3fgW>__b<7Ou=eL_vX_#9WysY4U&sbM{xH!
zq&J+|QctnC#SD1X32#>?$&Adg*JVbuXel%MErUO|qE_bLj@p%&foISh_Rl;Lk!*Hu
z)(rs_w1`9|Xrh_3cuwcZ49&z$w?kYM+;z2Su;14@;shwj;g!?@#RSxGXb^`BcLQGa
zD(NGto;w=Aa`S7u;>D+oxf*HIi;vZzx_VxYNCgKSYXX$~0_+n6p4e4D+<=frUr}07
zybn(+p{9;5B983I#RR$GItsR_bTl~FNlMk3*%h>tf|!j2Lhf&y#b-0wvJO!GyRpZ9
zXy)%iLj%FX;c|Dt)g(_JZer<il5MXh5)}PP4NUBg?0>i!-fd5|5=LF|!ncFlz{=Y&
ztGUS);^AvJJDa=KkIOlr`9Wgi3_11mF<Z04Ru>`z(92YmQWS5k4_3N-s{K0)T_L=V
zv~)R-)DEwhH=DZvctLb@SIB9fFlHGOcfS|n$gKJUx0#TmlDer=t`KiW4akc%P$_Df
zr)pe`XAJ=rV4+Vpu#g(uf7A3VaB}KU5OoLf-)Hq-bD}7KHsI*Zk^zvC1l9pxqpn})
zIgF>O%I#pA2fNn+Mk4~Q=nZ#S)CpVS|EUVfg03Wcdg1<5r-m^RS5)1+`j8NPeC_;{
zerru6rjrG)>Co^Oq4Tyx(eIO{aUy(Me5+p(-R`q()97m29yqdTu8eY~(ii|+%U&|g
z>o4i;REG9i0j@d7!HsaWG5VGVg+G;EQ-T7u5r7z38;c;foufrDHcuWC+Rko8??d~t
z2d~wCmr2nTljwbdfqUYbpS7*}(H_Xa%oNriM^Nk=!{|@IT>+IG5{{w0K42!bEmCJ&
z33@e+1#x2(wTVxI@@Vpl_Q3s=v|rMU_y<cRl;P-_CcI^<&lr<f8vTx4;dzuLdDSnw
z^{r69RK82#<R?cAqKt@r?hlN)ghlGBONw$<i+>U+z=`J=!!_Mqac3dIH0Y+l;CYT7
zSKX`E;wx_f#%~kA&<4Nx>1>PswHNtUJetckOP8~(-8|?N696U1bIp%=ihKEVle^*t
z&W`>nx_BastIhzYvfHo^$>5l`GRuO_3)lUqY<_(poPRYJeUp0^5vokr<d5=K@RdL1
zGNSX1k&St80umiXwD+54_x+jtr+)dbCS3MhUbA(N^9I=>dNh#xe+f|4Qv-EXXD4w@
zcKm@%58lov6Qw+MvMa;Iq&uYT7Ab~RanyT)Rno+jKWb0@DyR0~3F#{nSN_0^-*c1I
z(9Z*zN4oaggRQ&kxcKk{M~&d%`DxDY(%jp!YifV5uerSbJACW)+!F?V9{C+yy|XTx
zW{;Y3Y`DAQx6T7dK?k!ChSx6(^C-bif@vh_P=0BfNBv2sa=!8>#vF2D<*mtFh*;MP
zo_+{=dKj+xE<&VN27Q3aPW8?kgSnv1j@j{rWtHI#HltRCl49Q!&t-#!J|JinM~VSq
zs|kjNLuPIMhG&}O)fEWhBMi9sq;cOZogBY9dX?jXLc@m^9&i*)z;+do7H6sQVJD?!
zDC4dhjQQc;+2f75A4`(CM-TgU!6_G*#+U!t1k&amEfyDx_9FUwNwa(YkKSXZF8-DY
zWmCLYr$LZOB$|FAAda45dgIATqkGkXTA&j#etUiI<4XK^eC8n0Pbk3^NCG3{Dne7?
zX<`<2LPnp;%%ZZ&okSAQT=hyWOjXG`522M7U@o|>iv`(Pa0%WlyyW*Pnqggm*D+~b
zFj;$KyWGjUH0`Z7j2MebuKiQn><(^TS*6J(b&G=K|Ly6C2uT@i2c#p97{*=qGUl_t
zXUs>wSbs0x0oMDe2aVC~q`f#4qeJdwsq8ER02AOl#^c7lH=E#5N#1AGJq~sq`_mk@
z*}Bbg3&3wJ8gK>M0soaaNdo5kX*1@RKEO?vnqcAXCj0;*e7EAz<gaajs!nEqF;$xx
z52}_<^63LEg`p4QwG|N;{NOFsMQRC#ik^jgnc(ctn1E|#lWh%%bCXpOjiO&JFFlne
z4PVtIUgcS_wg!979EYziGfnL|s(!knv`;4u^n8k<$<znmLASk(M7ll|9C%bmS5KAb
zfaihn^A#>7UH&=qqW#xYA(z<sZocwzr6ZH!>nqIEOV4u0!fyN&(VC$Y1x#SDV9Qh;
zJF(}*ludj2X;vzd2g-|+wZYbkr6#~cbYOJ>yu=)DS>0?JzhR5(k-JLM;<j=qy25oC
z?f6pGD_ln2>bIE0wH606_`F<+w~z+mlwA_(1n6?H8!zMBJgfP-?q%9V%7AvEQ?U*X
zhqjHlWXjxeWi_T+b@wFzj12)gPJyl~MkiqwokT-_%d>nIX{dyHvu6O}T3pBb7d)`1
zriQ#VE<K3XTdPdt+Mk)$_K5L00%QkcySG?T+$Hh9j@{t&5!U=PY&rj5Aq?&&2y|7a
ztX@r*hCg=v&0!xh0fU9r@XroB@hBrkpsb#Sb>Kq|8Pr-&JZQofp9Dw)D|2is43Dx}
zeFH<9oMLzp2D?`)jDADPuT?d+3FKnZtzZB0=uhR*z*({nn*j1XnH6gao}VxFi-t^*
zoLodnw*;ljZt$YQXd-a-zN!s_7Asy!FDl(zq5jZ=4FX93+^<lr4%8%O4)Yr%j%AW)
za?eLYwgAK=<+yJ6{PYmXN$as{%BFs~9JDs7Bab4o-&9dy`fey@Ut`g5#GK`2?ZA<j
zNpaF2Iq(SVbuh-=d<8~+Zm9R2X|cp@d*J~`WKLcbA#BH627lr1eCw!u$;@y!C&`7F
zfY=3$3yo`;CaRQmg$DmtQ#1IQ%UQg(i5ongfk1p$FaR{<2BZMm3P2ry7Oo6-O^ujY
z$4WvB+8Eu!=X0MfPtkjaT~oLI*>AikZ^d}`QQJXNAHtjL!QH|~d-pZ<KH7@-Y&Pxf
zo_V1OP}ngjhNWo8!XeS7Ltr$pXEVg<L?`JCWFf1y77R@I<h@Bf9G*@HgNo4>fJa9R
z*2kOB=%I}2C!VyT1R&m@_t&!#+&t(JBA*7UZ&0)iAZbavB|Rz&ycM+jlaixjw2zyh
z+rL|q?s@F0ysmL1yXsY|q-yIyjl9{^DiQ#dY(4#eX+Hg^89tQr=E-l+0X`Lx#bp!u
z&U8^$`21t3yoCY%tOAtt^X9@=cICD0!Mlok8nOFH=dgdiV{YyuJb9UIUYHNN$ocq}
zOt5I*NE)zmakW*sfIjoEF{gaY7~P&&(Iqr)jTB<x9@Qpsjd`}ugM=f%!A-3Edy!gH
zq_JYQ=gIfi%vtLz=AYGU#Vq5jl9h}6X=23$%-)^~18>0O+IZmhNYN$P&&{Pb6&dbx
zAmabAbX+RbM?lB>o_^Q_Km1!%PA*9%%|0M@7L|Bz|07NCwf}4a8GFfSg(n|yXGuE%
zD!nX^R=6Re{T8|w%^&=Y2_L#;dg_r!pN)&CE2Gn;xpyI`vIGsTne+%=H2G!!yH>Lk
zqh0ZoNSt(jUk~uBJi3X|uC~e)3q>n>9z(nCX(vtxH&calP^;4Tf|ztdNyuBtxm*sH
z|8{BZH?w6G@d(>QO+>>@R?A`<1T)W-;nFry3%mEtYc8(0t(KYm9gaNwNn9NUVAXQI
zmph<oA}KCUB|LG7+`Mz<n(%`kGT|5h*qEbEN5YgZJxL)|;Ek1N;lEt%cOkoQI~PjI
zx7PtKSpJseO^Yy|2HSzbgSV9DpZ-++01U!LbJe@Ty=xc%I4X^Ne0lal1ub=E$LYK)
zH%bLuoD*o`t>PqB+kGFa2$;?8cm8Zz*DwQFATjQZm@fX_*Q49}x)$mo1Go2C<)APA
zkuh8WD=}f7%N;~q#yBxIk1p_GU~c{TN2c}jZy6))-J(^lgE#1R=7(@}X6!9TGXMY}
z07*naRH9Q@%hFOA{XneKP_=AChyHh;=t30TTDl^&lH-1R&iXeFI=X9HH}*WhG<Mr7
zq9K`9vaCuw+|uN)t(rQH2`{Q^wTa8+6^iVQdqrqNZnvDe?0cq#AuQiHSb7&Zd&!iJ
znqKjv>L#=8B;KC=9iBoQB$UxmRL&loyWtWOq7dttfI4tW^XglN`3t#K(wz5Yqzr5g
zbaUE&U-lxEVTInsb>JQz<}?6fWx*Je1*b9C-tx!x>>zZ3vhZt$uOq*%`YqwoYeJmn
z?8DOxf6(C90`R}_9KwT4eU=<bQH?8q%%qNZtjadP0`{*Z4lCg5^%1m(iHdb%A_*2h
z7b(0vad$O3DuPb3X=S(<`=;l77K>pAM*D*mXf3Tz{KZ=_r~GJ{hfh6hLYeDaI*W|6
z=GTI{#Uv-qlKQQxtUi;Hcw+IhqOx%PY$+UZ-m?6*EczcU%vXnYvi6}B_&Iw$a>_?d
zYc(4F&mp$W>C3^c`<jt+Q1rA)eO)QAh^$@z0<HT3N=l>4uv$G6ov<l|&`u2bR;H-u
z5PiC#i6$eJYv=TS9~hbz_T-ya{LmN~II7B=Y9F89yBlpudg9^N_xg!XQ=wnxcrW=5
zIx=q>bIi#|ZMG`R>L(;9{m86e<JJ~inef9OvCM!yVkd(=CG8+(ym0(Hwn~eo28Fn{
z*&c;N#>;NTiPT@0K5rUJpR2ZIkgeBX!!HBwFL>S_EZFIV_O4<8;H+dIhz&1$SHPe1
z9-H3gDS^&vB3SZNNd_-ztL-A40WT`+)yI$>^s{+vSQF01_15ZEa0`20t5=kMh`BJT
zM9Rw9ac3K&`_r|z=rJ!<XmuZVVV#<+4$xT$@4C)}H(xfpTDzVIyer+boy((UwEnt-
zwbzzKKZTDY$<vM5Kmn_zTlEfNtA>?S6(=dc*oD7qChxe$G#_GX>m4Q%iB`Elr?LML
zW&}mgp<Nbr1(nbXjm=k<8ndalEzkr`SB&ipRrLT|2{AiUE0>tYv1gjbp;)byU4L1x
zvy(MFR_(0G4I@b{PMfq4uZQ=rxT~vls(w+@H<G$0o|r;?G!<9Cu1@wX8y{D}q`b;p
zByIj3StAwnwJgdMoT30mo<b>7N<r|heWMF@itLK84Pe$nPXPl^ieJo&%q(|f0H8Ct
z<EnbwF-3LjFMbon|AFUz%~Ab<n%UCTMv0lF0FXd$zo`@(4Lk`G@EtN8#{-KwOQ!-v
zWzLF8(H)NCN1>DkyEyfn!U<Dl8I-JrD;Xww@TThcyWmYFYckwv5k{CVH0GeA(3+l`
zN_GL)%S-7cb8bGQ7a_)pLYX9fR{Y#7I}P@Z(3q4=u=sb;0GqRaT~;G^=}k6ISzFp&
z>ypXD!D>DC7}q<0l>6%0wyENvUlZWyM?Pm-C!A%%HLI=BoW{00m;k9&fY!W~)>MH-
z9^EC-dXnF?WObMeib+>(Ue*RGm;GH-BB&t&u((AVwhvm@{=~HI{EZ2aas^^?_)d)&
zC+ShFS!Ko8p^mjlno+ktLL{a_Qh-dwk~$<FOI7=y%9KbZ+8J|v62I$muUD2BbH=B*
zb@Ygi6B$KlbD*W7qH=82Y|Vn^bQlcGqzBTvf9dg5J{!PBLhvTG62ydLTsQnyS8AIb
zjH$A~s%kYbL&E@r+UK~M=ZBh`1_*aXK)vf20JRDY{Z?!nV1I(|pOKd814+2!ZqdL}
z0fs(~+(A&s`_MkNAKY>VrRi|k@i&K^h?YMChd$hl9sfL(h4f}J+mBu=t93}oFw_y=
z3=_lA%FV*X5`eP0So&jPQ@@X&P^B_r76!R0%is)Guusi7?BT7BF6c;^0xk%n*O;>l
zzdKJ^L%95TZ_2e+EHSOcPvxc7j;qwPc9jj&+N(o!9zMnjU)yNT^)lJJvhGcv3Z!2#
z4@sKWVQihcR4inr9bhut+PLWDJiF-E<oQz;r6(f6JN^u|Aa}6+t_x~MeaE|_9QI5?
zU5WfYq$jui2Ai!s{$wn=C5e#4ApX7tv;$5DCL)l2=oEt2Y<amhm$+vk<j<LtR&Oo@
z)uH2E$pFL^6x;cAo`2-&zPyeL&G<{5-(LM&y*uk8Npee(=JnU?@x$QW>!(lAWyjr(
zIr-xzJOT!Q{a(3*1{*5==RWGv{8D~natN=x#28uW8pI%5Oj5lRkCrNRad|9~3W`p7
z#H4=XybO79RU{1z!p-|`HjTYMkl61p{ay0#cm+~*&CBb@aWBRcS4<nO)9%&P!Y3qJ
zDNEYHPFP>g>jQnkQDL;@gVQcB!Ab0ybJQ}aQ{pMcV6%v+k#VgHe#e+=e_lxxo(oZW
z0oPp|8Rj|T0<`N{FV);yC?y#>Lm0;Jyw96p54HqkJjg9h!~mfPXzyW&8Guq)eg#zj
z?J)@~TB}M~{qi&Ce+N{WgK|V5Ge<-}nBKJvK)e;eGSZyH^F^M`vo88bw5O#`UBl^P
z3F!O*H?##3m5ZYv<RIl}(Z_kvaVC@vf1OnD1_(=o%U9uDm>->mP!oeRby1+)99>q-
z?GIMoeAr34#I<#uBq2B-M;1gDr_SJ4b**O}GR<cnGsA};-`A?IDn6T!$~4iEZ#{5x
z&x5wwqpX&>?L~hLupu8l`%uq#Yt^$`X5ERwWUCdt8I$b<TrS~hKpk0RG4$Be?3wsb
zM!g=rJzbz`NMnW+_Fm(1oYT(dSRV|&%rqBBp?t6%H2I0XpY2T@7c>j86e&9-k0DKw
zbxzDj8=VO8nIOMhkssPLW|sAZqM|bxPs17pG;;}a5v#O!r|V(#+I%XitpKR`A3RTN
zK2&8W8G?(Q*Q0;}C8Xfqo2GB_*YUpdzG6bz054b_R2~H4YAb(IMyumjmz$8|edcH1
z+-xWR%rDjvbais?Bm)uAX$Fl26`dHuii5Air?=Ot-4W@`I|FeG%V<`it$T^Sa)`bb
z7qCp}?)7)x><yNfqNt*_yu8^b7cdM!LssXcH9nh8jP!xWn8s&+KQ@hxWWrUTgs##o
zYz64pZSbkDq15+jCek@2kh&yEq3+V}nBdayu}WXubul5jYB^b;<UWDcC%$UJvp>()
zz-|$v0g&3TgjmXh*2H!#DrPFPswCy5zhDkxujAe8HqTXaz4m;O?Efdvzww~1zL`0h
z9@Rcz4=#jpXklx=!Qg71zP|?uB}Mk;UIOj)%l38`g(LR?*Wt)@&8*SQU=m@ztZlN*
z+{qRJBvz@TYY$r^O<Xna0uUAlqYA#H<-|B>qNyMW3XvF1-FCGZ`N(H_?tcm1ZXOi>
znz}LY!J8}5Rtzrs4T{q{Q|vK7CZ5LeXPed)-|fsWQ!xh~YZ@2)HWMGBYxN@c0~g@$
zlH4w(-(36mXTbpIx4-chy|=N%>GxiXX#NGOAQ)<!AxAm6GHq=tBcEv1alw<%H6dG2
zb}KR7PRwTQ8rGPpvD4Qp=vrvTGQ18ZEj$;`7{+Nr^sZ+B;J|b=@H*N@48Wi8j80Qq
z^#)d*SlYn7IK<20PP>}c1z$6b%lP=8d!+vlB0k<1YJbuVRuyT}z`!To-EkJ(+=ae^
z6oZP636(+7KqrGEJMC_j(t<6wiB2PE4_u4|w~d8TFj~13MZ(p+4~RYuId=h6s;dv9
zieFnn@fLuxmkqW)e!B&raup_jO9q2|3#*k=T<|ii^V?mRyeg#U<q5&l!~jk6I;5dh
zY0CqolOfd4uXA3u-1g$~p~i<e!7#DWgg3DdJ=2rMzK5B{$G%wUd&;FhucC2Wl3$iL
zrFpN#z+HS-{W#qb@{@0v0H!HC>D=g8U%W+`;OhszBo~X=mgxtE#>_eMdmBIc!P~v;
zI9dLM=UUA@-Lr4rIo|aQfSQ*dLPrDt0q+NS&gAJfj*w-B99saPx369sD_nKBaCg)C
z_?JzCWB=yKduoG73hcbM3GMN|BO~rQNvQ5|JwCUAWs3Brr=v?mp1!Z%o~$PQEtu#J
zI>y-jQ(aHWY9i3YrG0j-F06wB7=Zu-Lgt;dCS>0^eDVQ0LA>u+y(;aT!tE;7j_rtY
z6nI%Yx>B)S0y)TXO62AetyL#l&aF4Ey_nM+!)EB%Q%#`NUT!6FkXMKbCnijjwr^f}
z5vMz}8`r1v7$ZT-t$zUu87dk=qSe}VN7K6Q=h&Edt$I5Zz^oK4g+Cp);~On&+&Xm;
z-rW4sB|80l6do7%Z!}9x(w$eC03$jfQbzOsLpw~BSE_$Ord;|9^5#Zs%&c$<DYxwO
zMX~}hckui@a}Evo?stqP?+v$V)vEP7?zkgghB<?WFJ&`v+buNV(Wmq-1&FH=Y{B)a
zOp3u8q))4t*Q=atcprJH3D0MLP9p#K5}1DHf~33#ZW)ld=SE|G`OlHHG->@;b=+ew
zTjK#tPH@br#_YCdw0|f%S(yZy{QXC(6{WE%3KpVxq$`^DI}GDDFbgO<nI@vnI!-Ik
zeGcZfINBy&2~{bs`iHN-iXHabtK)?3#?jPq>+Rb-O%-HZlGJ?W5%fV|u<AH2<p~!*
z&FXl9^ZpAXk#E9G)dA$?rM<#;-ZstKuQ9D(eU~%!NMZVQ^nu3FC-=vgj-U{@%Oa~3
zXgGsz*1!a0n2LVMOqGWj3(mL@Wj%h+g2}3viLkWHd_?2A_3?!#tQE}^J#_<;s3AeK
z$BT9KHaDGGv3tM$qb?nJ`6sdO|0qnoBz&8Xdj(Q{kLNk&o6U!+J}7z5FaT-;7=V?$
zq?B<Q4=m(n;C9->gomHdzX(<zrL1G^wzmmZzluVg`eGNS)#A1=Am{#;2~YiabhIYt
z<JLshtJ6sZv-~AvuK2Mrw;`gC1-Lqc?xF*XL2)QJ@oYq>i2bbvyL^grV^tq%g3D-)
z%oXc6BgSkZi*}_$X{yS>-e_;X{}6-?Fc)>47=Zh4VYOM2;n5lIV@~64`t8dWj2#Pg
zdl3y6KAEM@)S)iQ%kjK$35J(eyi7Y`;0NZT4x^Jo$VAcN_ikSPLlfTi>;5Mp2b`^`
z#!)AmprXD^;V;YYXZwPfxv}{up)P~QjSkCT-@9=1?W4bC0)3YmS4dwbpC7DLM*UrV
zXC;dOF}roXH6NMp*UgR3W7$+NWwM-YBdc%V=c(bZRF7`(7*`sP+*SSFg>LZrPgf`U
zGoCA1{lhuEHyks>d&j|*wO|6Cqed)w&CxtHNAqcDi!HY^;bF(aS;Mst!s!T)&fLEB
zW@HAqXaLaUuj75^|F#JarYXAM&z)Sm(YyW~Zs59|RsX-D4)Y|d;EI!=gL}w{oOS+f
zChmi3F-V29iV;8*8!Xx%o9J&bK)&oSb$vSqz@Hck@i=H?uo8d=ZmrG$u%*#B>eQ|b
zfJ2eI`JG!&u+<^UbiFwB6U?)=UW9?zo=bo*0bEZ60a8G;5E)Nh{6Cp6kVaJ9il{;_
zeJ42dINF5?D5v3TO)5;10sTGLb3YTHM-u8=!SdfgCQDZr^|g~eW`cu{gx>ZrQ;W_R
zR_!tpk4v}c;XA7LJ4bifn?*(N%%d!wkfh1{cMrNtwd+zu50_dsbi<*xa%SI2r1(!f
z-*~Tx{#}#4rx*ZL3MOD2CV*aS4&~X4CucYzcBUM+q6K^v_BOylC}L>^puIrO><4eK
z(p`fzK%zX~Ax;g?{49HW7uvJA{-ow-%la!fl<>W_+yvMB+?ZQ_6^Ve07?CUz7yjU>
z#(eTCDEjTnJk%aQU2>IoF1>1>Ew{FYNy4>j<GT_v?UMsMj{(SL>%gbqRT6+Y41l%(
zjylDzQnT<&!?bxz5&&s%*KKPbu+C?1*bv<Ui1J)5CvE?$e-`PX^g}})QXLuHifxg-
zkqFh5!sNiSM=d37(Ur%0BN>v2TgM``+8u=35?asw0@o?CTE<nM_{fQPJH$4I8IL6s
zs;~NORj0gS=$9{v`ghfGRq`Rh3s5!=-dqC{uoF^879177&+2W^g%B1Njq87Df=6!a
zudjDOQ!!bC$8|h^%Jb%XMfC6L{+?q1R55-e=>t54_Y@xFWwYoQD1%p)n1F5+>Q41R
zFacCYqS8>30PS^hA9yk;=y>0!f7gUZo@DpPYYi-d+pVcE>=CdM4K8KXFY~Fr45$Yj
zV+{HT*4mdh@O8yqKwD=yVx%>#_Fl2nu6zrMCegt@i2wIHxbox^;bboyD~;j(H+3>$
z3FM52Ny+K}WLCNnyi8s{C<Xvi(6w~{d>GEpdGZGRL#yOkPA3cQxnb~=j))LL!A*9-
zzS!lLNZsofRcXwffPfP$Kv!h14@48%t1J4lRG83m5SIu^U!~%uOST*gRHzlU?((?x
zN@MP(Enh%#CT2jE@1)n##U*tlue}Of29O5r#Nfa3lF@CWRuf-a4qa$V=<1i2wQrdQ
z)<OeqC)SlH_KQ2e{If*=0nZDp{s&ggd{i?Z`<`R~)Qm6yERD@;Jba~gOMurbIh4{Y
z6EM}{s@A;+!vtu6)FihELm?X&K-l*VKl}+3vL~r6f?5MprdbLnqc>3)y7|{!eQ{Cm
zlfX`knEbzH%r3kO2Khq#89KAUY`H)Nm=Jf{LAJ~Fw87p?Jm>(_TYZ9&Rb{Ackg7TW
zJ!}D}UNWf~S{(q5M}0c0aEBD4;HI`B=u#vMC6=wCe^LabEMC%yb?Z#9^CHX`Yvq~!
zMbm|AjmDZV7qUIH=Lb-TM54QDS#_o@jn;;O<Igch(uyuLCPlf+BfRxDY?pmI+Ae!@
z6~|d&-d|mcr9QTHkjj`{7v-MIcQ8`*rD+2CgtfYdj>oh(j_?N0W94?;I~*0{JJJ#2
zocgBd>W2^%OB*mp!EIM?f@qrRRF6LPjm#hN-1c6a{M8iiSq4C&8khhMyjl~%$H#Bg
zd3GEfI^d#~0Pb4a`~#B&Fo=hH?r+S#2S=-Zi6nDA(z=yS4ZS+vCzHgNe%F}$uIo?n
z>mx8IhaAmB+r8_hXsB5MTb6bRbQN=BII^Ljl}&-u7J!KvfLeIpKmt%_3!tJBU<aA3
zki)0g0_a5vFbizK)>h-*GDz99valF{2N28Zs@LgqOo-tscz3OcvH#$dG6yorNYqY$
zusSESfmsO?(95;ONKk^4KZ?>SlVTO8Z~oysjrrBT<>Qm|<CVoQB=kHfveHL<mtXg&
zmj;jBGZ=}6kI?rc;R}{N%kx5{94KjkM_)c|K7fjTP5ziX4sN+@bD8|tLHS?t{D{ea
zs$wnPb=mkL-n)(;Zk*bEi|402QskIj#|>G*?N_qDbtzivZx4hP?RAC>l%Z^o*Idz+
z5fFXY{6{1gVB$6S(cdtM_9<@M|442dJT5hWbfcly0Y>F)Ssl-kO?-^C6gr<7p^z(U
z%NG`k6Y4TsnuIjq*Wxn3r7{C_ejTg&g+A0?{dBu$9x$!%{=XP9y3vH|*VWix&nL{U
zpUr{IfZ)UDn&3<SfmJ+GA1T$<aa+P<>q^`T&f;FXCKCIX-R!5+H21(<uUL|Ts`7<S
zb{){0m=T9%$pB^FKvJlfkuIgJ4pH0?+PL8|#+hF;`Op3^4e5wh4Er?ZTk#xHr#A1Z
zyzglSK)(b(;2XUD2haTq&$`1nOK|%YR@7xscG+y5G`!*ZgUh~W%r!rWw5a<bR<;O^
zJ>9PA>VmO@Xx&0_emh7>DG<fGLaBr5>PrV4Lf)RYlLAfRbth)w5!0rk@zV)7C&n@w
zl<=9AoNSe%{JK^u;AN_)5ayNW&C6BM;idm<T1cJ3*Ir5gJ{2Ikw$(dnXd8$NON*bQ
zg29(z0#5owB;Kw7*Jjavcoz+Mhu<O>{j$a1%}E-u^m$v?cKMP*T8URYHdz9tT9Oot
zk2}MJ=xEg2CMyB2Z%32=btwGZ%AWsBTW~BUO>@PcF?YOGoaMcdl9n~SH|msEix-Lf
zQ=T95EaI76CrJQiavOXAt<yhgE#CD@kOqvpi^_bQK-vg>kKAnn+3{bEm~;?s=RH}4
zGkDZpF>A#+g#?am2-Q)_NP$*tb>L{y(!Jyhp<xB0%sl5-=GiohG>WuduaWKP4kd+J
zFjRDQ^7VjF%tO%u#N}iIAW9p=(L2?(2UkXC58%2N;X4WMzS@MVUonj{KaGOmfrS%q
zindgs1Py&C&{f^%eh!@!>~&m!348KON(#hD>Q4oXSSM<JK{5JH<G&2Le%m)+ho|g>
zl3PsQfR5}<w`02`{ODIqc+`iJ_OD1`F=eWw#Qry39_{&WK9m0vi2f6v<;BFmcT)a;
z!2rO?wJ;TY7eCvd^ZY%}R<r&SqVN>la;a%Zv-+%0^|Uh1)<GYon=rCzmBLI;!KxK-
z<5wXsxe-QS-T&9#nSk3-Rr!AJD}oG>F(VmC5JG?e0YYR7GKmbLLfhidw%v|T?bhyg
z`1<*@+t&B>r){gRyS23iL{Jb>0SyqQ3nV}w10fJHka;2lBoIOfNb3FmyH4HIJ!4g!
zI_I8q&t6|v&bf7}cI~}()n03_G0|m-PCDuY6Oh_Bf<*nqamqZq5J#t3IG$m5)&e<{
zh5Fc22=F{QOl=!ASnE@vlk}mi0Kj7IXqQB&h^>6C5}>Y0Qw+#4-&i9x`dxCS7*D-I
zfb*`V-)_(~IuQREbBZMkT}hwf=QQH`v-8bvvid1^y`6F%iHr^@t*Dr}Q_w-t5Q>Vx
z?;!a7HKCJUwQ)Fy&(a%~9#JD4Rr{(6T5H}kw{l!f@*KLRX*)|4PPMVce^Y;`ve=VL
zq!0;Eew^_O6MR>kzr6itu-3E=^Vfp+O>h=GBbQ+&phTaZ(h&lHD69!Z2)K!_Bf$R+
zqQ~oFfce`Qm;+cCb}MGT5K~-Fuk_R=Vy?wEf!Qhvh}AA=Eo#U-ZE@PM<D?i*ms+!*
zDtdAkeR<?AJf!&^!LkL$sOCIg*unYlA;fEsP!XL{_ERd~F-L`U8H&fIg*oZ2E8e&U
zk>$E<GZZq0T1+I~ze?Yo8XuiP+6P4;Z*qLgLkOwVw@Sy!cM(w6AXu@;SSsULqF>_A
zQ>DwQ9oO{rfSysj`t4<ZVS?+~BUDq_!@N}OG9q8Ec6u6&zHpXkcF@4u+BEIv6~U8K
zL!)OwA%u+r)egD*qhb2+LaO8HV@=o*ig|TSyU|$rJhTq;XSd<}#cqUG^joLD;u*@O
z3oLG>P5x$Lm3iX_;LpKbEzxZ!1mx@(m}X#FL<k|YI40U({g6y^i}Pjv>dOH*DJsQi
z&ypE-(DBdkYw!QXpebc*6b=+;{yIzj)iL}i%*?xus?k+!C*G=dRf7%><C^2g^<4~&
z-^I&wS>TG>kN+*Zt@@JoMq=8!R(<U&;Qor!ce~lX=!2LA#jt|wzDG#iAHvFbDf<yU
zD`m;Ac|o&eRI5P(K_!p|1@$!|RI+K5=RE13tG20o9Y^NQ!^c#*Yw2-va>$0BJ80}D
zoNac0<O?QHWK1KNKZS@|i1~}*WA8NIf=5UY=osiI0YJ0L1Zz7fHP2mO6I`0POD%w@
zNfp+0+jXS)mCs`RP<DYUZkEI(cF9ww>(~EHR=*oqOz?RTgUuV1dtOCMDnLnJH?Cvn
zUt@P5k7}Kxx(Ee`7We4yl22D-92ILZ6pcA*r=(xS*F}FP-LdKX{RTKSZ|ZyK+Jv6x
zI<+d`SCQDx9B)Vrk}|J`!byD!Th^K2)}NW(H~-XCgY4zNS*ByDXe~{VOiX*Dwyy-L
zEwBlvzNFe8G1N0IG-k?0<%IwVb>mN=Qs<TF{DIg>yA;Qj`kCc8eGSgI#O%KE<Higd
zm8-z1wXJK~P2tYJ=$*^b)ts&o^PdL(V}Up1)NFe+(=jH1qUl)6-(Lj>fs;X2wmt@S
zH}<i+k&4;<lFTQNb5f%~3)jo|Ak4ZC2OM@%)zqDN^g%J#+Pzi*Ez$xv5$jil>4n2X
zmH$`2b?(p+z0T>?R{R%bVU)=L2GR@Mt~$D^*Dt+xcoiR#6khfA<a5GeF1k(Omeo}8
zJ@=%KDw7-x8O@lN_3mU7|5BE|E=o%8mY}*3+V|B$E-lfV`%SQ6HT6H=XUv32y?jE-
z&t^hG$rLA*eX;f_x?J;(DZ-p`R&pmiWjDO!gJA+J<pjXj#>l~y5MFcKX`zFiavvlG
zy~C8k&ZP`<bWcJG1F9PalX*rJVkm*H0CmxmzS`$E89VJ)tU20uwG_;yH(!DIvzT-q
zR9}_*DLt5M`2#$|@IDXz0>q%$0w8n19GEhnyD$5&39=Myi48+9?VeY-@Pif(m}Zyq
z_&+%#e|3NC{_d-ot3sw6lP&(S^l!zPyA-Ed;A?@HkIE2hOtHl(x-43>dT5|?3XV+C
zIlVr6PV9BG=Z~np=zu%D%zdNZdwpvBlh3Ds47<Q$&+X!dV;A-a2fEp?k*;KNaMOQ<
zH6UW=rTQv*r4U+rwcSNW#*R1kijNbfcQsCxOMCs?)IT);YnPbdrvJnz<eluY!KBG~
zs&$mI!c`M>>An&Gl!jXw@=D*b@~xA9AUOR3)a!32d#CanFb`t1!fMZDxz@1#+a*ty
z`z714k@&~F>#ES+Ulih4<?*b2uZa2I{tIL0cGo_?d1q)?dU*dHejr}Zk<f7_fM}K_
z1n_+}_yurPbiB_$wYbdd#vH&4BUQK->pGz9)lykYEt!=Gr0I{wlL{PLO)M}ZiGvmm
zLgfD($J|5PBw>JKCK!9c73m#4_jDdUL#bP|0QSN^FRw~YN@wjnMHAYNH=p#oY{K@a
ziKgqLe}}yshDK(*st^f(Ixj*!f6?)(7bo~pJN5f+F~JQ#G-feOF^TY4rP)CK7JJti
zle8bo<Dc;TjA-k|Of*bDks>pAc&GtL%ly@MtqsrSAOL6%PCC*y7NP(EAOJ~3K~%@=
zzUuQPK#Ssp^%!l`@5~_PkEx{VcUOnZKlNIW`OZl$M0I4o2(k<6T<Ay*Ks4P2O#p^u
z^DXc@U_zJjsD%c8&VR^sz4ofvefdXCFm!}l{IlLoFL8mb@`Z0hN1EO5{)n;cmhAn%
ztE}qGdc)%Dw7@0ZDeFAhnfGTZ$VFZi4n}3lt~hbqN@<Mub_uwJiTh?*?Icjt3IkN?
zSPI7|%&cyJaavL-2T#m2=9$N{H76%F(L#`A%(_nVgpIiC%D*-Nj&s3uG)k&W8G#rJ
zA%n`jU`H{ZJaekj*uz-Gq~*b`S_*5Hv6Bb4Zp>~{&>T{tICx=`G4K3yV<(*v-aqP3
zg3lgONI<UT*P;8(dC-_+PO9mf(bH~%J|sFt5eScW*Khw<a-Xx`ZGto3844mr?`U29
z7V}@X(sU`TGV61ih!~kplIP?<gVPHe!Ay<xhl@H|0MG>T0K9=Y;5xpJ0NK*?ap533
z;6Muu9?wn)xb!3B`^QRAYf*}>P4bCDS@4d_T+Ven?U$h+fMbM7E>3yQpkY0p#7VA{
zC$t@ZGWwZ&D>DQ!m`P`&@}=!Wz;dRdNpf^7hI)3QMT=%})9&xX=p$L@a@+CZ$6zPm
zG?sN?RZ=A-dve?#MqUr#)Tr2eLw$>2#+|6f7dl5rtDFmH2~>c`rKpagAByj#f;Ng}
zC*`zRvDgF)9;3?SquD*g<rhK*!GPpZ_U-gbnuZ!s%IKg;l6Q^#1ZLjD#+?1GvU6M7
zZjFv4`k7W&qq&~bo#^bcC+T?~Jc^RxSC{~EL{)P~*#>GHL@2h*rDOif7t}bp=|8{B
z9sd=)fwdngw6lRH!2^YZ-k@+0Z?icBoCvlKUD#E*LL9PfDwHnC!c<{OOO|>qjzdPc
z^qzM6b{vz|vLnoS**fJsb{QAreD~H0y()89@#d&U?Y6D#5Z9IVNekHI3yitoy`fWI
znI=jPF?y9ZeM~}y9DidVmG2m0z>kJW>w6lY9I%<)UD{^UhWdIWjPTT{C616K^ATNB
z>r)p>jV~=gma1uJ0PKh(jU9Ppa_vdAJ~2j1sGF;%c*5zXi<Hlnov|G_I8-T%29*RQ
zo@bZYQI##p#^+2Nit&FHP0ePW$1EV4tY2lUa!*u=oT&JuOG6?@Jw1EXK-wQg0~~Qo
zXxb@^v0}T`+DiHxeh2oJpHawYMbayJpQm?z0#1kTLvy40A@X-91DVI5XA3h-*R9tW
zvl0_YYXJ|2p=0L%!u(%pt*-S=Z(4`Z_09Nu?uq~)-LQ13!@&t)N>0EPje_l4okVR9
zAyb*60}64uS#DRtbR<xyn9x{;Ou0|H3MNVU;<`be{}+CM(564b>-|ugE4g#!TWBF2
zfWQEQvICIGs6yvr&)>2?iBez==Uh(yc6ME9Dj#Z5S0%f01&t*1j3d6??b2aLm3vnD
zODzFFZR6!F#+Fogt9^gYP<rIK4`s{Ns6NTNP&;&Gsmlvwo=~WzqAi@DS~?Q$Tp2X)
zx|Vzm_GskreGv-QE)O*Xm9HxQi$e9@f_6eFpkqRF)%!;+$vmO#lPVcp3sh!WrF><!
zV(f|9uhnLy-*FtY_up#Fe1wxM?<nt*^YXvw{Rr5H_o7SumYK%@-MZ$_GF><S*d$7+
z9KUJfziUzZ4fthno2tcnXr-NQAJ2v!2yh32z-+p51b8IaIzj*oja~LMb<*WPG%S&7
zvl2;5mSruxVgy>m#B^WSf_?G%(w%pu28)j$L22Um{1stRXR|26w9~QFLTmI%yFw*q
zk(%<PGmK?t8Ju=5$Hu#MZDGe%eEYJ0D_Y?0Td*@%c=5-=C<+2V{Q44F#ed{`um!t!
zwQ|7P{gU9t;yGV&7hKe4wLg3MBOCq`57+jSsMHu?e3no*JA4dJIep9#GBc2<51Lo}
z2kfYE#ts^R%6l1t4vaPpNXXd>VdA*S=~dhk79{{|T%GKWlrT20V#XLbj`wK4WY?rU
z3+8WT+-2;&@UUuC1uL~HFaIk(LCJ95NxfGUAoJXjNwn+n2aWyX_4tBpsL*<!9Y$4S
zZUg@Te6G{&{_$Br*Xkio0UnMu_yl~BW8z#F#DDAa?=NmK_O@$G7YRUiYX@BAMb6Y$
zob`fZCYb<dwXW_z8uQ4sbRO06@Sbv^3C_8c5JrTQ0)y^hT3I?J=CnWB0I+y*ivF(I
zzL<f+w${N&DnZm((eKgWn)fKWuGgPZ*Q=qr8VOsB`qQiZEPs%9BA9+t$Q&n~Y3x2Q
z%PJkr?Y?RHDo=cskCvKRp^sDuOa;o4CuW`n^vtAz$L|RRX6>$}rAuo{s&p^)gJMGV
zLEc4G%uCDs<>+_HJ4`V3Qs?gz*M?NOW$NSfuWROXW2fJkO(T{1hN&)igR_|&R}5~A
zXa2oum#^sGyY0693r)Z_Gy(G%0NXY*3d~{Y&WRjE2H53j0(N4th#aia?1T&5s5l_C
zg_BvJ9qYgm#%@@XEJ}cLgUde3LUT!IcP;8u#rx$%mdfq3fU2mF@*Y&G1gJhJyImO#
zK)LSqx>qd?fEI9asyqLJm@2wlyQz-JX>R77^)0w!CTNwMqDyI#B?J`BTdF=a;$&!M
z4;_q2=wL$po=B(qR@Oz8fmWP-8j#R1|Iy?c0JSZDfVIyOy1SnK4hel;Y9zm^*(LRZ
za6e1Y9P=O>*jMGhmI9Q^|6=lqoOLngGU!+1`Qu4V4NCCSb;qy6Xri>jN$R_$zCc5|
zAN(Y^!ZZI;`gsAMlqT*70>Bo&JPw`&qK9lDkeBVM#W=~q1eAzGS;jIf+`SlC@$eM7
zH)Oc8joUYPkJhgUcR0o8X@`E|RMd+&6)7Z2HrxtO^?ntuNqe~D9%8^xu$bR_OJzqr
z-DIo;0I<d)S<;_c0)Q^q{~$v5P(>&3NH1x>(g9_GdyI`u7AL@XoASV40%JwcvqMIP
zPL*kC5O1#$-+9Iqvg+jUrB5cmgM3B^zf6)VqF1Al2|%j-w6JA8VQ+JdeGQYd91vw%
zOG{4)6ED8tA`I+re`d_0+35ryJ!g~H^}qLH<nqUtLhoda^?|n}9iY{6VScw?Z|rQI
z!z?}t>F${JYz>JQ-+TsK>Y0Ce@_7NEJYD1uU}8eRDV)YOq=kF})Nh=W>^kg}htW0V
z+fTXBlrT%R83!?UIS7t9nh1o!#;)gH@m+|ViZ1$~3C??O=v0(I?OF4l@%z{D-Q7pb
z|2aI#Z~b}i81-`P9&xNOay&~ghF+Hw$8P34P+hoCEqFNsN>IxK2-ghe&VbRt7&OK_
zKpyW(Y(thpm#-j8a+*B)QK=0@h7f6B)~pEg1ynjOep~{8d`9G$m<AM@C=Eas0YLZB
zPI%=r#y&OMW&AUHAxw)Y3nNAxed>J8p_smMRBT3om^%|&`Y(-r7`6XP&!?MXY2x0+
zJ9+NqVOGSHYl6B{6A+N>;svJbmY<@P$?+MidE-<kJjU6d2A}rKzcSst4?tzwxDvwr
z{3JdBQX%~WJQ3^yTLTogPn>Pn&%f)`@4HVtJq)`_*gLU~nhaSB6$xAdrCA+;D!cpk
zFiv~q+gNDu@>j@Km0f>vR}$T`_@WGdyZfkE3RMoxs%J8^knocDLSE?-d^cQ%Izlef
z3Tb7Vl=@#uX!6e6Ag8xmuQtKD6~-!bQ=Z~!1){PYuK%Fs(<qVBneRdyh4y1-0(H2U
zpBQUe(45vgZbcGoUPH+-^54&Zkq>6>6?TcK#Z|_XFrfZXkW1;Tt)fYk5NRD_+YZy$
z^=Uxu9e)P7JxJ^$$IcW2oTF{hd&$`kjhdZyL*r|RB<)k_c~TSoEsP)4mWOH-@B%<J
z>g@SV{s5l`B?Mp`Zy_Oo&Zr`oz2zsSYZF=3re16U6&Ohfi5W7Xhe}2y2SJOV5sYRr
zlZrFLLYerU3CB?OG<p3`zXc->>d7P^Nhq(~bh-P@?l!^r6H&8cR;dTrod(W6y{ev8
zDqpL#y6ilIm5T`De7{jVe;NU=a>MC<Da(|^m}RCpd@S0E`L!F&!u(yUW$#}5e&x=P
zkfw~5LiJhZj5igSzs^@5RpvM=NK1F{U~+9-hO^&Usm+0DMrsi}?E`-dBN6K9bJnre
zzD~oDwEtOfR_)XM89Y56YEhtI4p_^1dbrL6#bL!VS_iP@+GPuj-O55Ed+7lK67Mz>
z4@3*F3WW@1H&awCEDIqL-#1O;V&V#MyZ86TJaikj$v-8#T48{)m!=hHYUKfl?!Ij^
zZS%S*--32)K<e=`wqWHFcInrW(GcxMqd-haVW3MFVDi~%ta8@NmYqb~QK?Uw7iA#a
z#`7ufe0I22`78=KEfO;#J%3~|bmosr_lk}yByaM$p+jDDEXk+y0YHPiVP%rD)14za
zC=r!x=ECBnRB2jM)Xnh-<L|-NuV{&V8E-vvRO#N4z5n;u8awOm`UI9r_sHk?QkwZJ
zJO6I2*&b?Bz-s_%)5x76I})aV2l(SN;E%x3AUeDjgSq#cuIHaKyD!ELsNGTmRiGB%
z)XXS{Vds8dsZH0SzNYM`%Rio0MV^=o#Rs3_qKEGclNU+74s$BLvg#a&`LA0UGJmO-
zn*rLj-g9$!U(&`}<%uW=FUfDuD0l5L!NNJ%)!CG-UK}QNQdp;wFDX~Vh$9dL5-vqz
zaPmnZyscun-gxK4a8p2dwly~8bt!I<&#A*P!C{sQPJDY9CYyorC!!4RRM#`}jHQ~N
z%RZR)oyuplNm{{n;<U8gNly0XgcLvo_mGqVNR<JOfqKx`8ktkUfl04z>UlB=EMEju
zXR%Z~eo=YPN`0xyfGS;7=W(kTc_lf~u28%0N;%`J-A9Yk3!8D8y4zUoj%D*tyMVhW
zfa4QuO?tYMBnlupS-U;uaes|Zh23d~nq=XYV54xoTmFaZQO##oZATqR@hLhgC9m=*
zP%qx9u0smPvOqTOnRmJT{ALwx>|mbdNGj(x9OcZig~ZJd!M;B<dAo85Tr?j|4_cLK
zpkhQ$18`uqv)pgJm?35stC|E^)9u#0TOB88*Z=m5OmGPTJ~=zGYG!(kw?cPRvbgKv
zdyM_v&y3l!F8w=Iq1~JhYbZQK=2PJPY}8m#JS3$+La{q(bN&Ckf+nDwk$xPMCIGI{
zf<RFed;2wbGP7HhV^CfWXgLnmsv6wWb8wQnBNPH~lyW6W@ij09;$N^g-qW&i7H82B
zQxX$Yd_TF^?P8e0g2L`H%MQiegWF`4fKo6-=e*X9c>+f}quTJwBftLv1yy*g0~(`3
z^oX-|9_f!v4;SGa>7S}8ISAhIEBrv-M&AG4axXnC4;q6Q^&P*g?6jwLwYyX#%dpYq
z+bKRO!D;9ygc5|JTA)5uf$G0jxv<$kN%J!NNEdPAa`>msZIGtFyjylXwG=R;*~fV9
zS{F2ZNR{T3tjjZ7x0|ioGcN#Sm>Wr%m;)Z+Qc0cv0iFP|eQhz2o%NABTz>!H(hr;6
z%12+tV_$Dmj0H7rFj`<Xu7&a6Y0M++4rL3~E|)|-_Q@G|Sg<1;F^&{WEO>G>RK`Q6
zBBqBFiLvtT-^7kYUehXIq}^l|#vhH)T}#^{Ko&^5BbNi!LIjqjFh`2=nDIE;4aKj5
z1WY}i;rKDAI-XfPFU)`^`t&tu$Nlnl6BG#m6}u$?@9_s}tLmRyNz6O1lRV{<)VYub
zK*@oUKm`FH>r^MXW$x#oc?r(IY;@|>uog&KKb4{mRUJEi8eI#?V{pffXh5XwY+2AS
z=766AA8*-Sws^;QlRRXhKtU7mDA#@h{607ZY)zBO`enwFO10~(OH4rN)}Tt_AiY%$
z6$0c`wg{WzJ-<a&kMLg1xW(vX;}+u2;3~z@Csz!}IZd(iFTO^<*9{cMW#FmDE(R04
zk?rmh1XM0ns2yJ99j=|fgo-TV+=t!qkWnsgLr<z`nO7t*iGj<@KP$*NE=`}dbKe!u
z)V`bAl!=2Zm&vmBF-u8yz!d~DJ>xZ@g5Xf|x;#(NGjZ~{CO}gZsLnuY|BKSjR2#b`
z`H;n2V;{hIwp`il(&qZ=2rq|A@*{^oBxDa+Dc}Wwtd!$A2?2b}K^yRKKK~P(3bvjm
zfKDloy1na0W62=5o5VfAh%qpnCQd&Ks(pbzbpL@@7q#N6><*JKlW6A~eQGQXfpBSz
z7RbbcfNc2k?l*Pr&^5k##(3D_<g7f4I+l~dczG3JicA|~+~jL_Ns(0KW&v_*+PwOr
zc^XrP&UeC**6IYH;zmlqlN2;IVYO#S{v|Pp<~DYy{8vqW65ovSSJ!`3jDFli7(Y&a
z$DA1Yiqzj~<rb(cX>p$Intn4TIi8Jrp2Ny_$?F$Q>I2~CSbvckJ=8;iCUSs!y4l*-
z@*plk2>1-W{5SAIur=wb3}y4WP1l;GCb;0woCk4GCQF(Y%ESzia}$9=^ZtM>c;168
z8b;K6#1XUTeKgTXn|qR+!X}<>j55Cs8&!UnD25`3xI+dJhBzLtmC453_xmtXB290#
zqfQ!Dsdg2Xrn1mUgbfvZl4?IGNE?(8qPa|XdT0vj3jsj$boe;5bnN&iGDnd~C~?QD
zpID9#a`dz0m9Y4C82pA>9K`(Z0j2g|+Twj}i|(a(<Jw|8ebz~YfW-&_dN5@Ucqh1b
zpLM3zjq&KUH~$C~{1S8)RPIx9nrOFJ>)NcpQ;Z}~r8IIB*hlXU)45jLy=A>m&ez2k
z&5FW6Rue$Iebt;zh4G8|4}gIt5!)mPXjeIKh%tZQnz`N8chT`a$~5r`nwz8`;d1OT
zgl6)b)dCl?x=*dM!r!G?P(NxtKeCm#f+|1Bs16-Qsq6Dm`JaWIe=yoPX_XoX(9V)3
z+unbhv2(f!)ns$f+937Nt>70}Yge~+SKFs|UI55(u6Qt46oi29&@8KR3kw0*pY2St
zdJ*0goPUK0jz84|@~$p`7+*z(7oC*m6J`}CgzWtHg(Y5b4zrKli>+~M->V#*@DpeC
z<p&m>v4<`ki4K;(q;W^p=X2f*J;Bsvp&5a~?k@chrkI_fLt-sv8jVD`>cv!(?2xsi
zRWTmr0H~I`;K&m~twd6$Cv$;nFf<Z0KG8TSU9$FtdKzZ(`7Vo}i_{U#8UXRf)Dk^o
z6@7E}EjZFHZou7gZ;}Z&bk=+sT$_9A9o%4p#mvs5EO`Q6V$}D62Z3ZdF^zenX*d_y
zzSTM9x!82=3X8Id?O}Gg+%4SM$O%!Qen*iScOPukTFhUA5%m>_p(zt!!g9b-H(j0u
zk}jFq_roZpoophEKgF1fuL{#KXSuByoE+(tUtghmJMj^y1)|eIm=VUqu#@<Y=pNLO
zP$4O^eoZLs#qS|zHwL=D`=g=xB8gC;>*dt=&>usm#&~<h-(4O61dtS|v0W3)rCsp2
zi%KbOGPl3Q_)mYA2`>N3FqzLG0~@A=>tX&H7XqBUhw#2TZa@pSsU0*VT2HS7zXWb%
zlhrev+~%T#8}b@}oF~8VfIg2V;Hxyf4*Vj>+up)}`p-UatFe??4KBEnob@M|K#ON1
zf#gKNDD0h>A1v9->=Tbrws&T@s5d*$xYGbI*p$+aRwC>ElN_DgCS5mK#W<&&PbeJB
zxE>J0RTjR}FTxyfZL;02(gUj)QPMCx(e^lm75N`L1yj}as*Wh%0EML<dvYj*BxU|m
zxhVazissY;IRR#27mYF-Xx<Kl(NBE42~IxS1Vcwu4a==HyfnXCA}s7P^NH;z`exaa
zX)f){b0w927yKdXDpH?^yeZ%XfV?SMXipC;LcsU<b2Io25S?oagP1NE^z8L?c?vEJ
zN>|IG9pL$$k}swkqyzy{%m#;#Hg?jP#?C_sP<h=K*jYDP{TlVOS@((VSMMhYVa&J*
zNFQDGwiG%Iia{$)v9i6@g00Mp@)J1WBjJ-FAwYtLoD}t3$=hEJf67o9317AD8~v_p
z7d;W?j);y``h-3~V!@(PBRL&cZi`dSF#*qbpel=RMi^-9n-z9kdHgp&XY51d19=Sp
zxz-NvixZm%&8?f)vzG3N|KPvpM*%MY<VVYrmUwV?A_QE`539lNgKq;9u9}?L7eJX+
zd*5#e7kriqW0!`zw0aA{BpC-a3j&yg?4VZp;Zecbc@L3{WL4v%1{@P&TC(gGHJfR}
z<C4&$(mCqu1Q@ow=JNvW=8r(2NFo3zMC^%&F$0{K-uFN@{xVS~Nr$27QLMVl`j|v$
zD+&WldLMUQJ=aDzQiR6fktR6l474El*eETxWBkzx4gQpe|KcZ6`C~p;4TdB%YjBqm
zG_Pr10ZMavJ8Ni@ZEFd7*pE)}0ziW&lLz=u2my%R=ELB>gHym9wr;f2NLc!Wv8$Jm
zeT>9GXQCojq(Bn8Z@qnDfppGLs%VHuv{BNaxid(X^K|1pmEFRah5Hu<+f4hvk_8QC
zH~pp@A0ee&9yT)EjVECe%1)>p{?Z)ep@pdN%=FBR`u6l(EWwhelS0qcNiPV`t7lwF
z#x#1oQ}e5QanL~fe%V1OR8t=QD&0H#zQ(;bWp7^BK~2`9;NOF@JoB%MmWeL*0ze`%
z)pt@s2$(}Fe+_;Igrl}-)<8Pe1M&@sA_dMSiy)B#X1@WA-|<Rqi@nq>oU(Nv3!_=N
zlz3(Q1n^VHJziP6>fIR`MGvu>^hMPj38~Cikp#U}dqKiQ5&=Nj1eL~_RL$nVLmD#h
za<ieZHKV!_X?#S=HB_s|dj8UC0A%0a|3I`e?DQv|W(=A8s%6}))rCyI%Xfi<PnKj)
z_O6?fX>>B(s38~0iDo+Z58xu!%q%n4kdF1|M!f*gq}eS<vq~8BDQ@`<@G5Xm+#P?k
zB#0pp$8CS}W1NWQncWBiW+Xe%y-{yA16Yg$d2t_)5OCCSq_o`-R%(+lpq*eEW>Bra
zT`c<iOAXClrlf_*+vFgICo@l)d<M@vP8|mnTNIkAR$n3wJ*$#Z6(iZvCdw(0=BDM&
z6(dcm0TAOSd5<|3#xI9P?E4LOpe@&Dg+{JkX1cm>M@urRop${i%`Wg4;MZ9v*Xw|X
z=1{;30L`Iu{4RRHzXWauKM(E?wmv9P2)X&YP{q4UWs2{X?Kp2{RFM)00*XwKpTJQ3
z1SX$j%(G92;aZDP3)hq5UP4Y)?o+W-&Hq99@^d#iFnH3zrUKEd`&O6O$((>yE2DWR
z5!vxOP^o7#3rq`{J^HKkOiX`YG-2b8M=Lg&&tpvBG$?42nhlx<mBN1XUJ!vyPMYln
zsFPelweP_Ex3yQ-+rPJ70BG_Y7F1hX(FA;pTQ3K{4h{pmz}5#>Q{Y!FcR--xLfZAz
z;n<aFz%ma=_)ut>)UE4RyTm5usmHQw1+wh^)p@5bW)W@{C<U&H>^O-fYp07kEAz)o
zIM<~WEVgsaEkD7r4YR~CCxsCOMNOCcvkGf1J$)D9YpN(X?fPum9?efCD05xGsjp|Z
zk6(;So|X9?nK~9;6sh}Fx$mKA?EV+^eL}7D!_oSubr5@nVTa+N*%a^sK(i@cxF3SR
z4upVf`BN{!H$gcEmRWT;+G?O(2esJk+GWNbH^n&#2C@e$tgD&8!s`~`BaX%_F_w7t
z3s4a+4~2ongo<f5l(?`7q))|}3IlcOV(t87!fXO)JnL43Uie8f=hf=gpHLrD3?`BN
zzqqXzw;%-kl#GHO3bXmilu!g&$m*JqJzHjmJAau?r7eM`-ZyIB147&W(I-)u2O&q#
zImwNJwBd_IG^y)PRn#Pnx1DiUJF5FNbg7%<6ZLnXoc;8-hd!V{ALy+5V3aL-%T1d$
z?Iv^JO1gJHcn~-qY#*U)H}CDnH89-SVR9JR>Q%r*JECUqinJh;+0G6+9AANnIAfui
z7(UL}H^Y#~cIX6wYU<#z_!lT2eM*yt-GY#zyal2~(*R|W93%4*xQG)savFO@c~>%k
zu2VVR*AY%ce}sU#;_oG3ZlqqtoxkSI_+2*UuVKh!bn3b3GXauoK;d&{Aol#JmyvGy
z3S%anfvta(tIQW9^$*BE%Bq)0_>;DaQrh<RYf0m~Bw0R$s*N`NM{HOwt?#G!d>ZE8
zMD<zI$J+8Y^a4O1PZ2_Z0k<LuNC=Q_7w+Z!0_xqnG-qUDs-*F?s}^Avn9pL3KhHsj
zh9yi>GSgf-jNoBqkCq@Zd`!4gJ{CLe;bV>6>n+Yp+A-_6x?93ShE%|=zb|Yg)T+C=
z0)QCq&{6n8jC6ulT@Q+!$7bDU%={T>K$y#{Am0R@0keFuGX+=)gNk`i!z`UWdkge@
z(Ae944tsdCKDx?L^;CRST+~F0fk}83ZAsc=$X02Ty4v|Tpm9pkOm3%&E=uOZj=$^n
z>x^B9sY_a$_5zXadGNd7Kf(B)W8Lc$a<&)Q8rxeh05q1qiCgDo*o6=vwHPa?t08b0
zpLMP6iEp0Qi7+Pn>;hw#J;Tlf^{Ya}_TDG;t~!tIIKpWm7ZVZ#kcmKAf#Xjjr@?46
z1N2KfRyj9nfz2uapaHP6AE=K}r5&&q|E-i)J_3c&00f;Hk4eRcNDP0;Q^wqO4J!N{
zX?sz6zJw~}mwy@twHi~5RMipy_F|cFDsy_G&P2<;&R5L(j+cyGx60Z2?H_I+(a=L-
zCdkq|q&uQ`d^xM8tp%VytH6?c8)5=X)a`VgsN-zWM-G1E!RY$^HO9{4Ioq+Vjt2Ym
z(uLgp3*fad|Cjr;C;sL=6sWj1^qk?pG?fDQ1xP5H0RAg@E(ix}Qy4eV1nj_q36sJ_
zxXBuUiVwFK{%dF|lvQpGjB3dO=gl4{q%CNo;{pHx6uU`8K~$|>9j%A`(bqx~Lo=sI
z4D}c^8&`hZ1S;s00qm-0jk)0m_!RKj2v8s2LXgX_F@(pBz-e<JjP<P{jTLq9(pL6_
z8=V=+ph+=uD$EloxD$N#UqVe#o$WT2`HS&y-)2;h$j-W#92oFUJ+tiz493Oxf0fUt
zyuH7*Cb8lg*;?J~tll65XkLbaUj{!0wnwNS9W4QcOpPU6YVx@zkd0ltakm>RIkO=L
zYChoF1xpPs`|5robImJy_wyMtCjR$7(FQ8;W`pQ>>0g@Q+{@DoF4~>n@;}r7nAY50
ztIuL)(KFCU#zw)R;B()uTL5Sp^H-e%gd)3y^t}&H$DD$8rjhh%{LD+ObTz2W%zBuA
z(@5F)q4keDU@Y~}Y823mf)KEteo1P^u<E>Jk7%`iChCtE>tbq;lRv<Yr0CDdQ$ug+
zLk`=+1QIor?If)@Rav^s1Ts?y+YQ7VR`7VdjyB^>sJl~uYQno~Q(TkFsS!hqK67cb
z(1?TzWiwQzK{+FiJ2q71*Kv=ga4gY6CY^=6Co(6sKjRn0*Mi>!f9X~JB1db27XVsw
zUQ9t+R;b`l>7slC&}EvlKn#;@2-+c2hSaL!;NwS!Rng?hF14`itYX9sf|^1=J@;)~
zx0Cfs%s&g4lA5`xkqgO&llm-$=^cPpY1n8SJ;#_pj-M2iG6!I4P)K50lTNGyS;!i@
zy!Kc5KRmw)#!oE&WA}w#{f!WeYWF11Gk74)L*Umzh4>-ecxY7$cmbeQXQt3EUZB?z
z0`RJGse|Q2^J$PRPMd->0?Tm}#I9*)-erOl&%iN{G^*OMHE<W+Fd;yWj#DmVzq6cO
z+-5@QUdkS}mU&9kv#LO4Vx@9!Cr~0DW!yUm?U4#14WZJWO6xk`0-W{~7MYVUnVzBv
z3F)F{b{Q8wI{#5)pO{I-%N6ae>et{!vgg5{fIkE`6*e(^_0Xym=<EGUtJ0+<`-LE&
z-T!&uH^39Y_7~u!wmoDB83l1@n>d-0z+=OmTg>~KapnfOKk!=6wUfi9ZeE7@BLt}a
zy4kokEM@${CS!IIwns)gqbz=T@9@T-VuFu-DSb9ZobT-a`x@b8YjUG)ZVl;~Pz?V;
zgThFX!NYMPB<r4p#6vl@Kf8YYuFyO;q4~~gLzusc3+<%1)`r!j)ShYVQ?tTIhrFMM
z+$JGaL%aY6hXwP0!24kQvi*B#0}8Z118D;y=ha1Ctk)0%?w~!rY+nJd0u=|=zMut=
zI`p>tx5msP{+on6s-_l<o8U68^*D>=G(s)zxv~qHF68KVfDpB_(!(BI5DFA&@Cs|8
z9J?e4Y~H}W2-gnh@s0;Pp5D#@v0lL-i(Q?0Jk<O5$7i)nlQE3QI<^cdduS|USBbGz
zZWxV1bzM~UWfo*fmb9oWBNc8%sYo=7tX*XyUs<l1$k;RX!QeODKYyS1|DSWt=k+}2
z@%fz3d)aub?tgefE9<Xp8T`9ZRuNU|dLu%S=ObX*g`Gl?3_9F8=8!N&EmV7A3D!@e
zgFaD2=UKaLXX{8#BpQ+I3~e%bDK78L%&FN6gm%ULkV{W^GSB*d@u1{W4+|8xb*uVM
zX-Z)1aZf2E$l#I5e+I&8H)wC_P|9^a4_<3VDp)CMcf2Z;xT>W1K)lZIy>UfnfCPr_
zqJ_$2RlB#GOFc=u*5*0V1OZ$ADCpzpp*+hYhuNh>#1R8c)KpPXn&}>Qi=cIddDL5M
zE`63xH0-rMPkEyq(Kn(wQ~Bo#XmDB^oz<o9dHdU1)p9^rsEW>w3KL*g2uJqtgJ)Iy
z)+#>j?yo*GM10KS<h-mj^z^M6d2^t6xcBw&YG&tKxbR4v?5qspO-4)w?keYHOojW6
zb$NB%vN=+y7$^D8{5vCv@9MQuO3niKn%@BgTxT3rZW?R7ct3*xcW?{n_TRsH-u-(P
zFR0_6c6tt)CTffUZnfh$v5VOFr4j}UqpW8uG~aj#Xk|iYPOk*y_}S-J&EL^-(Tkh^
zawp0I?%!Q%wUPUkaYw~UGL8x){!+e&euF63cbxe~exUkuG35Qriq&m``Eu-4iSQzW
z69LdRzEbtZaP3ioj6J>mSS)oY>0sK1NhD(4m2%e)JX{d>f;~x<W?q_If-)uH!xKlU
z4;Eb~d&%Zm$SgBa_hvc1;A`%LRoj-;hWrq;ZclWR=nx1SZM4LMtL{8m2)mZV&9`<t
zdT}{SdG24vUNa=I^-JlO%5QVTmBf$Sw&!hA>AfMDqf5^xO{Du`J1kr{(YZB!M#+Dl
z?BJe#@cupslTfIz$vEC-e=%xbfh=(p?q)r^IsBKc&3UoV9hGLq_B_*>@)BM4P(&!!
zyS^*gMVftg-jP4cO{aBZw<A*CUbT{5T^#N-u7am(cHGAW{)niFc(<L0?@sY0N9ih+
zK{5sI&68MEl$-y})~dec#Qyf-F&F1j6<5^@gtXlk{&OvY?y>l=P{Z-o&nAOsBii&m
zvG)^M5vj0+<))oe#ZPW0XMY&ftzD^X(1J=s*o|vx@Z53i@T(NqP`K3o;O+toDGfLz
zBTq_}@vi02bjKXw`ikl00sUSRQVmmhPHwvVJ#-I#q3~7DpJzsEv|NWGj5b4A3zWLm
z;EW|U0mB_=-Z3tG6@`XmPI~}$_a)h8QtHb-rgU1T{-or|I9kLNN%|o1GgBxoArsYl
zsn6Tnh~#$Y)XqMo|1rh7LK-tm=sv>ufkR;@|1geRR^oG*PKKm857kXss4!umEX3r<
zU1|iN-EUG^AZOzN=!^PzCNX^3_W&sU?p~FX^OUSG@%&Vuqo;qI?^VzO?0RXTy&jg{
z%G{`EZ?Fh@5Usy>Rp(rPUtVEX3N%Gt5V%5+BPBWSuey)OUgU`VO54!UP?<~!(}W4$
z*4#Xxf8z8WI#9E5t(NIQR_Gpg4%nHgMW4e3&SYy@+@d-L=c!*f*h04I*M@(48M<|^
zV%JKczfqpyr8uPb$zD~c7y2Q`M`?Tber@m1zjzt5Of~Xs^9zQ|{mqUjM*C`B{PUyP
z)FZfIj)`6RuPN`qt0mCGKj2YQF3Pe86upl6d2NWn&LtM!)_hXyFkSFP!;hp8?#HY3
z=^UD1WR8z+_Sb;Q{OI|NhL@a)xJgRPwh5CY7TO|MZOBM*2QuiZ%aVsxRa?lW05#CA
zyoK2Lha(heCt0}G^2m3|0}9bvPpQcBWmq=k@Z)fVpYTL4y~m|fxIu~ydJfak?drXH
z`DVaPg3?U#>x+lf6VHBRe_B%sv9{JhwLS-tAc2T+ozkxkm3U@tc!_b}tEhe5AXy8o
z*GzHT*vwIsmPBWblJ6ZQoBu)5_9^<_@&4nF3)O|Ve4{#=L-kO{$Ll}z383<X!<1WI
zhP8gG#@jb9cfNORZ~HPb(J|>%hn$hRDk}(%%;Ky%q)UMf0N1{!b!6N?lPM#`V#k#t
zkyVUs6Cg52uSX@#KMh>2-prQMJ$lWsqqFg+45u>#7Xn5kyHhZ2b#*#=!5VPFprHF{
z^jx@n2Aojh1JXu3BKNMjgLn5NDYWNZYIV@@Vj8TKSj@gMk{5!-BBzM_2<AAh_gDN>
zIr$CbIH}2Yi0mK@sxnvWBn5HVhLzSKU>y{u?ZwrDE499e`K28hqr`r1eB9`shmv1E
zUf)&5ZmsHnv_FB(>?dvaH!qB+4aruN?fJx7kcz~16CMB%D#w8gujr}PdrC)I03)BZ
zk(;Jvk?*8d5g3=^vETwct#~~H4!bH%(~aZ=bp3Ju?*_C>WAl0#tht_6L^a#FZjd!N
zUa|nw$r_As3jR>=sX*yedec_8@Po?Mhd;MUkfo<nL*z*9s>Hk0p~YRr5%~CNsv1JY
zUDQy!CII8Dgj5nhHL9kbnX!@96ph;<6YbA$U}a!Z=<fU}kZ+TTgNs*(DgornEPToR
zG^`hEW4RLWCF$QPZ-PTn^I92k6j{O9$kwk4uD1$({^xp4n(^OB+N1H%1>u*hww@)(
zK7!_fyn7Xm`-Qp~EQ7P?Ac0Va9*v$@TqdM~pmssVmB~^*;gr<N{$r#XXJ9&7@2tAq
zQqCoLt_K&U*!X^384I{cX+dgcI9RI0EGE>yKE{$WreX?)0&@bPIX?6FO9@w|&!+#V
zh8x2<=|86<;wNSm8P96h9DTP=y6recDhiS#Z3OQ_cknC+gWs=q@|HriC>Tlz{;7bm
z;}&wUcJNWvE9JPyM)=@fMOQ$69&1Me+>6F&d4fKYTOtxG%p$d;_jpRWyJCvuwJ=lR
zF`!h%Z)#)U_~x<n7>(;S9vQ^mAfFO^;JW?kFBT(R!}sdbFC`>rH$E#~e71R$@#MXH
zoU>YQ`Ofa!@s3l(r>R4WJ%HHwXj>mX{w^r~xzq)vHSsM36h;M{J)<L$l-;ujXCPsE
zC0koL)5zJLY6|YvaCOZmumBM71<R3p!AoYD^x!`veCkf$mx>+@^j{C5KU0wuU-bG=
z@DjbFYP6Esc%vGt<>r5BJ;3ntPJM3Uc=)a&Hh!Kr5nt;uI7XOg(u3=@{xXZ%kdcCX
zwXmu{Oc(6#KCqh?EP&bs6N5dFI6kWCHzq!ndAnxL6e^kw9KIlPyMpV3r;<szX!}0(
z!&*~3WNLquQG!vBlYt}m5z69lru?yN1+&4$;@6LCqTO;hy?1RY)*dCMy%6kf-37Vb
z8eZgdP4+McxkqYeGGMAQo=k(0tj?bvdQSl@WH)dnrA)j>{E0fhN7j+g)ny04!aDLE
zw52Zve4b2A>EHxqulMn`ssDQD)bIbO7X~qOd-z&ZnHK<GPbTtFd{h_!`ewZ23-K3_
z1knq%m6B7ng4TJ8x@dz_yjs0SfEFfD`6yV3j#IUeb|lTQyqVrKcNq7~IX=yFojO28
zr0RXur!Z41aUmj9&?eKu^a%_ZjlRi@;)*l>VHTiE!$h~Vf_mX`mr{xix)u2`{L@?z
zJ8{(kg4p=ouiIdMZSZmgLV!lwNNyAB8MDI9|GRY@EDq*VPF7%i+dRRXW!X~y8Js_%
zAPO;GAKDDa*SAa#ZbRXu^M@@j^8Kf1-QZBFvAjqFKI*#z#a!^W!cGTMiHT(%GE9+#
zh&)iV7inXf_MHBe2t!Lu`FVG8t7#CRw%n~UGD%FGnvwgMT+}ots9WHO?<glhlDbS%
zs<`DpQ2ZMaACJvN;N5^}zzLZm0A2oe8S@OjL%1w~w7Ld?-maST!>?@<Qcu`fu5GB;
zrt#UzFafl|^4eOgu7fBnum1f@BM+`J^;x>yAbiL6Ye}TliaxCKAxTq!jx({?GXkOi
z*e^nxeGMjXs-M<cH$Uh?p`HqYGXf+6fqJ)abWr-Y=%i(lyeX*sY(mqv4vRzmQk~Z`
zVAUsLV)HgA5HRJvwDnNl8_m;?gfRl70s*<8V9W50e?-b$_Qo}BzoqrA>_`>w`3oAG
z*p861dIJ$XMz%~J7whRJf))LgWD$2*pvu>Zl%9GEl4d!a@I+sk8n&<HQ5e7`mYHGF
zajgUqFV?>+!YZ$Iy($v~J%{4~?n{gU10n7ZIVWy9Fq2#Efk8j5<$sVDA#2K4kF<RE
zabcyLnsN6jS@h+akdQQ)txGoKAIQ}$XGijr_{#Y5^bE?V8vto#S_~p?ik9iKnpo3Z
zJ$#^W^RvkNv%eV$H#$i#yn`X*Xna-__dZPs{fRY%+@^6^-e?4@v%n)KKy}M&;l_{H
zRM>c8|9=+iAB!vwT^UNMyrGLXlyx;hmr<5+8+$w5XpD8S?blLBE3HRlpRI(zK&Ux+
ziF-PPzMuAOt8`if=DY`xfvMkB-bA8AQ=AUuTLxj`tT6M;X__fioI2_w@^<ABxoBsW
zdxNWi*Ns<$_>x^_b_TZH)%4<~PXBI`G9I|w7Fj?a%dsB?NK0tw*x#4Xf)~Sc0Z+{M
zJWwW^f__Vn*|>~LpN>ww!aEE6l;r`Uh<i{{PKZEV8LnOh>$`}MbK2_)rh%M-S=HSA
zTu)k^^o+TIG%hVgf+)!Dxp#=9E-<Vb*&3R#UD$6ULdf&CX_u1?YJVC*r6tzJzSC*S
z;ukcEAbK1!gnEu<3K=~QKn_WxNVNx(F56koeFnD8wF%9c{D$RemNzZ<_usJGk_21+
z6%-~+;-{$vKzZ+{0z40td_0(c3U8k}AcITW2a2D$99vtIWRx^9SSGIL6Jb`RvUAwx
zzpO=JxKO|@CJy$E2C%0<sL9L%S{m6^G@EhZlP$U&HyKwB&@feKof?;n^En=?i*c@1
z*&*UVOnsU`9T;gP%KJwm<@7w;)z(o}I3NV{!CVw9CLdr3Qx;d<qbeySKH-5bx0`h0
zavCyax@_9!CNe8aww&?Uc*`kkX!h4ypgGxVdA67wKu-fBN<pO{Neoy1F~o7HQsmYn
zoE;`VwOmHFy7d(Vyn$@qtGqW?T%5XjG6ia^IVE(x%&uN|RMcF&+{%1=nFITD%%f>j
zo2KxgXeR`(p3oGu<hA-=@vJHYmAs$&cI*hLu@V;!L#2T}1QVBtn=(>TKy3*)^nzD@
z#kt2u`D`@soGtzVSW<ExgAS8F{Ox-iH=W2gNHw4k`8||b-2BYj!T~8;;u2O+!?z+B
z%WH@#Ss3bfhGIT###lpT@Bnr7UWhABy3ba@3Uxcku!`RR0ju1rr9dDPruiFo2gD@h
zT3pYtu>m>CGnA=@OuJbVsYS-B^-&Ku|A9*ls_A{lR%`x!7sDeC*&D^pk43w!#Tz9i
z*BB%Xm<{9Js*CM9+u@A^lMzlL1xyP-3FZH(`34QuXm=f0DRt(7E<!Zs$q=%u!uNX%
zG74G}j*ak@Cj5XSC;A25Wzx|tpnk1$^j8c=c!*b1(v&+}6g-slmxwPp=gM)fe`o!Z
z@6l+>kj-BZSkH)xwUAT_I^-mR{mr*)f-iBfpC>3q(nvGq56f+$liKgn$``EBycaQ6
mvJ2{2yJNcC|2NpBD8Vk{&_&S}a`Kx1(RIwp-Lb|#i28pmu!Q{p

literal 5797
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

diff --git a/assets/icon/64x64.png b/assets/icon/64x64.png
index 3f662265e976e33a6f8f98f1a3bcd9f08a8e656e..1fdc81a25d35f57f9994314ec1b583bb25d5edfa 100644
GIT binary patch
literal 9255
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
F{twkP)YSk0

literal 3131
zcmbVOc{r478y`!y5~5S4VhqPpjaeA8FxdxTI2v(CndQaA%rG+;LX#~?mPEp#L@`2?
z6FMlBRAk9sN$J?jv87PH(Q>};k8_<rzW2J`_j&H;y?^)pySMjxPdSrp<mJF}AP`92
z&eqCBw3@BoGE$<akP$Q_T2y(~?z{tRA6_Vh1AxrwY$^b;V^Vwp7l1+!3wi{YfIt#l
z2HBnG?&yH0v6=dmbsc>^Gf;#EflN&KffSlQz=Kc$Uj~Z+ow?lzg)ry@s2kc5;TUKM
z_%Uq5IlzH%5}6k6Ps7onru!f!e7wj26W~!Gd}aWPi{}%dU+v;W`}Jcu6!KMt=TCrs
zBjxVs46$T$00>$i4Wl7YNC*a}k3<{dkjT9d6ar}gM<U=T91MxX8)EQCBgpp)D)Ppm
z``}%yh~IsQBm&fr#|y;6;h~|S`k@B;Y>qD+iNoRG2oxNJf{8R>+%Oi8!iTZAnm;U9
z0bCk~5y)e(S&(&$6e>HIM}Uf$ehYya=;-*jVHWp$qC_c!^C^LFq&@=9WUj~cRh!Fm
z0sc$lAGNvUus{Ir0&v;E9Ga*eKAJzkqTKzvqjg0Q8@v;TAu0+bz=}-^W&$jpofQEp
zdZSNg(D7IV9fJl8ePAdo9S1WsLStb#6jqd5oFN5+F+>{y2Dl$~{t0i1!CF{hQI;4S
z4uM2k8(^)`7M2JDOPmqP8jB+u{lMC>xI7Ar2K?~N5c&R&wfI*o-jV}Qcx(=t%?|j{
z1<rnK9-HgO4un`*LUbJ|GzM#3)?2U9w~(y>4kHAh6FF=q<ZF`gjDH|N$07_2QHB&4
z$_Gt{8KSWO4CjNP!q9XC#fJ(Q&~P+S@Za$C|2KJX5h?h3r~FUn{5TS|<NEgRIS>hd
zPZGcqjSojOCl!7dUV%U|hwZG)$^5}-Pey=>>(2avmn_DfQ=RwkZ*TN_BmHx>AWkkW
zkN4-6*vzi|wUUMM-~g@o=-6U2>LzN9o^8>7Tw-QvT+ue?ivmAtlDfkxJxTUdvt;<p
zdn|is&2)aWEr-U`&}y}B$@y)her<LozoMlgDa@{}-BPvr*4$@p{RKs2PHVWPc9viv
zK|xtOudKefjUkM9CP6kz*)VaV8?-e%8-Mlg;;E`b?ci6u_t`3ECqn<Kz0xcx1RqSi
z`{0VIGC|{V;iUtfW$;VIYvc6|*m}rP%ed?D54)vGj$g}~)HF*FTo3Rw-c%s_n$R&+
zEVwb+mtT9-!a-&<n^7?_6QT63cXa7=)xxpo1%1`EbqPnK?Co!<*gHFJ7HDJIv*`m0
z3_aF(YFcru#ZuDU8S+*{WvsMV;qWz7&hE?3<JR*{CZ1PJu|3vt%I93getA?RH4*Bs
zDV2WgIm>Te7%e+^=y}uuk2KT6w@C`wcijzO_RG_&!3fp5-uN5jn$JPj%Ml^JPke4h
z#WWNwhg@*=bNIaPt+Ba+jG2zLcS>JpVuYK`L;sjv#f#U4uYuYNgTbGRJO>Y@rI$2f
z<P^ErWA^QEd7WZw7XoPuJE^zDLKq|osEa*<m}TOBI)!d5n5{Zmu}}|xl{;N0R{DVE
zW$Ioy#9#c~=%I!~hEHR*io{IhtD=()gKzY%__o};UuT5tu@Oj1N<va&B`=H?jGQkX
z^C?_a;sXoAQ(4YB;6FmzL)LWLTERJnot~cM_VuaL5h(82xaNEFTrIVMs%dkOx%cWE
zRpLvLjd9%Rqcit}EgzruvKYaXOkd(zAj)P>aPiDfqz;sQ6y(hOiP4dboZu*wLiM8t
z*&2=E-Y)S6_5-dG18SpF&mlK72P>uuDFJq@(F7$u4+E_`3!EPF^dP6y4;pOc$yQtb
zTO|lrUTK%ujTD~We94>%VRe=i$ld7Z+P5)RJ^t1kyOA%LARS0RX5iEG?k(;%-tRPo
z%6v6NF-)e)N15SB0kh6C<l3{sPiRN4t`E3@a;9o`#0~IdOIBXt!%(?2s})aBBzp5D
zH>-SMWL#vDw)Yk@^T^xX2h-XCft#5k@x!g6xcGtvXR~%`qB$v5>dd*bS_a1HvI5nN
zP4|+fKbnhu)P_uB^a|9@EovL7^*W%>=2u+m+Ve;)YP(h2NcQOqle5o!5*y^7m6hGt
zV8bBtdFIJ5(*|X_;zjpr=B}Wc+U47OT%`IVqLtt2qqq808@fpJ-6z)^DU%4N@@5pA
zo+0`#Ynv_!TI#k;UiXc%zc>7{Mo~O51vDg`MCgtWz6lZ|CmN5DD!l>_X)i{#thANY
zXdOGfc2veUJWf9!+_nwl+=j_imF=jpEL&cDR}@DT)7?BIu6PxQjTm`ND{k%AuQ<Oc
z1(EO2oG_LC*@!bHg^cHA294BC8=Jc+Zx`1~uJBJsUCd8;2RErKff+4}_c$8j2FD{3
zX(f}(s#m+EGjeph2jr`c1S>P+m@(JL^r%lKpI6s<p(kqO>mnr+6a&*sGIN{FnpQMm
zvJ}40Hu}-9fHSm}2%Xrvp17y5*-Np%UXIyskuA}4gq=Hd`rz9WT(;|so|+`21vCdD
z2GENIL(j`=2g;LZofd=c{n!%yf>vf@f0=LEsw!w=1-H08wDq@uf}+D6Rhn0l<RahS
zv3?~v4TjbY&hkyX;{5OlqgR2raO)!1Fd^4u<zU`a(-i4|PW7Vvp8dICy~BOO(vOyN
z$1R3h{z`fHF5(U-R_>rhmN|vsC24zohn6PynTOL}{f-Z=AD{X$UxRB#^TIy->UX@U
zjj}@Ncqu*14?j*`_6O1?4r_PI-pU+2Y1_4L;}i0gRdx5&j*~h!i7Mw77k0F(+Ev^6
zZ=R~9eL_yorkop<S+W7oI?<xSZg*s=_e#<m#MKlp0(UNvvcAZlX_POjO}<Zk^~J1m
z>*J3}K<*KVF;(F`W1T?0ttRT}7$(ZT)!#m;$0$A}|NK^up&Xf0#CeNSBdZH;P9~I%
z{%Tw2!FWfojzl%d=fw&*y&8I^efp~5TJ2f<{66W0Wf{fz5?3WX+RO%_o%u)ptaqvC
zYc=_TO!|CxYFPbgsc!8yg9>X-X!qRSjyctixkpup2yYXocP$Y;qJZfJb;G<$jNGcq
zCz(J?kd(HUb^UV2R<TIgV>wL)vdjgO5%q9vV+T3!>eYT<NsnX?1%sQjb8cmI^{4&J
zB@+q;hTm`G)a<4{mT>Sweu)`YJ1RH3f4OsHrJ$>ECQD<{gzV7>&!5y~UVBOxlN>qZ
zsbAg@=eTJTO}8;?|L8?(NdH?**Uu7d`+@rwmelqQxH~VF90li-wKE<kB*$WPtb6tL
zRl<*UnaEzKf%rt$ohg}6k0%=aqAEd3ays0?7fW5t*;wUXh-VCiMjyU6oI0uNB819?
zDm*4w)~yNJC^eK)+nq!g7v1tr%$>VGZAPzkN7a4V)iP#Ny7J(T*J4@XxUDt#fDoE@
zlf4JjnV<2dK)5ZV>4j7Q))*WcJ<y*ntX*xxIW=Yd25JedY2H<yT3h=5Jg7x_`-a)1
zk>M@{z3Ci**5(*pS159z;}0l8N!dj_L&<GS<yM%EJc<-s)tBa-o3~4T@4~Mt*JVB^
zK`aD_Lu8@~hN-A`vJ`5^P(u5T-HA=^|C4a`U1i($2883Rl6MSf==YN`QiL>@T=bP=
z^N$lo@T`XT>d;ON#V5+Qlgng>p`@n3EwM5Us~*U^eHseMJ^o3zo<9kVW}R~0LUQma
z+EJdUs}MbY>1BLxjOK&{(OXx+HfYZB1Slnz(7kqSHEl_3O%?$<xI43`tMkdg`tQ7*
LHOZ>n!aMpu!xmI(

diff --git a/assets/icon/Icon.blend b/assets/icon/Icon.blend
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4a045e5a7944fa73c380495423c615e5419bc
GIT binary patch
literal 638756
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%0DaZ=PseqenBH$k`bx)
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
QAGqmi)jmEJM|b@DKYrimegFUf

literal 0
HcmV?d00001

diff --git a/assets/icon/Rendering Instructions.txt b/assets/icon/Rendering Instructions.txt
new file mode 100644
index 000000000..bf73392af
--- /dev/null
+++ b/assets/icon/Rendering Instructions.txt	
@@ -0,0 +1,26 @@
+
+/// -------------- *** -------------- ///
+///                                   ///
+///      Rendering Instructions       ///
+///                                   ///
+/// -------------- *** -------------- ///
+
+For those not well-versed in Blender, this document explains
+how to render the icon in any desired resolution and color.
+
+To Change Resolution:
+  1. Open Icon.blend in Blender.
+  2. In the right tool pane, look for "Resolution" under the
+     "Dimensions" settings. It should be defaulted to 512x512.
+     This is where you'll change the icon output dimensions.
+  3. After you've set the value to what you want, hit F12 or
+     select 'Render' > 'Render Image' from the top bar. This
+     will render the icon.
+  4. To save, hit F3 or select 'Image' > 'Save As Image' on
+     the left toward the middle of the screen.
+
+To Change Colors:
+  1. Open Icon.blend in Blender.
+  2. The icon's colors will appear in the bottom window as
+     labeled nodes. Change them by clicking on each node.
+  3. Render and save as described above.
\ No newline at end of file
diff --git a/assets/icon/icon.ico b/assets/icon/icon.ico
index d352654406f83035d8c4a0e9e87c5e746830b309..103a78ca86232fb78d3f99aad1658f497182f84c 100644
GIT binary patch
literal 153321
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

literal 273118
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

diff --git a/assets/icon/original/128x128.png b/assets/icon/original/128x128.png
new file mode 100644
index 0000000000000000000000000000000000000000..231718bb79a3b32bc3617adb79f3f792dbaa7f07
GIT binary patch
literal 3536
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

literal 0
HcmV?d00001

diff --git a/assets/icon/original/16x16.png b/assets/icon/original/16x16.png
new file mode 100644
index 0000000000000000000000000000000000000000..d28919c4bfd8a4aeed76dfd406562328a85b455b
GIT binary patch
literal 1396
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`k|nMYCBgY=CFO}lsSJ)O`AMk?
zp1FzXsX?iUDV2pMQ*9U+n3Xd_B1$5BeXNr6bM+EIYV;~{3xK*A7;Nk-3KEmEQ%e+*
zQqwc@Y?a>c-mj#PnPRIHZt82`Ti~3Uk?B!Ylp0*+7m{3+ootz+WN)WnQ(*-(AUCxn
zQK2F?C$HG5!d3}vt`(3C64qBz04piUwpD^SD#ABF!8yMuRl!uxR5#hc$WX!DQqR!T
z#M01EN5ROz&{*HlK;Otx*U-?)#N5izOaTg%fVLH-q*(>IxIyg#@@$ndN=gc>^!3Zj
z%k|2Q_413-^$jg8E%gnI^o@*kfhu&1EAvVcD|GXUm0>2hq!uR^WfqiV=I1GZOiWD5
zFD<cE0=g99h1>$Tv3bSNU;+l1ennz|zM-B0$V)JVzP|XC=H|jx7ncO3BHWAB;Np<V
zf>iyW)Z+ZoqGVvir744~DzI`cN=+=uFAB-e&w+(vKt_H^esM;Afr7KMf`)Hma%LWg
zuL;)R>ucqiS6q^qmz?V9Vygr+LN7Bj#mdmq*wM++$=Tcz7}kca#ul!oPR<6#&X#6I
zt`?SVW-z@j`N^fZsd*(Zy(tL2E;#jq(n4+l&}Ns^qRg_?6t|-MTm`V7tuk@D#Sy1@
zP`xR*-Qt8(uRhQ*`k<IaifNb-F!_L(@N^60z*Bx|9x%BV0n@ec?cQSy42;h`T^vIy
zZY>Eut=$qRV*h=%WPhtD_e7nW0^HnB|ElSTXfEl<(0LP>oS2@N_$kb(bCbid>=V}7
zn<o5ZRtr`Wd}?TXzx4dieZM8=-?S`!Z~J}TZ|nDmHyIl%Fco(AocWV*^lkDT*Xc9%
zWic)Dd+W63kb;}evh3dhmUqfSC(N;qeKYxTeZUemPQTeVn_XtJ+B*kLVY)u|X@PRs
zrU%8(zMGoAxoQ*jz4fKypTeD~PdTQ|?(TdaW81cK*`W?aNv@!l+n$F$g}TpFl)YiW
zs-0{QGd+FJRXy25kEd(>pU5O<zL9zT-q3oT*(>Y+vK*7*>hKp|m^5Pwv!wsoMY9hy
zAKEnYSeZUY&%=OoBD_l^q~{&F`)+G;(QO|y#)6!AjjrO6Ds1MVYu4<ny^*EMIJLN-
z<*3fdxOv=+inH^sOp<(%SleKFG)VERnP}_IT1}noge4Py)ts96-k9Z{{@3Hp<+0J{
z{v2H2@-_UKP=$hyy1padyKhDn;iUr81hoT8-aV~&B(<y7<Ok<@;kk>;>mIND`O5Lr
zere6bBKAkRToo>rUgCTTQ7U=6*G}Pi_*a+ZgG`X8p0wx1^v0ss?^iO#2Xyl$Pf74G
z*!7mXg=fQ&3GB}jH(AA+_}q~1ic|I3l4HhsEHUZ7?DKp^HilW}&%bWl;#&zS2R&W=
KT-G@yGywqTk@@!k

literal 0
HcmV?d00001

diff --git a/assets/icon/original/256x256.png b/assets/icon/original/256x256.png
new file mode 100644
index 0000000000000000000000000000000000000000..0c530d578d28a5fc7f32d519163e567d04777a58
GIT binary patch
literal 4429
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
a%wmZ1AK3#A(|6Di@UphDv*el|j{Yy20cq9%

literal 0
HcmV?d00001

diff --git a/assets/icon/original/32x32.png b/assets/icon/original/32x32.png
new file mode 100644
index 0000000000000000000000000000000000000000..9ae25c42ee0c62c7f2c2d43ef1635529274e7f22
GIT binary patch
literal 1065
zcmV+^1lIeBP)<h;3K|Lk000e1NJLTq001BW001Be1^@s6b9#F800001b5ch_0Itp)
z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02p*dSaefwW^{L9
za%BK;VQFr3E^cLXAT%y8E;Eegmrwuz1DZ)hK~z{rtyWu0RY4T??{uRmf{-98goqxx
z(2YncD(WS=5YdHRq9ll3>LCaU2|_D~FoOgO%+%C6Y9^(orN?vBJm#gew`smTYt3GJ
z&g^}T)Pj$hJ+s!gzL{Aw=aeX=3PRfQrAt&2$gOyD6U3P>SrRC$uoV*EBY*mRTGb5A
zsM_Hf^;`pejQM<tCf<?+NTNrBQ|g&cf}}k5Dl;3j^%*l(J3Jfs@H~U){1zub5<K|&
zGgxKah)D=EkNxuYU#4f&<8M<z437asn{Pe=GSCH*y`Pv1`dvBGrY3%?_8)T*AwCd&
z)La2>&=b9y7h>Cs1!55Ej#HY@qyToh*8Rf<#1&T(8b-}d$k?lblhPSu0Xzv*kaM*z
zJhb(?*iy9Z3jyke`^?D*lEPd8m%GLzj<{yr@0<P;ne(A{YCdTBhT!(_oa7FY!XSVL
zPp8JL1EY3$TD{KBs?OZJB~L<c0g*BXNeEYe>O;N&-o_59_=TWmD6D~s?unq4IU>n{
zlVb92@1%M-U>+aoQw&gqbtC3=1P8b<ez9|0op2Uu1srS}jZFLt`1~1nzU0)EkKy?r
zYRlTb6>y+690YEE&e?w4E}$mj3RA{NE}*<MT&xwa?_E|MX&()a;ey^O9<S^-+vft;
z5-%YTS09!A<~hFEV+8Q|BNzKv0oz(Kc93h~Mvo~R3H~v{+u+XmUQEe>1)`O?tbi@e
z8MUh=YmWj2!*h(Pf#?s6d?OgH58!ek7x%4zvZfI`h$1=bya^~I`3+PLnq*bF(%m_U
zGpVS6vbSL_D*)IeM7Y2?qL?5A*Xmy1q`I%`11;wHssYzO<sTiNyPG5O7OWS_B+hr3
z6-eS+qOxV5ePkg^Y?P~KlMbbgX|;iz_KIrd!aPS}E{O!P?;ag<fU~sGvwAijT=6Cy
zh(Ld<C>G#2RWZO<%J=&L?5AR84sfp0+&oWdL*ofxrFL8=wrab$HVj;;qZ-FF&_ApT
z7q4l#PK?`x7*soo8(dhJjHk5zKP13v3gEiHN_J?{-5PuJwsKL)M+MmF5sL-MZ%SuO
z3V=yRhCI8?P0<AMnB?4A9kYgxQi9Ti<_dtZ^WuiITIQ&CSK~{<K&*@>`l$H?z+58v
z?E*sGZ+DDn^DRyQOcL;FTw*DXedIhqbbd<`0CULzJ{n+=?gPHW0MW!-ApvYY@+45$
j|2JPU334maN=p6$$m(dI;4(@800000NkvXXu0mjf@VMV%

literal 0
HcmV?d00001

diff --git a/assets/icon/original/36x36.png b/assets/icon/original/36x36.png
new file mode 100644
index 0000000000000000000000000000000000000000..18f0ee0e88373fccd811540cd35d0a4925ce3e1d
GIT binary patch
literal 2767
zcmbVOdpK0<8ea@kX{dG*jx-J1CFVYZH5nOZ#Lmby%BAMAm`QUnGmLA^u1K;a5~(P)
zaooC45l%Q!F6Fkn?@}bUjY0~QGb;O>KlZc#IO}=V`o8!3-rsxqz3=-x>xjGC7EKL(
z4FCW%U7YEj%GG$`T?$uzUjbQJ%0*Ac@RNCof@N}+1OjMW5gS6f2v{MIC&c1Lg*8LA
z005Knz5Qf<Ojim=B*3s1bTE+uu@VgcwwoixEKVpSL$aX|zL1I<ufBys^0`!$FPVvB
ziX9;y-#J<Wc}2T<bD~2zAQ!dS4rv=nQ5q0HG8QsYuvaLhL{d>-?NXHcg<~uV`Bg<0
zN=1DO%8%)ebQDP-BpE|Sb8rMa(i+6z$s`buw?q<fcp?^$!xBI=9#0`zQ}9;E?+;4p
zO~MVPc+#D|`%+3&6i+4-Q?OXMT#k_wF(OF_77v0T7DvDm2xz4SS{fyku_DnzsnMbZ
zIwa*t_+lAfBt$M)WU)ozGAc?L>9-UFVkYxX!$RqIqLh?jBUxfB9)rUQ1Pgh6)t1UU
zq5p>Qm)cVAC^3ZfgruTy2}fCvV53E_lDofmw4kVrhO$k<R~Ch}moDOj3m~D)g-%5&
zZ!lawmtuqCT9YACFq&Y)1<@ocvJDy}*eJOLNi1t?64?qOf{S+k3XcbgGzXdkXbmb$
zfM*bG7-R=W9MKW9A~0+~C#yxQi%=?K2|3WBZ@$v^cdX6dVkwRih$RzAyhWnDi(TN(
z6UjtUo=A*zbVQmlSscD_K{j8g(YKW8kc1xrah)V00rD%!6#icXz_q~<NdyuLO$a7)
z(Im1Bga(7H*=RBs#|macL=MPNCjSl3{eQ{BDuco<bjts9&f<}>9T&EL&Vf?+bCMvT
za(pDpIT@H3Jpcgk2^TueJMw9pU+7+KA8otxY8mTCe0G*@A9nSAUA&!Y#>BAn*~H3K
zgAQvh+o~neV8(P6$3(>}?1)*#?x>}_R<9Rvw|HA!XdJd{vQys*j;kv!VQjj7EM=ft
zI^K5n2^#(JPP%KzoBLG*u^(z~G)eoKI^)v7HhJH^L-4l)@7n)yyH!_b)x-?1B-d<^
z$V;wqnw#l;Uo_JlfV>_wmZxB?EMF=!nLjd_D<GOy1D9-`3lYZ5;jM4uW70l?<~f{C
z21NA3o*uIbKy%9-BhcjYlA`Qf^mO|rA=!z09?=Xh=6;Mk-g6LM;vl<8dZZrQ-RM@o
z_GReglnZ;bFG09-R~DmMzpOK%p}FG1_0zr0#`POF?aF44$CpGsK*QBcm<M}1niG;u
zsS2m&Ob-N#2b`l_J30|yZ*^w;a^Tw6b4_`cSAsfY&$djOCJm(an2wz;2<hAs{^)TA
zV%F32eR*+2t*uY&Ca*osn(ITYb|>0Qs@3Q?82HIYs=~tdB^^Cs&j8Zufs+H=uFh%0
zooQ#y0pDxW9qX>AsDj$GE%!Tvjq0W+LQ_boP`lxtG*eRH-1}InZsXG&-+WE;%KS-q
zJqEtsxW2wh+;V6`)T4dRHyk*{X$fkjba9cDv>x<wf1L@vd{QPX{9UtEOrMU`rr)o)
zG$p&qVdr=uqvRxf>S%fX<EzIQ66dHp9hSyt#zK&ll#Agga_Kbu-B~%%R=|Az;S4J#
zyX<J~KBfgX^Rm`T*{nKTb7iCmgT{6HRLH?%ci)IGlT!5EynhR*MsV1R8yY5Qh6U&P
z4K(b2S#dKiLCbm0X0BL=as}smd&MBk?b+xx=ManHlaiIW!#6?8taJnamp;&|TD^37
zGqCQpyFzPlA`SS>Yx~QVqIlDtj88RjWk!M(W~Xd(FuUf1opEbt{OL#0zZI^FHLEp=
z>feY+_yg+waomr1&GLSxUc{PG2ix(&(LDD$Q`H#KF3#gu$5{tvjQ#Nqb%%`tP2YYD
zc;5Bfrh>@>MK>{L7{wDo+9StTadqkp`10P-&lZ7Y<IDFv^^_Gg@bW`@0s@BamHQ5<
zTzB;xn@uh+vD_rRP16kG?$}%qOA>Z9Ek7H(%@ezPKF|1c@V+MwH&$cl`Gt<{>#u8Y
zo~6ZVrn<xo1XpV#OvY=kG*t}>EG5H_hKZx9h!3QSRad4PUO9!$NAMqO>`Bi!ZTRfn
z&wseW1brTy+O`Ur9@+a1YsK`i1lrd95E1rdN5q|qvSnMc6X%xS+wH|J^T>#PUR7N2
zAUmw<p+2eIE+XELSXOo9Ls`0Bu|Jp@ZZ0yuNK->1oGXPV)-1iz=vQxEw)z|+;ElZ9
zWfXGebd=T~;+0f-$Bv%pkv*k`6s3lfdJoYq{lWU_)=x2B%;XJa`5ST{yiQHY(!t(3
znTh&zcKN!gS9=TQE{KKira<g5l-gC_{H|k1Jp6cy&R4U1hM$6#dfp0Q;<bdK_N%W4
zDJK<48703}Jlgu1{{!sc@AjVMsk3hfe~zA&LdPQw+fUu0Ce*C4J-9V9dt)aK-+GQ&
z->d88zH$0~ctAjO-Y-RKUst}iw{l8ZfAVl3#Ru_ZO{_ifuEKOAf4%5@wt5u`o@c<x
zn7kU#w%y-=hvRtJ8VH2~fV=cwP2~UVvFum*>fB6^nW;I56_?oH9D3_c1zU${EC7~3
z+wYeO!&Ryp@G!k3<lGh5_TQ(Xw8m7m{R3Ukw@|+DdvVn8%g1lF8az60d1gO3GbzQt
zB^qL>D0ci%_oOSJtxYu%bys1z>7=f6;nko)SCtcmh2_t6i0EKOTuz<SjynFxuZ?+K
zJMXq^)mJzbu)2tc^}V?7Tj^J8%i9}LXRAwUvSuxYZ}%OX8yT{8V|1+c(VQAda+s@#
zMmKX6Vj~TUjr$Ii%;>*UsquJ2)1^mg66SaK7;9+-MtG4ccCBmq>B|IL1vJ;o7%^mT
z0AS};@LfCqfqx8JsyfAwIIQ8_kshna?N<rF96$V^e$Y_T*zwYC0Jgb%UDc4tZq=t>
z8q|+|Zb%YJE$8n7+KGj4wA3u?Y#Yoq^;=`M`0lh9``vY0Vxpe<WzLMl#D6MMuko@t
z_wraq{M6eo(WcKx_8;Lnx43ab{k0z5pc!}M-u6Iq#pObO^U5X)GcWHx6k(<q5|v8q
zUrb*VU5Wti>0@x0-Rg+zkFI)H?C!U<DIJ4Q91Kl5d?v1@z&Es|w=DZcyXuAZkeAB}
zhdM?G{r>97<GnZ1RgY0~x;+z;!Osf4{>C7SWmO5Mf<#I2b+4_*gy_#xNxqGW!La_J
z(m~DL;~hHQI{GO{=bIz{`m*g}Z`WqkpuYKOZ0&w^U0}@<>4ohd|M_C!7t@8|MlW;N
Gec(Sn6q_ml

literal 0
HcmV?d00001

diff --git a/assets/icon/original/37x37.png b/assets/icon/original/37x37.png
new file mode 100644
index 0000000000000000000000000000000000000000..86e0c33f1a0d9abcb0b4195507a5080f03acbdcc
GIT binary patch
literal 2776
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
RqL%KO&JJ#j3cJAg{{X~5q;~)S

literal 0
HcmV?d00001

diff --git a/assets/icon/original/48x48.png b/assets/icon/original/48x48.png
new file mode 100644
index 0000000000000000000000000000000000000000..a2307c3558a6c0bc89cedf8293eac2b44772d750
GIT binary patch
literal 2923
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
B+i3s*

literal 0
HcmV?d00001

diff --git a/assets/icon/original/512x512.png b/assets/icon/original/512x512.png
new file mode 100644
index 0000000000000000000000000000000000000000..647425b3832d1b2416f006f8bd86b2ee2dc1aee4
GIT binary patch
literal 5797
zcmbVOcR*9;-j2m;)mnNjh#IZ=u$Br!SP3K$K_Mt0VA(Q-BoKroNJ0WchV4bG6lhhT
zYy~F>C@X|1DDu%5rbZx3iV#NFgpm-r2S=4#_0#YCbIy6kZ@tg+yuY(YY!7Z+zimAT
z1lnkM$lM+T`V9E|4D`hs;58HWND92RQqZmx2a+F!<`aSg?Z=XQaS%&_k3Y^H=YtJD
z(Tp<&ffUFAj;<6}o5M&9iJ;}PyhbaG5De@Ffs9SUf_*T7I10oU=N~{ssg76GsX_v<
zC{-7jjkZm&84e$CC?W*s5Mk?xi3r3Xu&O5eAjV-xzyJY9@qvU9f{0{f7)tepT_o_m
zJPcKZyjVgBM5(?E%GKrw#EcYzgTS<4niy?e9f$!!O9!Tp(9zio(bd+`gX(BQbrG66
zI!Jv3qz)YN>QM!}g<$=V_U0C^d;xzbRXl|fjD$jIG@2GoPm2`d57j{+5KwJhsIIOi
zutJj@PNevRX%fl1URyB7kuf0w!IS_J5wdL2$CngJL8$_fzD$7-Y-97cVIuiep@5P>
z!+e6FI$GLL0%19?7put>d)%8a-np9W7#@s++T+Ni&=3r89)7!CZw6}jVMoggfoPC+
zApyXl_yn1gFrfq-kz#3%QUzwTumM=4p*Ge4hST@c)HTE+H1**yLrsLPAy8X{zK?-{
zJ`9f2L%g>0uKoLU;N}(v+6V)Lp_z^jTF(#-J7A`*XNG|5q74xi@Yj1SiDZfo5rcc}
zI{@(gYOmo3_ae<ga6S}Lh$D#<^cn?6@FWU}j3)&{%*-G^*!W-qh|B+bme1&A%I3I`
z04fe^5kewBUKAM_@QwhmhT3}iy81qvx_&UMrasINr-|@0@YRH2wSD}2ae5d821x$p
ze(e9Zcu*iH=rU5?LeA?U0FKL_fAawN`I|{NB0!%IfG08ja)7*>{@2oczhhXBm>>8H
zKQyXo5|Mi1QP+Wh%SSe6m$t2iIsRgS8B4YNUcw3GPi~@p)3-ZqHRA?l&v5x6cV(*+
zw079hgXuxV+n{~${2!m_T(I=r^bKb3UhADoRy%)DTCW)kOZ6DYa9~*Pe5Bkno!U$q
zh;A8?EV33_m#6|n_(XvxQgmMHQvQ$<<zkwH>Gkw}B~T1N{na241bD3ifxZBNOo1;z
zUA_kW*VJL#M2EWwKi0Qntc-%#`On|6<g>eb{%OS&t>n3eGTBx&DUPkT`n9{HxOSmz
zOuVHvJ85*Z;`RjZbACaq=hs=R%k_-}IS3^k=;iFJbffYcSUX4;0{%^A2eVtuwdV)R
zHuOlJyP2GXq#5z?a*u>3B^wL`heX9>T`!Uns^vm`Q)bXW)wO+Ib;T%!m{gx8wl!h!
z=k;5*dDx4O)&z+5rLQ&mbqPrA!+E|b!5>$0xFEXPoj~=YWnA!pja^uV=uDs&^ozvl
z$B$V()O_JC(sp%f_Tn5&QS@!CG|yM`jJxY#4s-3A0hJo6T|)IvHp;L~dR*8fY-wpW
z-{roCj`Y|g>ym8nU(`#fwOd0=Kr7lwr;h8F_=l>>$JQlKa@w8NMXdtGeD&S?PvT94
zhS$$&DIiI@CG|O()Az3KtLe4RX4KYJ6H=xZhY}Sn$SRcU8_pNQQ6`Jkq(XIuwm)mI
z9Zxh{N^0k|2^4dfl1LYGa!D0SUiDXRe#ywJfl2e`&FuBUjl!NxO$O4b)oV|*tRLN2
zSU)jbJYI8Z2R%3LH?7?CFABrkq0V(Hpt9=e2hntQW>0154K>~s39CCK+o1Sb(GX`|
zXhl>>|7z%Tt>D-+Ka(|p&Mw0&-N6&t9pUI!T;-~%g*%+3+LCySnWIB~=xg56D6d)+
zSGCI_P~KM=_}DPz<7))~`tGB=HuznRe-p<UlP{F^Dzx*&!TpbDb;VtoONiZ!do?E~
z?pZyOPF(J5_ozulQ5kzHdGUtv&!3G0wd|7w?dofLdOj!GTN-)$7#Gii_DmBLR(~9Q
z0Nf3JiDs;7$%Cn#xTF_d)6wHHdyssU;VWMlGt+E+IM(7ec{#sm>SCnrPywwf@uU*l
z(;&Jq4#v(3lgaU8*xQ%KiwfOc&(8JFrl%y!&wmMT=LCJKd#aspuJ9CBmUcB^Iyq$)
z4FurW_~d_Fosx(WdPM8*__12$X;h}eedoHNxkp*K?K}f#kFD%wR&I^9?U?Il_sSNM
z+*6cgW2ubL(oHgu9LQ|Pq5oEkHyB+ZBr!LgDB!2i<hID$g>{HdJF5a!mGNGKuh8T~
zuc}M^scHxRBucpD<F5J)Vz;p!Omx_3jFr{%FglKp0*Ei8<mmJ*m1AgFA=!nfQH5@U
zf<SGj0R4K8zqhz9a_q*L#x7Mr>kK!uYbYbdcw%G)&lewTsXsR_*^tX@5=7PYr><SQ
z%-x}>i@jz|xy<_5lyETRHy6dIEo^@2;8af2!f5ciCkpk`(nA#<;yV+l8IO5^hCFhj
zkDDxemnOa^uox&jl@P;rUYk%jQgq+)sC=pxuf-pxEfxOU&Z7}smDrDa=1<!)q&1<>
za`9tn3*;K~wf3=zN>7*HM`lecVy7pM^@;Aect7UMSt$$X*^vj~*3ZK~l@7}n0;T-u
zl&Op+CWQM@Y`ohqFr(&c@I-v@iT1vei=+3Jq1o(qf=Ywa_8ZcCXjEIG8->Z(zcyUb
zHYwh>j$vc(=`=q!RJ`%)w=RwMr2XnVjz!Ek_M4`&*KfzTlxz|ew+BU@cqG>lsh}S0
z6q{@YN{!FDp0*?dtV^%X^^aP!1S!#S=Mk_;T`2n}D~~F7@1C8@huBdrADi3&dh7aH
z0k^k~|K*i-SAU@qe%DHj%xl=sx%YGR_`z{BSw(`CbAG504Abce<^UnC*E6f3**#?a
zG$SXHIa%#{x9A5;Vu@L=Kdxy$V7`Gz?L3bkt5kWA!_0odozv*}cn|_n{NaY$Z4xxb
zX%C|Y5rn^*q)LKWf=&ai04`X3_?{V@FF;QHs83@rGHnG)sd()8X;NY3@drx;u(#3I
z?5pnbH8ekW`Dqs@lxnNRtyIfGMK!Hosl+Sp^A!b&Ij3Iv<&CXctefY~PPDq4WN3D7
z*|wKqJ_r>WZ)c;lwS^9Fv=?gLM?XbNvUMNDI1TI(mKp~`x9*qn<c(z;{1)j@r;wX=
zQMShctbM%ntp=noEAu|*hDLdOxiPu@R?x0a@mLU1l}9zyuP7ZvM+ZNlYqnnGX>rEN
zM~ybKGxJhBtKj?Ee;J6nZ6cEqy^*bK9ds-I=c=#Dji;Y&jLT_7cHVfv6mx40(zsRS
zMg6G}Xt+=ca1i<1|JlsEf~P~iE*E6t`egjL&F`J@X&1E7Sv};^{?y5c@_hwW&a;&T
z>lo97t*C8m)Q$|6%-Lh;`^6j@A(scQ)MJaIYI_^+0K$wiYWW?;%4IU$=T<l2!H~Dm
z_`YTe@DH4e>A@eWHr~$P20oum5`x+B1)~}f8G&BiJK2%r571+at>KHKbGb~?YVKgx
zcEqMg&d&<n16AYI>5&3}EC<P8DT^>jSFI*0dPX|A3tR2@6%}1FEYSF9oUkqIf^TE*
zPRB>jF=@*h{b5GF3KT$2+q&Z^EzB!j=W655Ol`C*2`uCIH&id2F#<XTxlys^Pbw{W
zXmV9uId8`zLa`=FJB|KVqW|;L_nR8nw8YYd0i(I*naZ(Po$;bQi-oc<xz)#lbD6D<
zXuD=bBmP4b#bn-Zlx_~Hoi~_Pizh;Os$DJcS}G(hP(&c8eLtLJ*mB0pM9HfvwlP7c
z#;!vaGVPL5IvN?C*BdF(5QfJ4?M~?Ycw&kiM>`NHj=q8Q<HklEQxEF|dPioqhzL94
z2NL-0!g7PI;gmTvxu)!v4gKDg(VI9jzsybhn|-&+=5-RUrS(n~jz{56=+lIWg23>B
zA+U<eUx<p)etA1Dj<J`(rI|@<w=1fQE{Y442{L}4%G=!?<b!aH3FzodDqKG@tX_$p
zpnOi<oJE9lXDyfmXE5!&7WZUjREv6$XBB<kRDX{5^t=^MV@T){QsO-%`!2I;Hdf4}
zPY1HNvyrJpiFIbdgFuw@+c`inDG;FAFGVp1@V`PbOo4$nQ`emBoW3f3cC9Avj39m>
zDnfM5DueYo*TOw3d}M^BG0Dih)w=lDQ*AgN7^h&onhRpR`Ale9{-4xZidOgo#i9{t
zMD*2h78I3UlWoHE$LSjg9=LmbYU2Rhmum1^$HND5G{?=eLyLcmAGM2~Sj@r~&TxwE
zPmR)ZnVt;IxPj+`XS$Oa*{j_*nPmPzkLFMK&N8lorwbJg25SBlR7)p>Qft;yv2!k!
znMI|~w%Q5Rmcm@RHE&#R7(J;%*t)KczGm@b`2vvmu1fkt_+7Vrg?RQjh22w;*QH*1
zVN%Tr1AZEYF5mq90}jw-Z77eoAU8YLJvtlFJyJeWE+&mEhx6m9`0!nUQuWF0i@ib|
zSQ-`KKLVEKP3^M;)UxnyHf<o4cDyFtSy^TbkjQlHCeX)e%dz8<(&?Q~cz+O_kYx**
zK-U5m?mRp294G(Nw`rc<S_5Xwr}-LjS*&{_Qvb!sg@B6C(LaMbeTK0WWfSKn4AbkA
z84)AameB|m;zc7c@uIbgY1S9xNpWY~qP^_?E&47pS}v+l=#Jc)#hQ^_8dM1>5Q`Q*
zT6>>nsMmgZ<IX}Ro?m|}J|AdC?|6j;+;6rh85GI=ZddQ}9KNu3ck09VZchyv<k9hh
z=wp>wkw2~AhluQl;Zb(G6Z9r!y&?J0>ealw^_3f-cKHqV*)#MOfbj1_^FI)--06^{
zfRY^^;U=|kOY@G-Zz-v7;1)dZ6P!x+*Xq#)^tNdv{|;)@y48={yN~IQ=GJbvRT9`A
zovH+`;V4<R7%|VFugPJ0D`r=nE#wsO=TD1K7m0Q@!j$ZqCvgIdQ@2?3NmM@qfSj+~
z)pU_~6Zs9XaaglLdF1}-Q&v2+q1jTqvF7r7a?YIlQgw74L(DvE(B<R<J{H06kbTD=
zPLYPs^I&ksb6d+Lm}^o&)XlREiTjJZ0WJeff0z3IV=OP1I+S63F4DF5@^JKb;M9)K
ze-aVg9^Yzcv}OeFPFMCPcs%AP9-xJhINbSakBZ$!YJK1ynb*yqnyUl368=OtVo$jP
zRTsS4niwwmM3KRjuX4`026x899cvCuAvUTr|CP_b`b3LAl}x;8Tohjv9${-gdQz*^
z_yR#PvW~Wjv!U*BYsreP6Y_Sl{{X@z<T;{3#zTu+V`*^`4T+!Z=|xL}sIqBJS%>@T
z{NU`ve;p-=WLKPH{mZU2pY%?uc3IYe%=yGa*FPwbFOd~PzB#CSDQ|CBz+9u*Xtnu`
zQf$4`kSs7q)urnCW<HD9aFcH0&V(yuF$Ffst5&_Guq&XsqF;M)C0Zmpw1uB9@E)S(
z3vA$u2ZqIZ{qUJkBmR!-gUDmZ^Pm{Z>fFrFT9lUn0>07h6;@4w%DkDnmQ0Ar2y{B?
n=Ns_5Y||&H-I6eRoi=E6Ab(i@^x^@)D##LTYhHNZ*iZifB^;L`

literal 0
HcmV?d00001

diff --git a/assets/icon/original/64x64.png b/assets/icon/original/64x64.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f662265e976e33a6f8f98f1a3bcd9f08a8e656e
GIT binary patch
literal 3131
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
LHOZ>n!aMpu!xmI(

literal 0
HcmV?d00001

diff --git a/assets/icon/Icon.psd b/assets/icon/original/Icon.psd
similarity index 100%
rename from assets/icon/Icon.psd
rename to assets/icon/original/Icon.psd
diff --git a/assets/icon/Icon_Complex.psd b/assets/icon/original/Icon_Complex.psd
similarity index 100%
rename from assets/icon/Icon_Complex.psd
rename to assets/icon/original/Icon_Complex.psd
diff --git a/assets/icon/original/icon.ico b/assets/icon/original/icon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..d352654406f83035d8c4a0e9e87c5e746830b309
GIT binary patch
literal 273118
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

literal 0
HcmV?d00001


From c083ef8e89654e05e71d9de9c6bd68dbd5539807 Mon Sep 17 00:00:00 2001
From: Christopher Cruzen <christopher.a.cruzen@gmail.com>
Date: Wed, 2 May 2018 22:35:26 -0500
Subject: [PATCH 34/56] Restore Original Icon Credit

---
 .../{original => original icon by KMA}/128x128.png  | Bin
 .../{original => original icon by KMA}/16x16.png    | Bin
 .../{original => original icon by KMA}/256x256.png  | Bin
 .../{original => original icon by KMA}/32x32.png    | Bin
 .../{original => original icon by KMA}/36x36.png    | Bin
 .../{original => original icon by KMA}/37x37.png    | Bin
 .../{original => original icon by KMA}/48x48.png    | Bin
 .../{original => original icon by KMA}/512x512.png  | Bin
 .../{original => original icon by KMA}/64x64.png    | Bin
 .../{original => original icon by KMA}/Icon.psd     | Bin
 .../Icon_Complex.psd                                | Bin
 .../{original => original icon by KMA}/icon.ico     | Bin
 12 files changed, 0 insertions(+), 0 deletions(-)
 rename assets/icon/{original => original icon by KMA}/128x128.png (100%)
 rename assets/icon/{original => original icon by KMA}/16x16.png (100%)
 rename assets/icon/{original => original icon by KMA}/256x256.png (100%)
 rename assets/icon/{original => original icon by KMA}/32x32.png (100%)
 rename assets/icon/{original => original icon by KMA}/36x36.png (100%)
 rename assets/icon/{original => original icon by KMA}/37x37.png (100%)
 rename assets/icon/{original => original icon by KMA}/48x48.png (100%)
 rename assets/icon/{original => original icon by KMA}/512x512.png (100%)
 rename assets/icon/{original => original icon by KMA}/64x64.png (100%)
 rename assets/icon/{original => original icon by KMA}/Icon.psd (100%)
 rename assets/icon/{original => original icon by KMA}/Icon_Complex.psd (100%)
 rename assets/icon/{original => original icon by KMA}/icon.ico (100%)

diff --git a/assets/icon/original/128x128.png b/assets/icon/original icon by KMA/128x128.png
similarity index 100%
rename from assets/icon/original/128x128.png
rename to assets/icon/original icon by KMA/128x128.png
diff --git a/assets/icon/original/16x16.png b/assets/icon/original icon by KMA/16x16.png
similarity index 100%
rename from assets/icon/original/16x16.png
rename to assets/icon/original icon by KMA/16x16.png
diff --git a/assets/icon/original/256x256.png b/assets/icon/original icon by KMA/256x256.png
similarity index 100%
rename from assets/icon/original/256x256.png
rename to assets/icon/original icon by KMA/256x256.png
diff --git a/assets/icon/original/32x32.png b/assets/icon/original icon by KMA/32x32.png
similarity index 100%
rename from assets/icon/original/32x32.png
rename to assets/icon/original icon by KMA/32x32.png
diff --git a/assets/icon/original/36x36.png b/assets/icon/original icon by KMA/36x36.png
similarity index 100%
rename from assets/icon/original/36x36.png
rename to assets/icon/original icon by KMA/36x36.png
diff --git a/assets/icon/original/37x37.png b/assets/icon/original icon by KMA/37x37.png
similarity index 100%
rename from assets/icon/original/37x37.png
rename to assets/icon/original icon by KMA/37x37.png
diff --git a/assets/icon/original/48x48.png b/assets/icon/original icon by KMA/48x48.png
similarity index 100%
rename from assets/icon/original/48x48.png
rename to assets/icon/original icon by KMA/48x48.png
diff --git a/assets/icon/original/512x512.png b/assets/icon/original icon by KMA/512x512.png
similarity index 100%
rename from assets/icon/original/512x512.png
rename to assets/icon/original icon by KMA/512x512.png
diff --git a/assets/icon/original/64x64.png b/assets/icon/original icon by KMA/64x64.png
similarity index 100%
rename from assets/icon/original/64x64.png
rename to assets/icon/original icon by KMA/64x64.png
diff --git a/assets/icon/original/Icon.psd b/assets/icon/original icon by KMA/Icon.psd
similarity index 100%
rename from assets/icon/original/Icon.psd
rename to assets/icon/original icon by KMA/Icon.psd
diff --git a/assets/icon/original/Icon_Complex.psd b/assets/icon/original icon by KMA/Icon_Complex.psd
similarity index 100%
rename from assets/icon/original/Icon_Complex.psd
rename to assets/icon/original icon by KMA/Icon_Complex.psd
diff --git a/assets/icon/original/icon.ico b/assets/icon/original icon by KMA/icon.ico
similarity index 100%
rename from assets/icon/original/icon.ico
rename to assets/icon/original icon by KMA/icon.ico

From 1f157f35f4d1e9f1b1b17503dc34ce7aeeaa2b43 Mon Sep 17 00:00:00 2001
From: DrChat <arkolbed@gmail.com>
Date: Thu, 3 May 2018 10:02:07 -0500
Subject: [PATCH 35/56] [Vulkan] Initial support for mipmaps

---
 src/xenia/gpu/sampler_info.cc         |   2 +
 src/xenia/gpu/sampler_info.h          |   6 +-
 src/xenia/gpu/texture_info.cc         | 230 +++++++++++++--
 src/xenia/gpu/texture_info.h          |  18 +-
 src/xenia/gpu/vulkan/texture_cache.cc | 408 +++++++++++---------------
 src/xenia/gpu/vulkan/texture_cache.h  |   9 +-
 6 files changed, 401 insertions(+), 272 deletions(-)

diff --git a/src/xenia/gpu/sampler_info.cc b/src/xenia/gpu/sampler_info.cc
index 0adefbd1b..c6fcf0985 100644
--- a/src/xenia/gpu/sampler_info.cc
+++ b/src/xenia/gpu/sampler_info.cc
@@ -44,6 +44,8 @@ bool SamplerInfo::Prepare(const xenos::xe_gpu_texture_fetch_t& fetch,
 
   out_info->border_color = static_cast<BorderColor>(fetch.border_color);
   out_info->lod_bias = (fetch.lod_bias) / 32.f;
+  out_info->mip_min_level = fetch.mip_min_level;
+  out_info->mip_max_level = fetch.mip_max_level;
 
   return true;
 }
diff --git a/src/xenia/gpu/sampler_info.h b/src/xenia/gpu/sampler_info.h
index 57e3ceeac..415c28bd2 100644
--- a/src/xenia/gpu/sampler_info.h
+++ b/src/xenia/gpu/sampler_info.h
@@ -26,6 +26,8 @@ struct SamplerInfo {
   AnisoFilter aniso_filter;
   BorderColor border_color;
   float lod_bias;
+  uint32_t mip_min_level;
+  uint32_t mip_max_level;
 
   static bool Prepare(const xenos::xe_gpu_texture_fetch_t& fetch,
                       const ParsedTextureFetchInstruction& fetch_instr,
@@ -36,7 +38,9 @@ struct SamplerInfo {
     return min_filter == other.min_filter && mag_filter == other.mag_filter &&
            mip_filter == other.mip_filter && clamp_u == other.clamp_u &&
            clamp_v == other.clamp_v && clamp_w == other.clamp_w &&
-           aniso_filter == other.aniso_filter;
+           aniso_filter == other.aniso_filter && lod_bias == other.lod_bias &&
+           mip_min_level == other.mip_min_level &&
+           mip_max_level == other.mip_max_level;
   }
 };
 
diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 655249304..36883f8a4 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -15,6 +15,7 @@
 
 #include "xenia/base/logging.h"
 #include "xenia/base/math.h"
+#include "xenia/base/memory.h"
 
 #include "third_party/xxhash/xxhash.h"
 
@@ -59,6 +60,8 @@ bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch,
   info.endianness = static_cast<Endian>(fetch.endianness);
   info.is_tiled = fetch.tiled;
   info.has_packed_mips = fetch.packed_mips;
+  info.mip_address = fetch.mip_address << 12;
+  info.mip_levels = fetch.packed_mips ? fetch.mip_max_level + 1 : 1;
   info.input_length = 0;  // Populated below.
 
   if (info.format_info()->format == TextureFormat::kUnknown) {
@@ -78,6 +81,7 @@ bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch,
     } break;
     case Dimension::k3D: {
       // TODO(benvanik): calculate size.
+      assert_always();
       return false;
     }
     case Dimension::kCube: {
@@ -106,6 +110,8 @@ bool TextureInfo::PrepareResolve(uint32_t physical_address,
   info.endianness = endian;
   info.is_tiled = true;
   info.has_packed_mips = false;
+  info.mip_address = 0;
+  info.mip_levels = 1;
   info.input_length = 0;
 
   if (info.format_info()->format == TextureFormat::kUnknown) {
@@ -121,10 +127,6 @@ void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) {
   size_2d.logical_width = width;
   size_2d.logical_height = height;
 
-  // Here be dragons. The values here are used in texture_cache.cc to copy
-  // images and create GL textures. Changes here will impact that code.
-  // TODO(benvanik): generic texture copying utility.
-
   auto format = format_info();
 
   // w/h in blocks.
@@ -135,11 +137,15 @@ void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) {
       xe::round_up(size_2d.logical_height, format->block_height) /
       format->block_height;
 
-  // Tiles are 32x32 blocks. The pitch of all textures must a multiple of tile
-  // dimensions.
-  uint32_t tile_width = xe::round_up(block_width, 32) / 32;
-  size_2d.block_width = tile_width * 32;
-  size_2d.block_height = block_height;
+  if (is_tiled) {
+    // If the texture is tiled, its dimensions must be a multiple of tile
+    // dimensions (32x32 blocks).
+    size_2d.block_width = xe::round_up(block_width, 32);
+    size_2d.block_height = xe::round_up(block_height, 32);
+  } else {
+    size_2d.block_width = block_width;
+    size_2d.block_height = block_height;
+  }
 
   uint32_t bytes_per_block =
       format->block_width * format->block_height * format->bits_per_pixel / 8;
@@ -177,11 +183,15 @@ void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height,
       xe::round_up(size_cube.logical_height, format->block_height) /
       format->block_height;
 
-  // Tiles are 32x32 blocks. All textures must be multiples of tile dimensions.
-  uint32_t tile_width = xe::round_up(block_width, 32) / 32;
-  uint32_t tile_height = xe::round_up(block_height, 32) / 32;
-  size_cube.block_width = tile_width * 32;
-  size_cube.block_height = tile_height * 32;
+  if (is_tiled) {
+    // If the texture is tiled, its dimensions must be a multiple of tile
+    // dimensions (32x32 blocks).
+    size_cube.block_width = xe::round_up(block_width, 32);
+    size_cube.block_height = xe::round_up(block_height, 32);
+  } else {
+    size_cube.block_width = block_width;
+    size_cube.block_height = block_height;
+  }
 
   uint32_t bytes_per_block =
       format->block_width * format->block_height * format->bits_per_pixel / 8;
@@ -204,12 +214,154 @@ void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height,
   input_length = size_cube.input_face_length * 6;
 }
 
+static void TextureSwap(Endian endianness, void* dest, const void* src,
+                        size_t length) {
+  switch (endianness) {
+    case Endian::k8in16:
+      xe::copy_and_swap_16_unaligned(dest, src, length / 2);
+      break;
+    case Endian::k8in32:
+      xe::copy_and_swap_32_unaligned(dest, src, length / 4);
+      break;
+    case Endian::k16in32:  // Swap high and low 16 bits within a 32 bit word
+      xe::copy_and_swap_16_in_32_unaligned(dest, src, length);
+      break;
+    default:
+    case Endian::kUnspecified:
+      std::memcpy(dest, src, length);
+      break;
+  }
+}
+
+static void ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch,
+                             const uint8_t* src, Endian src_endianness) {
+  // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
+  union {
+    uint8_t data[8];
+    struct {
+      uint8_t r0, g0, r1, g1;
+      uint32_t xx;
+    };
+  } block;
+  static_assert(sizeof(block) == 8, "CTX1 block mismatch");
+
+  const uint32_t bytes_per_block = 8;
+  TextureSwap(src_endianness, block.data, src, bytes_per_block);
+
+  uint8_t cr[4] = {
+      block.r0, block.r1,
+      static_cast<uint8_t>(2.f / 3.f * block.r0 + 1.f / 3.f * block.r1),
+      static_cast<uint8_t>(1.f / 3.f * block.r0 + 2.f / 3.f * block.r1)};
+  uint8_t cg[4] = {
+      block.g0, block.g1,
+      static_cast<uint8_t>(2.f / 3.f * block.g0 + 1.f / 3.f * block.g1),
+      static_cast<uint8_t>(1.f / 3.f * block.g0 + 2.f / 3.f * block.g1)};
+
+  for (uint32_t oy = 0; oy < 4; ++oy) {
+    for (uint32_t ox = 0; ox < 4; ++ox) {
+      uint8_t xx = (block.xx >> (((ox + (oy * 4)) * 2))) & 3;
+      dest[(oy * dest_pitch) + (ox * 2) + 0] = cr[xx];
+      dest[(oy * dest_pitch) + (ox * 2) + 1] = cg[xx];
+    }
+  }
+}
+
+void TextureInfo::ConvertTiled(uint8_t* dest, const uint8_t* src, Endian endian,
+                               const FormatInfo* format_info, uint32_t offset_x,
+                               uint32_t offset_y, uint32_t block_pitch,
+                               uint32_t width, uint32_t height,
+                               uint32_t output_width) {
+  // TODO(benvanik): optimize this inner loop (or work by tiles).
+  uint32_t bytes_per_block = format_info->block_width *
+                             format_info->block_height *
+                             format_info->bits_per_pixel / 8;
+
+  uint32_t output_pitch =
+      output_width * format_info->block_width * format_info->bits_per_pixel / 8;
+
+  uint32_t output_row_height = 1;
+  if (format_info->format == TextureFormat::k_CTX1) {
+    // TODO: Can we calculate this?
+    output_row_height = 4;
+  }
+
+  // logical w/h in blocks.
+  uint32_t block_width =
+      xe::round_up(width, format_info->block_width) / format_info->block_width;
+  uint32_t block_height = xe::round_up(height, format_info->block_height) /
+                          format_info->block_height;
+
+  // Bytes per pixel
+  auto log2_bpp =
+      (bytes_per_block / 4) + ((bytes_per_block / 2) >> (bytes_per_block / 4));
+
+  // Offset to the current row, in bytes.
+  uint32_t output_row_offset = 0;
+  for (uint32_t y = 0; y < block_height; y++) {
+    auto input_row_offset =
+        TextureInfo::TiledOffset2DOuter(offset_y + y, block_pitch, log2_bpp);
+
+    // Go block-by-block on this row.
+    uint32_t output_offset = output_row_offset;
+    for (uint32_t x = 0; x < block_width; x++) {
+      auto input_offset = TextureInfo::TiledOffset2DInner(
+          offset_x + x, offset_y + y, log2_bpp, input_row_offset);
+      input_offset >>= log2_bpp;
+
+      if (format_info->format == TextureFormat::k_CTX1) {
+        // Convert to R8G8.
+        ConvertTexelCTX1(&dest[output_offset], output_pitch, src, endian);
+      } else {
+        // Generic swap to destination.
+        TextureSwap(endian, dest + output_offset,
+                    src + input_offset * bytes_per_block, bytes_per_block);
+      }
+
+      output_offset += bytes_per_block;
+    }
+
+    output_row_offset += output_pitch * output_row_height;
+  }
+}
+
 uint32_t TextureInfo::GetMaxMipLevels(uint32_t width, uint32_t height,
                                       uint32_t depth) {
   return 1 + xe::log2_floor(std::max({width, height, depth}));
 }
 
-bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
+uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
+                                     uint32_t* offset_x, uint32_t* offset_y) {
+  if (mip == 0) {
+    // Short-circuit. Mip 0 is always stored in guest_address.
+    GetPackedTileOffset(src, offset_x, offset_y);
+    return src.guest_address;
+  }
+
+  // Walk forward to find the address of the mip
+  // If the texture is <= 16 pixels w/h, the mips are packed with the base
+  // texture. Otherwise, they're stored beginning from mip_address.
+  uint32_t address_base = std::min(src.width, src.height) < 16
+                              ? src.guest_address
+                              : src.mip_address;
+  uint32_t address_offset = 0;
+
+  for (uint32_t i = 1; i < mip; i++) {
+    uint32_t logical_width = std::max((src.width + 1) >> mip, 1u);
+    uint32_t logical_height = std::max((src.height + 1) >> mip, 1u);
+    if (std::min(logical_width, logical_height) <= 16) {
+      // We've reached the point where the mips are packed into a single tile.
+      // TODO(DrChat): Figure out how to calculate the packed tile offset.
+      continue;
+    }
+
+    address_offset += src.input_length >> (i * 2);
+  }
+
+  return address_base + address_offset;
+}
+
+bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
+                                      const FormatInfo* format_info,
                                       uint32_t* out_offset_x,
                                       uint32_t* out_offset_y) {
   // Tile size is 32x32, and once textures go <=16 they are packed into a
@@ -231,6 +383,13 @@ bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
   // This only works for square textures, or textures that are some non-pot
   // <= square. As soon as the aspect ratio goes weird, the textures start to
   // stretch across tiles.
+  //
+  // The 2x2 and 1x1 squares are packed in their specific positions because
+  // each square is the size of at least one block (which is 4x4 pixels max)
+  // 4x4: x = 4
+  // 2x2: y = (x & 0x3) << 2
+  // 1x1: y = (x & 0x3) << 2
+  //
   // if (tile_aligned(w) > tile_aligned(h)) {
   //   // wider than tall, so packed horizontally
   // } else if (tile_aligned(w) < tile_aligned(h)) {
@@ -243,16 +402,14 @@ bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
   // The minimum dimension is what matters most: if either width or height
   // is <= 16 this mode kicks in.
 
-  if (std::min(texture_info.size_2d.logical_width,
-               texture_info.size_2d.logical_height) > 16) {
+  if (std::min(width, height) > 16) {
     // Too big, not packed.
     *out_offset_x = 0;
     *out_offset_y = 0;
     return false;
   }
 
-  if (xe::log2_ceil(texture_info.size_2d.logical_width) >
-      xe::log2_ceil(texture_info.size_2d.logical_height)) {
+  if (xe::log2_ceil(width) > xe::log2_ceil(height)) {
     // Wider than tall. Laid out vertically.
     *out_offset_x = 0;
     *out_offset_y = 16;
@@ -261,26 +418,37 @@ bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
     *out_offset_x = 16;
     *out_offset_y = 0;
   }
-  *out_offset_x /= texture_info.format_info()->block_width;
-  *out_offset_y /= texture_info.format_info()->block_height;
+
+  *out_offset_x /= format_info->block_width;
+  *out_offset_y /= format_info->block_height;
   return true;
 }
 
+bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
+                                      uint32_t* out_offset_x,
+                                      uint32_t* out_offset_y) {
+  return GetPackedTileOffset(
+      texture_info.size_2d.logical_width, texture_info.size_2d.logical_height,
+      texture_info.format_info(), out_offset_x, out_offset_y);
+}
+
 // https://github.com/BinomialLLC/crunch/blob/ea9b8d8c00c8329791256adafa8cf11e4e7942a2/inc/crn_decomp.h#L4108
 uint32_t TextureInfo::TiledOffset2DOuter(uint32_t y, uint32_t width,
-                                         uint32_t log_bpp) {
-  uint32_t macro = ((y >> 5) * (width >> 5)) << (log_bpp + 7);
-  uint32_t micro = ((y & 6) << 2) << log_bpp;
-  return macro + ((micro & ~15) << 1) + (micro & 15) +
-         ((y & 8) << (3 + log_bpp)) + ((y & 1) << 4);
+                                         uint32_t log2_bpp) {
+  uint32_t macro = ((y / 32) * (width / 32)) << (log2_bpp + 7);
+  uint32_t micro = ((y & 6) << 2) << log2_bpp;
+  return macro + ((micro & ~0xF) << 1) + (micro & 0xF) +
+         ((y & 8) << (3 + log2_bpp)) + ((y & 1) << 4);
 }
 
-uint32_t TextureInfo::TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t bpp,
+uint32_t TextureInfo::TiledOffset2DInner(uint32_t x, uint32_t y,
+                                         uint32_t log2_bpp,
                                          uint32_t base_offset) {
-  uint32_t macro = (x >> 5) << (bpp + 7);
-  uint32_t micro = (x & 7) << bpp;
-  uint32_t offset = base_offset + (macro + ((micro & ~15) << 1) + (micro & 15));
-  return ((offset & ~511) << 3) + ((offset & 448) << 2) + (offset & 63) +
+  uint32_t macro = (x / 32) << (log2_bpp + 7);
+  uint32_t micro = (x & 7) << log2_bpp;
+  uint32_t offset =
+      base_offset + (macro + ((micro & ~0xF) << 1) + (micro & 0xF));
+  return ((offset & ~0x1FF) << 3) + ((offset & 0x1C0) << 2) + (offset & 0x3F) +
          ((y & 16) << 7) + (((((y & 8) >> 2) + (x >> 3)) & 3) << 6);
 }
 
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 821d5134b..0f02a236a 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -256,6 +256,8 @@ struct TextureInfo {
   Endian endianness;
   bool is_tiled;
   bool has_packed_mips;
+  uint32_t mip_address;
+  uint32_t mip_levels;
   uint32_t input_length;
 
   const FormatInfo* format_info() const {
@@ -304,14 +306,26 @@ struct TextureInfo {
                              uint32_t width, uint32_t height,
                              TextureInfo* out_info);
 
+  static void ConvertTiled(uint8_t* dest, const uint8_t* src, Endian endian,
+                           const FormatInfo* format_info, uint32_t offset_x,
+                           uint32_t offset_y, uint32_t block_pitch,
+                           uint32_t width, uint32_t height,
+                           uint32_t output_width);
+
   static uint32_t GetMaxMipLevels(uint32_t width, uint32_t height,
                                   uint32_t depth);
+  static uint32_t GetMipLocation(const TextureInfo& src, uint32_t mip,
+                                 uint32_t* offset_x, uint32_t* offset_y);
+  static bool GetPackedTileOffset(uint32_t width, uint32_t height,
+                                  const FormatInfo* format_info,
+                                  uint32_t* out_offset_x,
+                                  uint32_t* out_offset_y);
   static bool GetPackedTileOffset(const TextureInfo& texture_info,
                                   uint32_t* out_offset_x,
                                   uint32_t* out_offset_y);
   static uint32_t TiledOffset2DOuter(uint32_t y, uint32_t width,
-                                     uint32_t log_bpp);
-  static uint32_t TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t bpp,
+                                     uint32_t log2_bpp);
+  static uint32_t TiledOffset2DInner(uint32_t x, uint32_t y, uint32_t log2_bpp,
                                      uint32_t base_offset);
 
   uint64_t hash() const;
diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index 9d433f6f1..3ea4afead 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -258,7 +258,13 @@ TextureCache::Texture* TextureCache::AllocateTexture(
   assert_not_null(texture_info.format_info());
   auto& config = texture_configs[int(texture_info.format_info()->format)];
   VkFormat format = config.host_format;
-  assert(format != VK_FORMAT_UNDEFINED);
+  if (format == VK_FORMAT_UNDEFINED) {
+    XELOGE(
+        "Texture Cache: Attempted to allocate texture format %s, which is "
+        "defined as VK_FORMAT_UNDEFINED!",
+        texture_info.format_info()->name);
+    return nullptr;
+  }
 
   image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
   image_info.usage =
@@ -302,7 +308,7 @@ TextureCache::Texture* TextureCache::AllocateTexture(
 
   image_info.format = format;
   image_info.extent = {texture_info.width + 1, texture_info.height + 1, 1};
-  image_info.mipLevels = 1;
+  image_info.mipLevels = texture_info.mip_levels;
   image_info.arrayLayers = texture_info.depth + 1;
   image_info.samples = VK_SAMPLE_COUNT_1_BIT;
   image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
@@ -664,8 +670,6 @@ TextureCache::Sampler* TextureCache::Demand(const SamplerInfo& sampler_info) {
   sampler_create_info.addressModeW =
       address_mode_map[static_cast<int>(sampler_info.clamp_w)];
 
-  sampler_create_info.mipLodBias = sampler_info.lod_bias;
-
   float aniso = 0.f;
   switch (sampler_info.aniso_filter) {
     case AnisoFilter::kDisabled:
@@ -697,8 +701,9 @@ TextureCache::Sampler* TextureCache::Demand(const SamplerInfo& sampler_info) {
 
   sampler_create_info.compareEnable = VK_FALSE;
   sampler_create_info.compareOp = VK_COMPARE_OP_NEVER;
-  sampler_create_info.minLod = 0.0f;
-  sampler_create_info.maxLod = 0.0f;
+  sampler_create_info.mipLodBias = sampler_info.lod_bias;
+  sampler_create_info.minLod = float(sampler_info.mip_min_level);
+  sampler_create_info.maxLod = float(sampler_info.mip_max_level);
   sampler_create_info.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
   sampler_create_info.unnormalizedCoordinates = VK_FALSE;
   VkSampler vk_sampler;
@@ -816,13 +821,13 @@ void TextureSwap(Endian endianness, void* dest, const void* src,
                  size_t length) {
   switch (endianness) {
     case Endian::k8in16:
-      xe::copy_and_swap_16_aligned(dest, src, length / 2);
+      xe::copy_and_swap_16_unaligned(dest, src, length / 2);
       break;
     case Endian::k8in32:
-      xe::copy_and_swap_32_aligned(dest, src, length / 4);
+      xe::copy_and_swap_32_unaligned(dest, src, length / 4);
       break;
     case Endian::k16in32:  // Swap high and low 16 bits within a 32 bit word
-      xe::copy_and_swap_16_in_32_aligned(dest, src, length);
+      xe::copy_and_swap_16_in_32_unaligned(dest, src, length);
       break;
     default:
     case Endian::kUnspecified:
@@ -867,43 +872,21 @@ void TextureCache::FlushPendingCommands(VkCommandBuffer command_buffer,
   vkBeginCommandBuffer(command_buffer, &begin_info);
 }
 
-void TextureCache::ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch,
-                                    const uint8_t* src, Endian src_endianness) {
-  // http://fileadmin.cs.lth.se/cs/Personal/Michael_Doggett/talks/unc-xenos-doggett.pdf
-  union {
-    uint8_t data[8];
-    struct {
-      uint8_t r0, g0, r1, g1;
-      uint32_t xx;
-    };
-  } block;
-  static_assert(sizeof(block) == 8, "CTX1 block mismatch");
-
-  const uint32_t bytes_per_block = 8;
-  TextureSwap(src_endianness, block.data, src, bytes_per_block);
-
-  uint8_t cr[4] = {
-      block.r0, block.r1,
-      static_cast<uint8_t>(2.f / 3.f * block.r0 + 1.f / 3.f * block.r1),
-      static_cast<uint8_t>(1.f / 3.f * block.r0 + 2.f / 3.f * block.r1)};
-  uint8_t cg[4] = {
-      block.g0, block.g1,
-      static_cast<uint8_t>(2.f / 3.f * block.g0 + 1.f / 3.f * block.g1),
-      static_cast<uint8_t>(1.f / 3.f * block.g0 + 2.f / 3.f * block.g1)};
-
-  for (uint32_t oy = 0; oy < 4; ++oy) {
-    for (uint32_t ox = 0; ox < 4; ++ox) {
-      uint8_t xx = (block.xx >> (((ox + (oy * 4)) * 2))) & 3;
-      dest[(oy * dest_pitch) + (ox * 2) + 0] = cr[xx];
-      dest[(oy * dest_pitch) + (ox * 2) + 1] = cg[xx];
-    }
-  }
-}
-
 bool TextureCache::ConvertTexture2D(uint8_t* dest,
                                     VkBufferImageCopy* copy_region,
-                                    const TextureInfo& src) {
-  void* host_address = memory_->TranslatePhysical(src.guest_address);
+                                    uint32_t mip, const TextureInfo& src) {
+  uint32_t offset_x = 0;
+  uint32_t offset_y = 0;
+  uint32_t address =
+      TextureInfo::GetMipLocation(src, mip, &offset_x, &offset_y);
+  void* host_address = memory_->TranslatePhysical(address);
+
+  uint32_t logical_width = src.size_2d.logical_width >> mip;
+  uint32_t logical_height = src.size_2d.logical_height >> mip;
+  uint32_t block_width = src.size_2d.block_width >> mip;
+  uint32_t input_width = src.size_2d.input_width >> mip;
+  uint32_t input_height = src.size_2d.input_height >> mip;
+
   if (!src.is_tiled) {
     uint32_t offset_x, offset_y;
     if (src.has_packed_mips &&
@@ -922,89 +905,25 @@ bool TextureCache::ConvertTexture2D(uint8_t* dest,
         src_mem += src.size_2d.input_pitch;
         dest += src.size_2d.input_pitch;
       }
-      copy_region->bufferRowLength = src.size_2d.input_width;
-      copy_region->bufferImageHeight = src.size_2d.input_height;
-      copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
-      copy_region->imageExtent = {src.size_2d.logical_width,
-                                  src.size_2d.logical_height, 1};
-      return true;
     } else {
       // Fast path copy entire image.
       TextureSwap(src.endianness, dest, host_address, src.input_length);
-      copy_region->bufferRowLength = src.size_2d.input_width;
-      copy_region->bufferImageHeight = src.size_2d.input_height;
-      copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
-      copy_region->imageExtent = {src.size_2d.logical_width,
-                                  src.size_2d.logical_height, 1};
-      return true;
     }
   } else {
     // Untile image.
     // We could do this in a shader to speed things up, as this is pretty
     // slow.
-
-    // TODO(benvanik): optimize this inner loop (or work by tiles).
     const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address);
-    uint32_t bytes_per_block = src.format_info()->block_width *
-                               src.format_info()->block_height *
-                               src.format_info()->bits_per_pixel / 8;
-
-    uint32_t output_pitch = src.size_2d.input_width *
-                            src.format_info()->block_width *
-                            src.format_info()->bits_per_pixel / 8;
-
-    uint32_t output_row_height = 1;
-    if (src.texture_format == TextureFormat::k_CTX1) {
-      // TODO: Can we calculate this?
-      output_row_height = 4;
-    }
-
-    // Tiled textures can be packed; get the offset into the packed texture.
-    uint32_t offset_x;
-    uint32_t offset_y;
-    TextureInfo::GetPackedTileOffset(src, &offset_x, &offset_y);
-    auto log2_bpp = (bytes_per_block >> 2) +
-                    ((bytes_per_block >> 1) >> (bytes_per_block >> 2));
-
-    // Offset to the current row, in bytes.
-    uint32_t output_row_offset = 0;
-    for (uint32_t y = 0; y < src.size_2d.block_height; y++) {
-      auto input_row_offset = TextureInfo::TiledOffset2DOuter(
-          offset_y + y, src.size_2d.block_width, log2_bpp);
-
-      // Go block-by-block on this row.
-      uint32_t output_offset = output_row_offset;
-      for (uint32_t x = 0; x < src.size_2d.block_width; x++) {
-        auto input_offset = TextureInfo::TiledOffset2DInner(
-            offset_x + x, offset_y + y, log2_bpp, input_row_offset);
-        input_offset >>= log2_bpp;
-
-        if (src.texture_format == TextureFormat::k_CTX1) {
-          // Convert to R8G8.
-          ConvertTexelCTX1(&dest[output_offset], output_pitch, src_mem,
-                           src.endianness);
-        } else {
-          // Generic swap to destination.
-          TextureSwap(src.endianness, dest + output_offset,
-                      src_mem + input_offset * bytes_per_block,
-                      bytes_per_block);
-        }
-
-        output_offset += bytes_per_block;
-      }
-
-      output_row_offset += output_pitch * output_row_height;
-    }
-
-    copy_region->bufferRowLength = src.size_2d.input_width;
-    copy_region->bufferImageHeight = src.size_2d.input_height;
-    copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
-    copy_region->imageExtent = {src.size_2d.logical_width,
-                                src.size_2d.logical_height, 1};
-    return true;
+    TextureInfo::ConvertTiled(dest, src_mem, src.endianness, src.format_info(),
+                              offset_x, offset_y, block_width, logical_width,
+                              logical_height, input_width);
   }
 
-  return false;
+  copy_region->bufferRowLength = input_width;
+  copy_region->bufferImageHeight = input_height;
+  copy_region->imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, mip, 0, 1};
+  copy_region->imageExtent = {logical_width, logical_height, 1};
+  return true;
 }
 
 bool TextureCache::ConvertTextureCube(uint8_t* dest,
@@ -1067,13 +986,13 @@ bool TextureCache::ConvertTextureCube(uint8_t* dest,
 }
 
 bool TextureCache::ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region,
-                                  const TextureInfo& src) {
+                                  uint32_t mip, const TextureInfo& src) {
   switch (src.dimension) {
     case Dimension::k1D:
       assert_always();
       break;
     case Dimension::k2D:
-      return ConvertTexture2D(dest, copy_region, src);
+      return ConvertTexture2D(dest, copy_region, mip, src);
     case Dimension::k3D:
       assert_always();
       break;
@@ -1083,6 +1002,145 @@ bool TextureCache::ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region,
   return false;
 }
 
+bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
+                                 VkFence completion_fence, Texture* dest,
+                                 const TextureInfo& src) {
+#if FINE_GRAINED_DRAW_SCOPES
+  SCOPE_profile_cpu_f("gpu");
+#endif  // FINE_GRAINED_DRAW_SCOPES
+
+  size_t unpack_length;
+  if (!ComputeTextureStorage(&unpack_length, src)) {
+    XELOGW("Failed to compute texture storage");
+    return false;
+  }
+
+  size_t total_unpack_length = unpack_length;
+  for (uint32_t i = 1; i < src.mip_levels; i++) {
+    // Add in more space for mips.
+    total_unpack_length += unpack_length >> (2 * i);
+  }
+
+  if (!staging_buffer_.CanAcquire(total_unpack_length)) {
+    // Need to have unique memory for every upload for at least one frame. If we
+    // run out of memory, we need to flush all queued upload commands to the
+    // GPU.
+    FlushPendingCommands(command_buffer, completion_fence);
+
+    // Uploads have been flushed. Continue.
+    if (!staging_buffer_.CanAcquire(total_unpack_length)) {
+      // The staging buffer isn't big enough to hold this texture.
+      XELOGE(
+          "TextureCache staging buffer is too small! (uploading 0x%.8X bytes)",
+          total_unpack_length);
+      assert_always();
+      return false;
+    }
+  }
+
+  // Grab some temporary memory for staging.
+  auto alloc = staging_buffer_.Acquire(total_unpack_length, completion_fence);
+  assert_not_null(alloc);
+  if (!alloc) {
+    XELOGE("%s: Failed to acquire staging memory", __func__);
+    return false;
+  }
+
+  // DEBUG: Check the source address. If it's completely zero'd out, print it.
+  bool valid = false;
+  auto src_data = memory_->TranslatePhysical(src.guest_address);
+  for (uint32_t i = 0; i < src.input_length; i++) {
+    if (src_data[i] != 0) {
+      valid = true;
+      break;
+    }
+  }
+
+  if (!valid) {
+    XELOGW(
+        "Warning: Uploading blank texture at address 0x%.8X "
+        "(length: 0x%.8X, format: %s)",
+        src.guest_address, src.input_length, src.format_info()->name);
+  }
+
+  // Upload texture into GPU memory.
+  // TODO: If the GPU supports it, we can submit a compute batch to convert the
+  // texture and copy it to its destination. Otherwise, fallback to conversion
+  // on the CPU.
+  std::vector<VkBufferImageCopy> copy_regions(src.mip_levels);
+
+  // Base MIP
+  if (!ConvertTexture(reinterpret_cast<uint8_t*>(alloc->host_ptr),
+                      &copy_regions[0], 0, src)) {
+    XELOGW("Failed to convert texture");
+    return false;
+  }
+  copy_regions[0].bufferOffset = alloc->offset;
+  copy_regions[0].imageOffset = {0, 0, 0};
+
+  // Now upload all the MIPs
+  VkDeviceSize buffer_offset = unpack_length;
+  for (uint32_t mip = 1; mip < src.mip_levels; mip++) {
+    uint8_t* dest = reinterpret_cast<uint8_t*>(alloc->host_ptr) + buffer_offset;
+    ConvertTexture(dest, &copy_regions[mip], mip, src);
+    copy_regions[mip].bufferOffset = alloc->offset + buffer_offset;
+    copy_regions[mip].imageOffset = {0, 0, 0};
+
+    // With each mip, the length is divided by 4.
+    buffer_offset += unpack_length >> (2 * mip);
+  }
+
+  // Transition the texture into a transfer destination layout.
+  VkImageMemoryBarrier barrier;
+  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  barrier.pNext = nullptr;
+  barrier.srcAccessMask = 0;
+  barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+  barrier.oldLayout = dest->image_layout;
+  barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.image = dest->image;
+  barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, src.mip_levels,
+                              copy_regions[0].imageSubresource.baseArrayLayer,
+                              copy_regions[0].imageSubresource.layerCount};
+  if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT ||
+      dest->format == VK_FORMAT_D24_UNORM_S8_UINT ||
+      dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+    barrier.subresourceRange.aspectMask =
+        VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+  }
+
+  vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0,
+                       nullptr, 1, &barrier);
+
+  // Now move the converted texture into the destination.
+  if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT ||
+      dest->format == VK_FORMAT_D24_UNORM_S8_UINT ||
+      dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
+    // Do just a depth upload (for now).
+    // This assumes depth buffers don't have mips (hopefully they don't)
+    copy_regions[0].imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+  }
+  vkCmdCopyBufferToImage(command_buffer, staging_buffer_.gpu_buffer(),
+                         dest->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                         src.mip_levels, copy_regions.data());
+
+  // Now transition the texture into a shader readonly source.
+  barrier.srcAccessMask = barrier.dstAccessMask;
+  barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+  barrier.oldLayout = barrier.newLayout;
+  barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+  vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
+                           VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                       0, 0, nullptr, 0, nullptr, 1, &barrier);
+
+  dest->image_layout = barrier.newLayout;
+  return true;
+}
+
 bool TextureCache::ComputeTextureStorage(size_t* output_length,
                                          const TextureInfo& src) {
   if (src.texture_format == TextureFormat::k_CTX1) {
@@ -1182,120 +1240,6 @@ void TextureCache::WritebackTexture(Texture* texture) {
   wb_staging_buffer_.Scavenge();
 }
 
-bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
-                                 VkFence completion_fence, Texture* dest,
-                                 const TextureInfo& src) {
-#if FINE_GRAINED_DRAW_SCOPES
-  SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-  size_t unpack_length;
-  if (!ComputeTextureStorage(&unpack_length, src)) {
-    XELOGW("Failed to compute texture storage");
-    return false;
-  }
-
-  if (!staging_buffer_.CanAcquire(unpack_length)) {
-    // Need to have unique memory for every upload for at least one frame. If we
-    // run out of memory, we need to flush all queued upload commands to the
-    // GPU.
-    FlushPendingCommands(command_buffer, completion_fence);
-
-    // Uploads have been flushed. Continue.
-    if (!staging_buffer_.CanAcquire(unpack_length)) {
-      // The staging buffer isn't big enough to hold this texture.
-      XELOGE(
-          "TextureCache staging buffer is too small! (uploading 0x%.8X bytes)",
-          unpack_length);
-      assert_always();
-      return false;
-    }
-  }
-
-  // Grab some temporary memory for staging.
-  auto alloc = staging_buffer_.Acquire(unpack_length, completion_fence);
-  assert_not_null(alloc);
-
-  // DEBUG: Check the source address. If it's completely zero'd out, print it.
-  bool valid = false;
-  auto src_data = memory_->TranslatePhysical(src.guest_address);
-  for (uint32_t i = 0; i < src.input_length; i++) {
-    if (src_data[i] != 0) {
-      valid = true;
-      break;
-    }
-  }
-
-  if (!valid) {
-    XELOGW(
-        "Warning: Uploading blank texture at address 0x%.8X "
-        "(length: 0x%.8X, format: %d)",
-        src.guest_address, src.input_length, src.texture_format);
-  }
-
-  // Upload texture into GPU memory.
-  // TODO: If the GPU supports it, we can submit a compute batch to convert the
-  // texture and copy it to its destination. Otherwise, fallback to conversion
-  // on the CPU.
-  VkBufferImageCopy copy_region;
-  if (!ConvertTexture(reinterpret_cast<uint8_t*>(alloc->host_ptr), &copy_region,
-                      src)) {
-    XELOGW("Failed to convert texture");
-    return false;
-  }
-
-  // Transition the texture into a transfer destination layout.
-  VkImageMemoryBarrier barrier;
-  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
-  barrier.pNext = nullptr;
-  barrier.srcAccessMask = 0;
-  barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-  barrier.oldLayout = dest->image_layout;
-  barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
-  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
-  barrier.image = dest->image;
-  barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1,
-                              copy_region.imageSubresource.baseArrayLayer,
-                              copy_region.imageSubresource.layerCount};
-  if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT ||
-      dest->format == VK_FORMAT_D24_UNORM_S8_UINT ||
-      dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-    barrier.subresourceRange.aspectMask =
-        VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
-  }
-
-  vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0,
-                       nullptr, 1, &barrier);
-
-  // Now move the converted texture into the destination.
-  copy_region.bufferOffset = alloc->offset;
-  copy_region.imageOffset = {0, 0, 0};
-  if (dest->format == VK_FORMAT_D16_UNORM_S8_UINT ||
-      dest->format == VK_FORMAT_D24_UNORM_S8_UINT ||
-      dest->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
-    // Do just a depth upload (for now).
-    copy_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
-  }
-  vkCmdCopyBufferToImage(command_buffer, staging_buffer_.gpu_buffer(),
-                         dest->image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
-                         &copy_region);
-
-  // Now transition the texture into a shader readonly source.
-  barrier.srcAccessMask = barrier.dstAccessMask;
-  barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
-  barrier.oldLayout = barrier.newLayout;
-  barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-  vkCmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                       VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
-                           VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-                       0, 0, nullptr, 0, nullptr, 1, &barrier);
-
-  dest->image_layout = barrier.newLayout;
-  return true;
-}
-
 void TextureCache::HashTextureBindings(
     XXH64_state_t* hash_state, uint32_t& fetch_mask,
     const std::vector<Shader::TextureBinding>& bindings) {
diff --git a/src/xenia/gpu/vulkan/texture_cache.h b/src/xenia/gpu/vulkan/texture_cache.h
index 6be4a6660..ab529333d 100644
--- a/src/xenia/gpu/vulkan/texture_cache.h
+++ b/src/xenia/gpu/vulkan/texture_cache.h
@@ -149,15 +149,12 @@ class TextureCache {
   void FlushPendingCommands(VkCommandBuffer command_buffer,
                             VkFence completion_fence);
 
-  static void ConvertTexelCTX1(uint8_t* dest, size_t dest_pitch,
-                               const uint8_t* src, Endian src_endianness);
-
   bool ConvertTexture2D(uint8_t* dest, VkBufferImageCopy* copy_region,
-                        const TextureInfo& src);
-  bool ConvertTextureCube(uint8_t* dest, VkBufferImageCopy* copy_region,
+                        uint32_t mip, const TextureInfo& src);
+  bool ConvertTextureCube(uint8_t* dest, VkBufferImageCopy* copy_regions,
                           const TextureInfo& src);
   bool ConvertTexture(uint8_t* dest, VkBufferImageCopy* copy_region,
-                      const TextureInfo& src);
+                      uint32_t mip, const TextureInfo& src);
   bool ComputeTextureStorage(size_t* output_length, const TextureInfo& src);
 
   // Writes a texture back into guest memory. This call is (mostly) asynchronous

From c9d4cfe6d0dd136d3892c018ca6b25f8c2cda597 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 12:01:50 -0500
Subject: [PATCH 36/56] [GPU] MIPs > 16 pixels are stored in their own
 individual tiles

---
 src/xenia/gpu/texture_info.cc | 9 +++++++--
 src/xenia/gpu/texture_info.h  | 2 ++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 36883f8a4..f890cedef 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -337,6 +337,11 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
     return src.guest_address;
   }
 
+  // One tile is 32x32 blocks
+  const uint32_t tile_size = src.format_info()->block_width *
+                             src.format_info()->block_height * 32 * 32 *
+                             src.format_info()->bits_per_pixel / 8;
+
   // Walk forward to find the address of the mip
   // If the texture is <= 16 pixels w/h, the mips are packed with the base
   // texture. Otherwise, they're stored beginning from mip_address.
@@ -348,13 +353,13 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
   for (uint32_t i = 1; i < mip; i++) {
     uint32_t logical_width = std::max((src.width + 1) >> mip, 1u);
     uint32_t logical_height = std::max((src.height + 1) >> mip, 1u);
-    if (std::min(logical_width, logical_height) <= 16) {
+    if (std::min(logical_width, logical_height) < 16) {
       // We've reached the point where the mips are packed into a single tile.
       // TODO(DrChat): Figure out how to calculate the packed tile offset.
       continue;
     }
 
-    address_offset += src.input_length >> (i * 2);
+    address_offset += std::max(src.input_length >> (i * 2), tile_size);
   }
 
   return address_base + address_offset;
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 0f02a236a..667210c55 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -314,6 +314,8 @@ struct TextureInfo {
 
   static uint32_t GetMaxMipLevels(uint32_t width, uint32_t height,
                                   uint32_t depth);
+
+  // Get the memory location of a mip. offset_x and offset_y are in blocks.
   static uint32_t GetMipLocation(const TextureInfo& src, uint32_t mip,
                                  uint32_t* offset_x, uint32_t* offset_y);
   static bool GetPackedTileOffset(uint32_t width, uint32_t height,

From f885b89a03a4ab5ce57b7e3f4f625e2715edc155 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 14:15:36 -0500
Subject: [PATCH 37/56] [Vulkan] Make image views cover all mips Align texture
 dimensions to 1 block minimum (for uploading mips)

---
 src/xenia/gpu/texture_info.cc         | 10 ++++++++++
 src/xenia/gpu/texture_info.h          |  3 +++
 src/xenia/gpu/vulkan/texture_cache.cc | 16 ++++++++++++----
 3 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index f890cedef..4f8926f50 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -365,6 +365,16 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
   return address_base + address_offset;
 }
 
+uint32_t TextureInfo::GetMipLinearSize(const TextureInfo& src, uint32_t mip) {
+  uint32_t bytes_per_block = src.format_info()->block_width *
+                             src.format_info()->block_height *
+                             src.format_info()->bits_per_pixel / 8;
+  uint32_t size = src.input_length >> (mip * 2);
+
+  // The size is at least one block large.
+  return std::max(size, bytes_per_block);
+}
+
 bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
                                       const FormatInfo* format_info,
                                       uint32_t* out_offset_x,
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 667210c55..930eff292 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -318,6 +318,9 @@ struct TextureInfo {
   // Get the memory location of a mip. offset_x and offset_y are in blocks.
   static uint32_t GetMipLocation(const TextureInfo& src, uint32_t mip,
                                  uint32_t* offset_x, uint32_t* offset_y);
+  // Get the byte size of a MIP when stored linearly.
+  static uint32_t GetMipLinearSize(const TextureInfo& src, uint32_t mip);
+
   static bool GetPackedTileOffset(uint32_t width, uint32_t height,
                                   const FormatInfo* format_info,
                                   uint32_t* out_offset_x,
diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index 3ea4afead..eac942b2e 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -62,7 +62,7 @@ static const TextureConfig texture_configs[64] = {
 
     // TODO: D24 unsupported on AMD.
     /* k_24_8                   */ {VK_FORMAT_D24_UNORM_S8_UINT},
-    /* k_24_8_FLOAT             */ {VK_FORMAT_D24_UNORM_S8_UINT},
+    /* k_24_8_FLOAT             */ {VK_FORMAT_D32_SFLOAT_S8_UINT},
     /* k_16                     */ {VK_FORMAT_R16_UNORM},
     /* k_16_16                  */ {VK_FORMAT_R16G16_UNORM},
     /* k_16_16_16_16            */ {VK_FORMAT_R16G16B16A16_UNORM},
@@ -555,7 +555,8 @@ TextureCache::TextureView* TextureCache::DemandView(Texture* texture,
       swiz_component_map[(swizzle >> 6) & 0x7],
       swiz_component_map[(swizzle >> 9) & 0x7],
   };
-  view_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
+  view_info.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0,
+                                texture->texture_info.mip_levels, 0, 1};
   if (texture->format == VK_FORMAT_D16_UNORM_S8_UINT ||
       texture->format == VK_FORMAT_D24_UNORM_S8_UINT ||
       texture->format == VK_FORMAT_D32_SFLOAT_S8_UINT) {
@@ -887,6 +888,13 @@ bool TextureCache::ConvertTexture2D(uint8_t* dest,
   uint32_t input_width = src.size_2d.input_width >> mip;
   uint32_t input_height = src.size_2d.input_height >> mip;
 
+  // All dimensions must be at least one block w/h
+  logical_width = std::max(logical_width, src.format_info()->block_width);
+  logical_height = std::max(logical_height, src.format_info()->block_height);
+  block_width = std::max(block_width, src.format_info()->block_width);
+  input_width = std::max(input_width, src.format_info()->block_width);
+  input_height = std::max(input_height, src.format_info()->block_height);
+
   if (!src.is_tiled) {
     uint32_t offset_x, offset_y;
     if (src.has_packed_mips &&
@@ -1018,7 +1026,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
   size_t total_unpack_length = unpack_length;
   for (uint32_t i = 1; i < src.mip_levels; i++) {
     // Add in more space for mips.
-    total_unpack_length += unpack_length >> (2 * i);
+    total_unpack_length += TextureInfo::GetMipLinearSize(src, i);
   }
 
   if (!staging_buffer_.CanAcquire(total_unpack_length)) {
@@ -1087,7 +1095,7 @@ bool TextureCache::UploadTexture(VkCommandBuffer command_buffer,
     copy_regions[mip].imageOffset = {0, 0, 0};
 
     // With each mip, the length is divided by 4.
-    buffer_offset += unpack_length >> (2 * mip);
+    buffer_offset += TextureInfo::GetMipLinearSize(src, mip);
   }
 
   // Transition the texture into a transfer destination layout.

From 5e4b696782aa4208ee4fff6b7a6fd56521f94b0e Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 14:15:53 -0500
Subject: [PATCH 38/56] [SPIR-V] Reset writes_depth_

---
 src/xenia/gpu/spirv_shader_translator.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/xenia/gpu/spirv_shader_translator.cc b/src/xenia/gpu/spirv_shader_translator.cc
index 834f4ae06..17cec8f37 100644
--- a/src/xenia/gpu/spirv_shader_translator.cc
+++ b/src/xenia/gpu/spirv_shader_translator.cc
@@ -619,6 +619,7 @@ std::vector<uint8_t> SpirvShaderTranslator::CompleteTranslation() {
 
   // Cleanup builder.
   cf_blocks_.clear();
+  writes_depth_ = false;
   loop_head_block_ = nullptr;
   loop_body_block_ = nullptr;
   loop_cont_block_ = nullptr;

From 04748b4a0da431613823157e112017a5bdcd4c8e Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 16:04:11 -0500
Subject: [PATCH 39/56] [GPU] TextureInfo::GetMipLocation - calculate packed
 mip offset

---
 src/xenia/gpu/texture_info.cc | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 4f8926f50..9c93a7872 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -350,18 +350,34 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
                               : src.mip_address;
   uint32_t address_offset = 0;
 
+  uint32_t logical_width = std::max((src.width + 1) >> mip, 1u);
+  uint32_t logical_height = std::max((src.height + 1) >> mip, 1u);
   for (uint32_t i = 1; i < mip; i++) {
-    uint32_t logical_width = std::max((src.width + 1) >> mip, 1u);
-    uint32_t logical_height = std::max((src.height + 1) >> mip, 1u);
     if (std::min(logical_width, logical_height) < 16) {
       // We've reached the point where the mips are packed into a single tile.
-      // TODO(DrChat): Figure out how to calculate the packed tile offset.
-      continue;
+      break;
     }
 
     address_offset += std::max(src.input_length >> (i * 2), tile_size);
   }
 
+  *offset_x = 0;
+  *offset_y = 0;
+  if (std::min(logical_width, logical_height) <= 16) {
+    // Find the block offset of the mip.
+    if (xe::log2_ceil(logical_width) > xe::log2_ceil(logical_height)) {
+      // Wider than tall. Laid out vertically.
+      *offset_y = logical_height & ~0x3;
+      *offset_x = (logical_height & 0x3) << 2;
+    } else {
+      // Taller than wide. Laid out horizontally.
+      *offset_x = logical_width & ~0x3;
+      *offset_y = (logical_width & 0x3) << 2;
+    }
+  }
+
+  *offset_x /= src.format_info()->block_width;
+  *offset_y /= src.format_info()->block_height;
   return address_base + address_offset;
 }
 

From f45cd398efffc166f9d00fd9e260104c38ee69fb Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 17:54:09 -0500
Subject: [PATCH 40/56] [Vulkan] Handle MIPs with non-power-of-two dimensions

---
 src/xenia/gpu/texture_info.cc         | 34 +++++++++++++++++++--------
 src/xenia/gpu/texture_info.h          |  2 ++
 src/xenia/gpu/vulkan/texture_cache.cc |  7 +++---
 3 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 9c93a7872..abcdc8163 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -337,12 +337,6 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
     return src.guest_address;
   }
 
-  // One tile is 32x32 blocks
-  const uint32_t tile_size = src.format_info()->block_width *
-                             src.format_info()->block_height * 32 * 32 *
-                             src.format_info()->bits_per_pixel / 8;
-
-  // Walk forward to find the address of the mip
   // If the texture is <= 16 pixels w/h, the mips are packed with the base
   // texture. Otherwise, they're stored beginning from mip_address.
   uint32_t address_base = std::min(src.width, src.height) < 16
@@ -350,17 +344,22 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
                               : src.mip_address;
   uint32_t address_offset = 0;
 
-  uint32_t logical_width = std::max((src.width + 1) >> mip, 1u);
-  uint32_t logical_height = std::max((src.height + 1) >> mip, 1u);
+  // Walk forward to find the address of the mip.
   for (uint32_t i = 1; i < mip; i++) {
-    if (std::min(logical_width, logical_height) < 16) {
+    uint32_t logical_width = std::max(xe::next_pow2(src.width + 1) >> i, 1u);
+    uint32_t logical_height = std::max(xe::next_pow2(src.height + 1) >> i, 1u);
+    if (std::min(logical_width, logical_height) <= 16) {
       // We've reached the point where the mips are packed into a single tile.
       break;
     }
 
-    address_offset += std::max(src.input_length >> (i * 2), tile_size);
+    address_offset += GetMipSize(src, i);
   }
 
+  // Now, check if the mip is packed at an offset.
+  uint32_t logical_width = std::max(xe::next_pow2(src.width + 1) >> mip, 1u);
+  uint32_t logical_height = std::max(xe::next_pow2(src.height + 1) >> mip, 1u);
+
   *offset_x = 0;
   *offset_y = 0;
   if (std::min(logical_width, logical_height) <= 16) {
@@ -381,6 +380,21 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
   return address_base + address_offset;
 }
 
+uint32_t TextureInfo::GetMipSize(const TextureInfo& src, uint32_t mip) {
+  uint32_t size = src.format_info()->block_width *
+                  src.format_info()->block_height *
+                  (xe::next_pow2(src.width + 1) >> mip) *
+                  (xe::next_pow2(src.height + 1) >> mip) *
+                  src.format_info()->bits_per_pixel / 8;
+
+  // One tile is 32x32 blocks
+  uint32_t tile_size = src.format_info()->block_width *
+                       src.format_info()->block_height * 32 * 32 *
+                       src.format_info()->bits_per_pixel / 8;
+
+  return std::max(size, tile_size);
+}
+
 uint32_t TextureInfo::GetMipLinearSize(const TextureInfo& src, uint32_t mip) {
   uint32_t bytes_per_block = src.format_info()->block_width *
                              src.format_info()->block_height *
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 930eff292..6b7bbfecb 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -318,6 +318,8 @@ struct TextureInfo {
   // Get the memory location of a mip. offset_x and offset_y are in blocks.
   static uint32_t GetMipLocation(const TextureInfo& src, uint32_t mip,
                                  uint32_t* offset_x, uint32_t* offset_y);
+  static uint32_t GetMipSize(const TextureInfo& src, uint32_t mip);
+
   // Get the byte size of a MIP when stored linearly.
   static uint32_t GetMipLinearSize(const TextureInfo& src, uint32_t mip);
 
diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index eac942b2e..6a602d287 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -888,12 +888,11 @@ bool TextureCache::ConvertTexture2D(uint8_t* dest,
   uint32_t input_width = src.size_2d.input_width >> mip;
   uint32_t input_height = src.size_2d.input_height >> mip;
 
-  // All dimensions must be at least one block w/h
+  // All dimensions must be a multiple of block w/h
   logical_width = std::max(logical_width, src.format_info()->block_width);
   logical_height = std::max(logical_height, src.format_info()->block_height);
-  block_width = std::max(block_width, src.format_info()->block_width);
-  input_width = std::max(input_width, src.format_info()->block_width);
-  input_height = std::max(input_height, src.format_info()->block_height);
+  input_width = xe::round_up(input_width, src.format_info()->block_width);
+  input_height = xe::round_up(input_height, src.format_info()->block_height);
 
   if (!src.is_tiled) {
     uint32_t offset_x, offset_y;

From 911588e9dc866b239d6f64b30b90d9f8486532c9 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 18:34:23 -0500
Subject: [PATCH 41/56] [GPU] Fix mip size calculation for compressed textures

---
 src/xenia/gpu/texture_info.cc | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index abcdc8163..1ed2d91e3 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -381,17 +381,25 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
 }
 
 uint32_t TextureInfo::GetMipSize(const TextureInfo& src, uint32_t mip) {
-  uint32_t size = src.format_info()->block_width *
-                  src.format_info()->block_height *
-                  (xe::next_pow2(src.width + 1) >> mip) *
-                  (xe::next_pow2(src.height + 1) >> mip) *
-                  src.format_info()->bits_per_pixel / 8;
+  uint32_t bytes_per_block = src.format_info()->block_width *
+                             src.format_info()->block_height *
+                             src.format_info()->bits_per_pixel / 8;
 
-  // One tile is 32x32 blocks
-  uint32_t tile_size = src.format_info()->block_width *
-                       src.format_info()->block_height * 32 * 32 *
-                       src.format_info()->bits_per_pixel / 8;
+  uint32_t logical_width = xe::next_pow2(src.width + 1) >> mip;
+  uint32_t logical_height = xe::next_pow2(src.height + 1) >> mip;
 
+  // w/h in blocks
+  uint32_t block_width =
+      xe::round_up(logical_width, src.format_info()->block_width) /
+      src.format_info()->block_width;
+  uint32_t block_height =
+      xe::round_up(logical_height, src.format_info()->block_height) /
+      src.format_info()->block_height;
+
+  uint32_t size = block_width * block_height * bytes_per_block;
+
+  // Minimum of one tile, which is 32x32 blocks.
+  uint32_t tile_size = 32 * 32 * bytes_per_block;
   return std::max(size, tile_size);
 }
 

From 92ac9e00b5137aae4373171611cbed4620fb39c7 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 19:58:37 -0500
Subject: [PATCH 42/56] Add Discord to the readme in place of IRC

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index e1b752425..d656cfcf0 100644
--- a/README.md
+++ b/README.md
@@ -4,11 +4,11 @@ Xenia - Xbox 360 Emulator Research Project
 Xenia is an experimental emulator for the Xbox 360. For more information see the
 [main xenia website](http://xenia.jp/).
 
-Come chat with us about **emulator-related topics** in
-[#xenia @ irc.freenode.net](http://webchat.freenode.net?channels=%23xenia&uio=MTE9NzIaa).
-For developer chat join `#xenia-dev` but stay on topic. Lurking is fine.
+Come chat with us about **emulator-related topics** on [Discord](https://discord.gg/Q9mxZf9).
+For developer chat join `#dev` but stay on topic. Lurking is fine.
 Please check the [frequently asked questions](http://xenia.jp/faq/) page before
 asking questions. We've got jobs/lives/etc, so don't expect instant answers.
+
 Discussing illegal activities will get you banned. No warnings.
 
 ## Status

From 0ed99660c41eb495338182e1923ed421a442d793 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 21:22:13 -0500
Subject: [PATCH 43/56] Add in (proper) ico file

---
 assets/icon/icon.ico | Bin 153321 -> 284444 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/assets/icon/icon.ico b/assets/icon/icon.ico
index 103a78ca86232fb78d3f99aad1658f497182f84c..b5da3d6a5dc02df45b0a044c28986902b91397dc 100644
GIT binary patch
literal 284444
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
Y-ox!;vH5X&5P-PUm35Tr6s)8E4{jYU4FCWD

literal 153321
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


From 198cc9b9b908c1facd6bd3357e149636b4d12305 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Thu, 3 May 2018 22:12:36 -0500
Subject: [PATCH 44/56] [CPU] Print a message and crash if the CPU does not
 support AVX.

---
 src/xenia/cpu/backend/x64/x64_backend.cc | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/xenia/cpu/backend/x64/x64_backend.cc b/src/xenia/cpu/backend/x64/x64_backend.cc
index 7739c9519..3390869e5 100644
--- a/src/xenia/cpu/backend/x64/x64_backend.cc
+++ b/src/xenia/cpu/backend/x64/x64_backend.cc
@@ -13,7 +13,9 @@
 
 #include "third_party/capstone/include/capstone.h"
 #include "third_party/capstone/include/x86.h"
+
 #include "xenia/base/exception_handler.h"
+#include "xenia/base/logging.h"
 #include "xenia/cpu/backend/x64/x64_assembler.h"
 #include "xenia/cpu/backend/x64/x64_code_cache.h"
 #include "xenia/cpu/backend/x64/x64_emitter.h"
@@ -65,11 +67,16 @@ bool X64Backend::Initialize(Processor* processor) {
     return false;
   }
 
+  Xbyak::util::Cpu cpu;
+  if (!cpu.has(Xbyak::util::Cpu::tAVX)) {
+    XELOGE("This CPU does not support AVX. The emulator will now crash.");
+    return false;
+  }
+
   RegisterSequences();
 
   // Need movbe to do advanced LOAD/STORE tricks.
   if (FLAGS_enable_haswell_instructions) {
-    Xbyak::util::Cpu cpu;
     machine_info_.supports_extended_load_store =
         cpu.has(Xbyak::util::Cpu::tMOVBE);
   } else {

From 8ecadd49d27a9ff10b8161f49ce28f71748210b0 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 00:18:22 -0500
Subject: [PATCH 45/56] [GPU] Further fix mip address calculations with really
 skewed aspect ratios

---
 src/xenia/gpu/texture_info.cc | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 1ed2d91e3..8025e82fc 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -367,11 +367,11 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
     if (xe::log2_ceil(logical_width) > xe::log2_ceil(logical_height)) {
       // Wider than tall. Laid out vertically.
       *offset_y = logical_height & ~0x3;
-      *offset_x = (logical_height & 0x3) << 2;
+      *offset_x = logical_height & 0x3 ? logical_width << 1 : 0;
     } else {
       // Taller than wide. Laid out horizontally.
       *offset_x = logical_width & ~0x3;
-      *offset_y = (logical_width & 0x3) << 2;
+      *offset_y = logical_width & 0x3 ? logical_height << 1 : 0;
     }
   }
 
@@ -439,9 +439,9 @@ bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
   //
   // The 2x2 and 1x1 squares are packed in their specific positions because
   // each square is the size of at least one block (which is 4x4 pixels max)
-  // 4x4: x = 4
-  // 2x2: y = (x & 0x3) << 2
-  // 1x1: y = (x & 0x3) << 2
+  // 4x4: x = width & ~0x3
+  // 2x2: y = (width & 0x3) << 2
+  // 1x1: y = (width & 0x3) << 2
   //
   // if (tile_aligned(w) > tile_aligned(h)) {
   //   // wider than tall, so packed horizontally

From 7a3d0b683b1f33908f7467d64a5126075b8de4ee Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 00:18:45 -0500
Subject: [PATCH 46/56] [Vulkan] Fix block pitch calculation of mips

---
 src/xenia/gpu/vulkan/texture_cache.cc | 38 +++++++++++----------------
 1 file changed, 15 insertions(+), 23 deletions(-)

diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index 6a602d287..f79367b64 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -882,40 +882,32 @@ bool TextureCache::ConvertTexture2D(uint8_t* dest,
       TextureInfo::GetMipLocation(src, mip, &offset_x, &offset_y);
   void* host_address = memory_->TranslatePhysical(address);
 
+  // Pitch of the source texture in blocks.
+  uint32_t block_width = mip == 0
+                             ? src.size_2d.block_width
+                             : xe::next_pow2(src.size_2d.block_width) >> mip;
   uint32_t logical_width = src.size_2d.logical_width >> mip;
   uint32_t logical_height = src.size_2d.logical_height >> mip;
-  uint32_t block_width = src.size_2d.block_width >> mip;
   uint32_t input_width = src.size_2d.input_width >> mip;
   uint32_t input_height = src.size_2d.input_height >> mip;
 
   // All dimensions must be a multiple of block w/h
-  logical_width = std::max(logical_width, src.format_info()->block_width);
-  logical_height = std::max(logical_height, src.format_info()->block_height);
+  logical_width = xe::round_up(logical_width, src.format_info()->block_width);
+  logical_height =
+      xe::round_up(logical_height, src.format_info()->block_height);
   input_width = xe::round_up(input_width, src.format_info()->block_width);
   input_height = xe::round_up(input_height, src.format_info()->block_height);
 
   if (!src.is_tiled) {
-    uint32_t offset_x, offset_y;
-    if (src.has_packed_mips &&
-        TextureInfo::GetPackedTileOffset(src, &offset_x, &offset_y)) {
-      uint32_t bytes_per_block = src.format_info()->block_width *
-                                 src.format_info()->block_height *
-                                 src.format_info()->bits_per_pixel / 8;
+    uint32_t bytes_per_block = src.format_info()->block_width *
+                               src.format_info()->block_height *
+                               src.format_info()->bits_per_pixel / 8;
 
-      const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address);
-      src_mem += offset_y * src.size_2d.input_pitch;
-      src_mem += offset_x * bytes_per_block;
-      for (uint32_t y = 0;
-           y < std::min(src.size_2d.block_height, src.size_2d.logical_height);
-           y++) {
-        TextureSwap(src.endianness, dest, src_mem, src.size_2d.input_pitch);
-        src_mem += src.size_2d.input_pitch;
-        dest += src.size_2d.input_pitch;
-      }
-    } else {
-      // Fast path copy entire image.
-      TextureSwap(src.endianness, dest, host_address, src.input_length);
-    }
+    const uint8_t* src_mem = reinterpret_cast<const uint8_t*>(host_address);
+    src_mem += offset_y * src.size_2d.input_pitch;
+    src_mem += offset_x * bytes_per_block;
+    TextureSwap(src.endianness, dest, src_mem,
+                src.size_2d.input_pitch * src.size_2d.logical_height);
   } else {
     // Untile image.
     // We could do this in a shader to speed things up, as this is pretty

From f54ac240a49c91d7c6d65acbf0ab51e69b7c5f19 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 09:45:42 -0500
Subject: [PATCH 47/56] [Vulkan] Stupid hack to fix ABGR4 formats.

---
 src/xenia/gpu/vulkan/texture_cache.cc | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index f79367b64..15369643a 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -548,6 +548,12 @@ TextureCache::TextureView* TextureCache::DemandView(Texture* texture,
       VK_COMPONENT_SWIZZLE_ZERO,     VK_COMPONENT_SWIZZLE_ONE,
       VK_COMPONENT_SWIZZLE_IDENTITY,
   };
+  if (texture->texture_info.texture_format == TextureFormat::k_4_4_4_4) {
+    swiz_component_map[0] = VK_COMPONENT_SWIZZLE_A;
+    swiz_component_map[1] = VK_COMPONENT_SWIZZLE_B;
+    swiz_component_map[2] = VK_COMPONENT_SWIZZLE_G;
+    swiz_component_map[3] = VK_COMPONENT_SWIZZLE_R;
+  }
 
   view_info.components = {
       swiz_component_map[(swizzle >> 0) & 0x7],

From 040d8d1ade74f4c3f55e6ae6b5b3bfe692dc8128 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 11:54:33 -0500
Subject: [PATCH 48/56] [GL4] Farewell, GL4 backend

---
 premake5.lua                               |    2 -
 src/xenia/app/premake5.lua                 |    2 -
 src/xenia/app/xenia_main.cc                |    8 +-
 src/xenia/gpu/gl4/draw_batcher.cc          |  535 -----
 src/xenia/gpu/gl4/draw_batcher.h           |  191 --
 src/xenia/gpu/gl4/gl4_command_processor.cc | 2131 --------------------
 src/xenia/gpu/gl4/gl4_command_processor.h  |  237 ---
 src/xenia/gpu/gl4/gl4_gpu_flags.cc         |   17 -
 src/xenia/gpu/gl4/gl4_gpu_flags.h          |   21 -
 src/xenia/gpu/gl4/gl4_graphics_system.cc   |   86 -
 src/xenia/gpu/gl4/gl4_graphics_system.h    |   45 -
 src/xenia/gpu/gl4/gl4_shader.cc            |  298 ---
 src/xenia/gpu/gl4/gl4_shader.h             |   54 -
 src/xenia/gpu/gl4/gl4_shader_cache.cc      |  187 --
 src/xenia/gpu/gl4/gl4_shader_cache.h       |   62 -
 src/xenia/gpu/gl4/gl4_trace_viewer_main.cc |  109 -
 src/xenia/gpu/gl4/premake5.lua             |   97 -
 src/xenia/gpu/gl4/texture_cache.cc         | 1101 ----------
 src/xenia/gpu/gl4/texture_cache.h          |  119 --
 src/xenia/hid/premake5.lua                 |    1 -
 src/xenia/ui/gl/blitter.cc                 |  315 ---
 src/xenia/ui/gl/blitter.h                  |   70 -
 src/xenia/ui/gl/circular_buffer.cc         |  139 --
 src/xenia/ui/gl/circular_buffer.h          |   71 -
 src/xenia/ui/gl/gl.h                       |   32 -
 src/xenia/ui/gl/gl_context.cc              |  268 ---
 src/xenia/ui/gl/gl_context.h               |   93 -
 src/xenia/ui/gl/gl_context_win.cc          |  315 ---
 src/xenia/ui/gl/gl_context_win.h           |   64 -
 src/xenia/ui/gl/gl_context_x11.cc          |  323 ---
 src/xenia/ui/gl/gl_context_x11.h           |   69 -
 src/xenia/ui/gl/gl_immediate_drawer.cc     |  283 ---
 src/xenia/ui/gl/gl_immediate_drawer.h      |   56 -
 src/xenia/ui/gl/gl_provider.cc             |   49 -
 src/xenia/ui/gl/gl_provider.h              |   40 -
 src/xenia/ui/gl/gl_window_demo.cc          |   30 -
 src/xenia/ui/gl/premake5.lua               |   65 -
 37 files changed, 2 insertions(+), 7583 deletions(-)
 delete mode 100644 src/xenia/gpu/gl4/draw_batcher.cc
 delete mode 100644 src/xenia/gpu/gl4/draw_batcher.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_command_processor.cc
 delete mode 100644 src/xenia/gpu/gl4/gl4_command_processor.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_gpu_flags.cc
 delete mode 100644 src/xenia/gpu/gl4/gl4_gpu_flags.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_graphics_system.cc
 delete mode 100644 src/xenia/gpu/gl4/gl4_graphics_system.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_shader.cc
 delete mode 100644 src/xenia/gpu/gl4/gl4_shader.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_shader_cache.cc
 delete mode 100644 src/xenia/gpu/gl4/gl4_shader_cache.h
 delete mode 100644 src/xenia/gpu/gl4/gl4_trace_viewer_main.cc
 delete mode 100644 src/xenia/gpu/gl4/premake5.lua
 delete mode 100644 src/xenia/gpu/gl4/texture_cache.cc
 delete mode 100644 src/xenia/gpu/gl4/texture_cache.h
 delete mode 100644 src/xenia/ui/gl/blitter.cc
 delete mode 100644 src/xenia/ui/gl/blitter.h
 delete mode 100644 src/xenia/ui/gl/circular_buffer.cc
 delete mode 100644 src/xenia/ui/gl/circular_buffer.h
 delete mode 100644 src/xenia/ui/gl/gl.h
 delete mode 100644 src/xenia/ui/gl/gl_context.cc
 delete mode 100644 src/xenia/ui/gl/gl_context.h
 delete mode 100644 src/xenia/ui/gl/gl_context_win.cc
 delete mode 100644 src/xenia/ui/gl/gl_context_win.h
 delete mode 100644 src/xenia/ui/gl/gl_context_x11.cc
 delete mode 100644 src/xenia/ui/gl/gl_context_x11.h
 delete mode 100644 src/xenia/ui/gl/gl_immediate_drawer.cc
 delete mode 100644 src/xenia/ui/gl/gl_immediate_drawer.h
 delete mode 100644 src/xenia/ui/gl/gl_provider.cc
 delete mode 100644 src/xenia/ui/gl/gl_provider.h
 delete mode 100644 src/xenia/ui/gl/gl_window_demo.cc
 delete mode 100644 src/xenia/ui/gl/premake5.lua

diff --git a/premake5.lua b/premake5.lua
index 5412aad33..a3dd2a3c8 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -242,13 +242,11 @@ solution("xenia")
   include("src/xenia/debug/ui")
   include("src/xenia/gpu")
   include("src/xenia/gpu/null")
-  include("src/xenia/gpu/gl4")
   include("src/xenia/gpu/vulkan")
   include("src/xenia/hid")
   include("src/xenia/hid/nop")
   include("src/xenia/kernel")
   include("src/xenia/ui")
-  include("src/xenia/ui/gl")
   include("src/xenia/ui/spirv")
   include("src/xenia/ui/vulkan")
   include("src/xenia/vfs")
diff --git a/src/xenia/app/premake5.lua b/src/xenia/app/premake5.lua
index 4f5498b99..d4d9bb8e1 100644
--- a/src/xenia/app/premake5.lua
+++ b/src/xenia/app/premake5.lua
@@ -26,14 +26,12 @@ project("xenia-app")
     "xenia-cpu-backend-x64",
     "xenia-debug-ui",
     "xenia-gpu",
-    "xenia-gpu-gl4",
     "xenia-gpu-null",
     "xenia-gpu-vulkan",
     "xenia-hid",
     "xenia-hid-nop",
     "xenia-kernel",
     "xenia-ui",
-    "xenia-ui-gl",
     "xenia-ui-spirv",
     "xenia-ui-vulkan",
     "xenia-vfs",
diff --git a/src/xenia/app/xenia_main.cc b/src/xenia/app/xenia_main.cc
index 7b20892a7..be2f3d34b 100644
--- a/src/xenia/app/xenia_main.cc
+++ b/src/xenia/app/xenia_main.cc
@@ -26,7 +26,6 @@
 #endif  // XE_PLATFORM_WIN32
 
 // Available graphics systems:
-#include "xenia/gpu/gl4/gl4_graphics_system.h"
 #include "xenia/gpu/null/null_graphics_system.h"
 #include "xenia/gpu/vulkan/vulkan_graphics_system.h"
 
@@ -38,7 +37,7 @@
 #endif  // XE_PLATFORM_WIN32
 
 DEFINE_string(apu, "any", "Audio system. Use: [any, nop, xaudio2]");
-DEFINE_string(gpu, "any", "Graphics system. Use: [any, gl4, vulkan, null]");
+DEFINE_string(gpu, "any", "Graphics system. Use: [any, vulkan, null]");
 DEFINE_string(hid, "any", "Input system. Use: [any, nop, winkey, xinput]");
 
 DEFINE_string(target, "", "Specifies the target .xex or .iso to execute.");
@@ -71,10 +70,7 @@ std::unique_ptr<apu::AudioSystem> CreateAudioSystem(cpu::Processor* processor) {
 }
 
 std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() {
-  if (FLAGS_gpu.compare("gl4") == 0) {
-    return std::unique_ptr<gpu::GraphicsSystem>(
-        new xe::gpu::gl4::GL4GraphicsSystem());
-  } else if (FLAGS_gpu.compare("vulkan") == 0) {
+  if (FLAGS_gpu.compare("vulkan") == 0) {
     return std::unique_ptr<gpu::GraphicsSystem>(
         new xe::gpu::vulkan::VulkanGraphicsSystem());
   } else if (FLAGS_gpu.compare("null") == 0) {
diff --git a/src/xenia/gpu/gl4/draw_batcher.cc b/src/xenia/gpu/gl4/draw_batcher.cc
deleted file mode 100644
index fa2368884..000000000
--- a/src/xenia/gpu/gl4/draw_batcher.cc
+++ /dev/null
@@ -1,535 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/draw_batcher.h"
-
-#include <cstring>
-
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/gpu/gl4/gl4_gpu_flags.h"
-#include "xenia/gpu/gpu_flags.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-using namespace xe::gpu::xenos;
-
-const size_t kCommandBufferCapacity = 16 * (1024 * 1024);
-const size_t kCommandBufferAlignment = 4;
-const size_t kStateBufferCapacity = 64 * (1024 * 1024);
-const size_t kStateBufferAlignment = 256;
-
-DrawBatcher::DrawBatcher(RegisterFile* register_file)
-    : register_file_(register_file),
-      command_buffer_(kCommandBufferCapacity, kCommandBufferAlignment),
-      state_buffer_(kStateBufferCapacity, kStateBufferAlignment),
-      array_data_buffer_(nullptr),
-      draw_open_(false) {
-  std::memset(&batch_state_, 0, sizeof(batch_state_));
-  batch_state_.needs_reconfigure = true;
-  batch_state_.command_range_start = batch_state_.state_range_start =
-      UINTPTR_MAX;
-  std::memset(&active_draw_, 0, sizeof(active_draw_));
-}
-
-bool DrawBatcher::Initialize(CircularBuffer* array_data_buffer) {
-  array_data_buffer_ = array_data_buffer;
-  if (!command_buffer_.Initialize()) {
-    return false;
-  }
-  if (!state_buffer_.Initialize()) {
-    return false;
-  }
-  if (!InitializeTFB()) {
-    return false;
-  }
-
-  glBindBuffer(GL_DRAW_INDIRECT_BUFFER, command_buffer_.handle());
-  return true;
-}
-
-// Initializes a transform feedback object
-// We use this to capture vertex data straight from the vertex/geometry shader.
-bool DrawBatcher::InitializeTFB() {
-  glCreateBuffers(1, &tfvbo_);
-  if (!tfvbo_) {
-    return false;
-  }
-
-  glCreateTransformFeedbacks(1, &tfbo_);
-  if (!tfbo_) {
-    return false;
-  }
-
-  glCreateQueries(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 1, &tfqo_);
-  if (!tfqo_) {
-    return false;
-  }
-
-  // TODO(DrChat): Calculate this based on the number of primitives drawn.
-  glNamedBufferData(tfvbo_, 16384 * 4, nullptr, GL_STATIC_READ);
-
-  return true;
-}
-
-void DrawBatcher::ShutdownTFB() {
-  glDeleteBuffers(1, &tfvbo_);
-  glDeleteTransformFeedbacks(1, &tfbo_);
-  glDeleteQueries(1, &tfqo_);
-
-  tfvbo_ = 0;
-  tfbo_ = 0;
-  tfqo_ = 0;
-}
-
-size_t DrawBatcher::QueryTFBSize() {
-  if (!tfb_enabled_) {
-    return 0;
-  }
-
-  size_t size = 0;
-  switch (tfb_prim_type_gl_) {
-    case GL_POINTS:
-      size = tfb_prim_count_ * 1 * 4 * 4;
-      break;
-    case GL_LINES:
-      size = tfb_prim_count_ * 2 * 4 * 4;
-      break;
-    case GL_TRIANGLES:
-      size = tfb_prim_count_ * 3 * 4 * 4;
-      break;
-  }
-
-  return size;
-}
-
-bool DrawBatcher::ReadbackTFB(void* buffer, size_t size) {
-  if (!tfb_enabled_) {
-    XELOGW("DrawBatcher::ReadbackTFB called when TFB was disabled!");
-    return false;
-  }
-
-  void* data = glMapNamedBufferRange(tfvbo_, 0, size, GL_MAP_READ_BIT);
-  std::memcpy(buffer, data, size);
-  glUnmapNamedBuffer(tfvbo_);
-
-  return true;
-}
-
-void DrawBatcher::Shutdown() {
-  command_buffer_.Shutdown();
-  state_buffer_.Shutdown();
-  ShutdownTFB();
-}
-
-bool DrawBatcher::ReconfigurePipeline(GL4Shader* vertex_shader,
-                                      GL4Shader* pixel_shader,
-                                      GLuint pipeline) {
-  if (batch_state_.pipeline == pipeline) {
-    // No-op.
-    return true;
-  }
-  if (!Flush(FlushMode::kReconfigure)) {
-    return false;
-  }
-
-  batch_state_.vertex_shader = vertex_shader;
-  batch_state_.pixel_shader = pixel_shader;
-  batch_state_.pipeline = pipeline;
-
-  return true;
-}
-
-bool DrawBatcher::BeginDrawArrays(PrimitiveType prim_type,
-                                  uint32_t index_count) {
-  assert_false(draw_open_);
-  if (batch_state_.prim_type != prim_type || batch_state_.indexed) {
-    if (!Flush(FlushMode::kReconfigure)) {
-      return false;
-    }
-  }
-  batch_state_.prim_type = prim_type;
-  batch_state_.indexed = false;
-
-  if (!BeginDraw()) {
-    return false;
-  }
-
-  auto cmd = active_draw_.draw_arrays_cmd;
-  cmd->base_instance = 0;
-  cmd->instance_count = 1;
-  cmd->count = index_count;
-  cmd->first_index = 0;
-
-  return true;
-}
-
-bool DrawBatcher::BeginDrawElements(PrimitiveType prim_type,
-                                    uint32_t index_count,
-                                    IndexFormat index_format) {
-  assert_false(draw_open_);
-  GLenum index_type =
-      index_format == IndexFormat::kInt32 ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
-  if (batch_state_.prim_type != prim_type || !batch_state_.indexed ||
-      batch_state_.index_type != index_type) {
-    if (!Flush(FlushMode::kReconfigure)) {
-      return false;
-    }
-  }
-  batch_state_.prim_type = prim_type;
-  batch_state_.indexed = true;
-  batch_state_.index_type = index_type;
-
-  if (!BeginDraw()) {
-    return false;
-  }
-
-  uint32_t start_index = register_file_->values[XE_GPU_REG_VGT_INDX_OFFSET].u32;
-  assert_zero(start_index);
-
-  auto cmd = active_draw_.draw_elements_cmd;
-  cmd->base_instance = 0;
-  cmd->instance_count = 1;
-  cmd->count = index_count;
-  cmd->first_index = start_index;
-  cmd->base_vertex = 0;
-
-  return true;
-}
-
-bool DrawBatcher::BeginDraw() {
-  draw_open_ = true;
-
-  if (batch_state_.needs_reconfigure) {
-    batch_state_.needs_reconfigure = false;
-    // Have been reconfigured since last draw - need to compute state size.
-    // Layout:
-    //   [draw command]
-    //   [common header]
-    //   [consts]
-
-    // Padded to max.
-    GLsizei command_size = 0;
-    if (batch_state_.indexed) {
-      command_size = sizeof(DrawElementsIndirectCommand);
-    } else {
-      command_size = sizeof(DrawArraysIndirectCommand);
-    }
-    batch_state_.command_stride =
-        xe::round_up(command_size, GLsizei(kCommandBufferAlignment));
-
-    GLsizei header_size = sizeof(CommonHeader);
-
-    // TODO(benvanik): consts sizing.
-    // GLsizei float_consts_size = sizeof(float4) * 512;
-    // GLsizei bool_consts_size = sizeof(uint32_t) * 8;
-    // GLsizei loop_consts_size = sizeof(uint32_t) * 32;
-    // GLsizei consts_size =
-    //    float_consts_size + bool_consts_size + loop_consts_size;
-    // batch_state_.float_consts_offset = batch_state_.header_offset +
-    // header_size;
-    // batch_state_.bool_consts_offset =
-    //    batch_state_.float_consts_offset + float_consts_size;
-    // batch_state_.loop_consts_offset =
-    //    batch_state_.bool_consts_offset + bool_consts_size;
-    GLsizei consts_size = 0;
-
-    batch_state_.state_stride = header_size + consts_size;
-  }
-
-  // Allocate a command data block.
-  // We should treat it as write-only.
-  if (!command_buffer_.CanAcquire(batch_state_.command_stride)) {
-    Flush(FlushMode::kMakeCoherent);
-  }
-  active_draw_.command_allocation =
-      command_buffer_.Acquire(batch_state_.command_stride);
-  assert_not_null(active_draw_.command_allocation.host_ptr);
-
-  // Allocate a state data block.
-  // We should treat it as write-only.
-  if (!state_buffer_.CanAcquire(batch_state_.state_stride)) {
-    Flush(FlushMode::kMakeCoherent);
-  }
-  active_draw_.state_allocation =
-      state_buffer_.Acquire(batch_state_.state_stride);
-  assert_not_null(active_draw_.state_allocation.host_ptr);
-
-  active_draw_.command_address =
-      reinterpret_cast<uintptr_t>(active_draw_.command_allocation.host_ptr);
-  auto state_host_ptr =
-      reinterpret_cast<uintptr_t>(active_draw_.state_allocation.host_ptr);
-  active_draw_.header = reinterpret_cast<CommonHeader*>(state_host_ptr);
-  active_draw_.header->ps_param_gen = -1;
-  // active_draw_.float_consts =
-  //    reinterpret_cast<float4*>(state_host_ptr +
-  //    batch_state_.float_consts_offset);
-  // active_draw_.bool_consts =
-  //    reinterpret_cast<uint32_t*>(state_host_ptr +
-  //    batch_state_.bool_consts_offset);
-  // active_draw_.loop_consts =
-  //    reinterpret_cast<uint32_t*>(state_host_ptr +
-  //    batch_state_.loop_consts_offset);
-  return true;
-}
-
-void DrawBatcher::DiscardDraw() {
-  if (!draw_open_) {
-    // No-op.
-    return;
-  }
-  draw_open_ = false;
-
-  command_buffer_.Discard(std::move(active_draw_.command_allocation));
-  state_buffer_.Discard(std::move(active_draw_.state_allocation));
-}
-
-bool DrawBatcher::CommitDraw() {
-  assert_true(draw_open_);
-  draw_open_ = false;
-
-  // Copy over required constants.
-  CopyConstants();
-
-  if (batch_state_.state_range_start == UINTPTR_MAX) {
-    batch_state_.command_range_start = active_draw_.command_allocation.offset;
-    batch_state_.state_range_start = active_draw_.state_allocation.offset;
-  }
-  batch_state_.command_range_length +=
-      active_draw_.command_allocation.aligned_length;
-  batch_state_.state_range_length +=
-      active_draw_.state_allocation.aligned_length;
-
-  command_buffer_.Commit(std::move(active_draw_.command_allocation));
-  state_buffer_.Commit(std::move(active_draw_.state_allocation));
-
-  ++batch_state_.draw_count;
-  return true;
-}
-
-void DrawBatcher::TFBBegin(PrimitiveType prim_type) {
-  if (!tfb_enabled_) {
-    return;
-  }
-
-  // Translate the primitive typename to something compatible with TFB.
-  GLenum gl_prim_type = 0;
-  switch (prim_type) {
-    case PrimitiveType::kLineList:
-      gl_prim_type = GL_LINES;
-      break;
-    case PrimitiveType::kLineStrip:
-      gl_prim_type = GL_LINES;
-      break;
-    case PrimitiveType::kLineLoop:
-      gl_prim_type = GL_LINES;
-      break;
-    case PrimitiveType::kPointList:
-      // The geometry shader associated with this writes out triangles.
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    case PrimitiveType::kTriangleList:
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    case PrimitiveType::kTriangleStrip:
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    case PrimitiveType::kRectangleList:
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    case PrimitiveType::kTriangleFan:
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    case PrimitiveType::kQuadList:
-      // FIXME: In some cases the geometry shader will output lines.
-      // See: GL4CommandProcessor::UpdateShaders
-      gl_prim_type = GL_TRIANGLES;
-      break;
-    default:
-      assert_unhandled_case(prim_type);
-      break;
-  }
-
-  // TODO(DrChat): Resize the TFVBO here.
-  // Could draw a 2nd time with the rasterizer disabled once we have a primitive
-  // count.
-
-  tfb_prim_type_ = prim_type;
-  tfb_prim_type_gl_ = gl_prim_type;
-
-  glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfbo_);
-
-  // Bind the buffer to the TFB object.
-  glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfvbo_);
-
-  // Begin a query for # prims written
-  glBeginQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0, tfqo_);
-
-  // Begin capturing.
-  glBeginTransformFeedback(gl_prim_type);
-}
-
-void DrawBatcher::TFBEnd() {
-  if (!tfb_enabled_) {
-    return;
-  }
-
-  glEndTransformFeedback();
-  glEndQueryIndexed(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, 0);
-  glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
-  glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
-
-  // Cache the query size as query objects aren't shared.
-  GLint prim_count = 0;
-  glGetQueryObjectiv(tfqo_, GL_QUERY_RESULT, &prim_count);
-  tfb_prim_count_ = prim_count;
-}
-
-bool DrawBatcher::Flush(FlushMode mode) {
-  GLboolean cull_enabled = 0;
-  if (batch_state_.draw_count) {
-#if FINE_GRAINED_DRAW_SCOPES
-    SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-    assert_not_zero(batch_state_.command_stride);
-    assert_not_zero(batch_state_.state_stride);
-
-    // Flush pending buffer changes.
-    command_buffer_.Flush();
-    state_buffer_.Flush();
-    array_data_buffer_->Flush();
-
-    // State data is indexed by draw ID.
-    glBindBufferRange(GL_SHADER_STORAGE_BUFFER, 0, state_buffer_.handle(),
-                      batch_state_.state_range_start,
-                      batch_state_.state_range_length);
-
-    GLenum prim_type = 0;
-    bool valid_prim = true;
-    switch (batch_state_.prim_type) {
-      case PrimitiveType::kPointList:
-        prim_type = GL_POINTS;
-        break;
-      case PrimitiveType::kLineList:
-        prim_type = GL_LINES;
-        break;
-      case PrimitiveType::kLineStrip:
-        prim_type = GL_LINE_STRIP;
-        break;
-      case PrimitiveType::kLineLoop:
-        prim_type = GL_LINE_LOOP;
-        break;
-      case PrimitiveType::kTriangleList:
-        prim_type = GL_TRIANGLES;
-        break;
-      case PrimitiveType::kTriangleStrip:
-        prim_type = GL_TRIANGLE_STRIP;
-        break;
-      case PrimitiveType::kTriangleFan:
-        prim_type = GL_TRIANGLE_FAN;
-        break;
-      case PrimitiveType::kRectangleList:
-        prim_type = GL_TRIANGLES;
-        // Rect lists aren't culled. There may be other things they skip too.
-        // assert_true(
-        // (register_file_->values[XE_GPU_REG_PA_SU_SC_MODE_CNTL].u32
-        // & 0x3) == 0);
-        break;
-      case PrimitiveType::kQuadList:
-        prim_type = GL_LINES_ADJACENCY;
-        break;
-      default:
-      case PrimitiveType::kTriangleWithWFlags:
-        prim_type = GL_TRIANGLES;
-        valid_prim = false;
-        XELOGE("unsupported primitive type %d", batch_state_.prim_type);
-        assert_unhandled_case(batch_state_.prim_type);
-        break;
-    }
-
-    // Fast path for single draws.
-    void* indirect_offset =
-        reinterpret_cast<void*>(batch_state_.command_range_start);
-
-    if (tfb_enabled_) {
-      TFBBegin(batch_state_.prim_type);
-    }
-
-    if (valid_prim && batch_state_.draw_count == 1) {
-      // Fast path for one draw. Removes MDI overhead when not required.
-      if (batch_state_.indexed) {
-        auto& cmd = active_draw_.draw_elements_cmd;
-        glDrawElementsInstancedBaseVertexBaseInstance(
-            prim_type, cmd->count, batch_state_.index_type,
-            reinterpret_cast<void*>(
-                uintptr_t(cmd->first_index) *
-                (batch_state_.index_type == GL_UNSIGNED_SHORT ? 2 : 4)),
-            cmd->instance_count, cmd->base_vertex, cmd->base_instance);
-      } else {
-        auto& cmd = active_draw_.draw_arrays_cmd;
-        glDrawArraysInstancedBaseInstance(prim_type, cmd->first_index,
-                                          cmd->count, cmd->instance_count,
-                                          cmd->base_instance);
-      }
-    } else if (valid_prim) {
-      // Full multi-draw.
-      if (batch_state_.indexed) {
-        glMultiDrawElementsIndirect(prim_type, batch_state_.index_type,
-                                    indirect_offset, batch_state_.draw_count,
-                                    batch_state_.command_stride);
-      } else {
-        glMultiDrawArraysIndirect(prim_type, indirect_offset,
-                                  batch_state_.draw_count,
-                                  batch_state_.command_stride);
-      }
-    }
-
-    if (tfb_enabled_) {
-      TFBEnd();
-    }
-
-    batch_state_.command_range_start = UINTPTR_MAX;
-    batch_state_.command_range_length = 0;
-    batch_state_.state_range_start = UINTPTR_MAX;
-    batch_state_.state_range_length = 0;
-    batch_state_.draw_count = 0;
-  }
-
-  if (mode == FlushMode::kReconfigure) {
-    // Reset - we'll update it as soon as we have all the information.
-    batch_state_.needs_reconfigure = true;
-  }
-
-  return true;
-}
-
-void DrawBatcher::CopyConstants() {
-  // TODO(benvanik): partial updates, etc. We could use shader constant access
-  // knowledge that we get at compile time to only upload those constants
-  // required. If we did this as a variable length then we could really cut
-  // down on state block sizes.
-
-  std::memcpy(active_draw_.header->float_consts,
-              &register_file_->values[XE_GPU_REG_SHADER_CONSTANT_000_X].f32,
-              sizeof(active_draw_.header->float_consts));
-  std::memcpy(
-      active_draw_.header->bool_consts,
-      &register_file_->values[XE_GPU_REG_SHADER_CONSTANT_BOOL_000_031].f32,
-      sizeof(active_draw_.header->bool_consts));
-  std::memcpy(active_draw_.header->loop_consts,
-              &register_file_->values[XE_GPU_REG_SHADER_CONSTANT_LOOP_00].f32,
-              sizeof(active_draw_.header->loop_consts));
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/draw_batcher.h b/src/xenia/gpu/gl4/draw_batcher.h
deleted file mode 100644
index fdecfb9da..000000000
--- a/src/xenia/gpu/gl4/draw_batcher.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_DRAW_BATCHER_H_
-#define XENIA_GPU_GL4_DRAW_BATCHER_H_
-
-#include "xenia/gpu/gl4/gl4_shader.h"
-#include "xenia/gpu/register_file.h"
-#include "xenia/gpu/xenos.h"
-#include "xenia/ui/gl/circular_buffer.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-using xe::ui::gl::CircularBuffer;
-
-union float4 {
-  float v[4];
-  struct {
-    float x, y, z, w;
-  };
-};
-
-#pragma pack(push, 4)
-struct DrawArraysIndirectCommand {
-  GLuint count;
-  GLuint instance_count;
-  GLuint first_index;
-  GLuint base_instance;
-};
-struct DrawElementsIndirectCommand {
-  GLuint count;
-  GLuint instance_count;
-  GLuint first_index;
-  GLint base_vertex;
-  GLuint base_instance;
-};
-#pragma pack(pop)
-
-class DrawBatcher {
- public:
-  enum class FlushMode {
-    kMakeCoherent,
-    kStateChange,
-    kReconfigure,
-  };
-
-  explicit DrawBatcher(RegisterFile* register_file);
-
-  bool Initialize(CircularBuffer* array_data_buffer);
-  void Shutdown();
-
-  PrimitiveType prim_type() const { return batch_state_.prim_type; }
-
-  void set_window_scalar(float width_scalar, float height_scalar) {
-    active_draw_.header->window_scale.x = width_scalar;
-    active_draw_.header->window_scale.y = height_scalar;
-  }
-  void set_vtx_fmt(float xy, float z, float w) {
-    active_draw_.header->vtx_fmt.x = xy;
-    active_draw_.header->vtx_fmt.y = xy;
-    active_draw_.header->vtx_fmt.z = z;
-    active_draw_.header->vtx_fmt.w = w;
-  }
-  void set_alpha_test(bool enabled, uint32_t func, float ref) {
-    active_draw_.header->alpha_test.x = enabled ? 1.0f : 0.0f;
-    active_draw_.header->alpha_test.y = static_cast<float>(func);
-    active_draw_.header->alpha_test.z = ref;
-  }
-  void set_ps_param_gen(int register_index) {
-    active_draw_.header->ps_param_gen = register_index;
-  }
-  void set_texture_sampler(int index, GLuint64 handle, uint32_t swizzle) {
-    active_draw_.header->texture_samplers[index] = handle;
-    active_draw_.header->texture_swizzles[index] = swizzle;
-  }
-  void set_index_buffer(const CircularBuffer::Allocation& allocation) {
-    // Offset is used in glDrawElements.
-    auto& cmd = active_draw_.draw_elements_cmd;
-    size_t index_size = batch_state_.index_type == GL_UNSIGNED_SHORT ? 2 : 4;
-    cmd->first_index = GLuint(allocation.offset / index_size);
-  }
-
-  bool ReconfigurePipeline(GL4Shader* vertex_shader, GL4Shader* pixel_shader,
-                           GLuint pipeline);
-
-  bool BeginDrawArrays(PrimitiveType prim_type, uint32_t index_count);
-  bool BeginDrawElements(PrimitiveType prim_type, uint32_t index_count,
-                         IndexFormat index_format);
-  void DiscardDraw();
-  bool CommitDraw();
-  bool Flush(FlushMode mode);
-
-  // TFB - Filled with vertex shader output from the last flush.
-  size_t QueryTFBSize();
-  bool ReadbackTFB(void* buffer, size_t size);
-
-  GLuint tfvbo() { return tfvbo_; }
-  bool is_tfb_enabled() const { return tfb_enabled_; }
-  void set_tfb_enabled(bool enabled) { tfb_enabled_ = enabled; }
-
- private:
-  bool InitializeTFB();
-  void ShutdownTFB();
-
-  void TFBBegin(PrimitiveType prim_type);
-  void TFBEnd();
-
-  bool BeginDraw();
-  void CopyConstants();
-
-  RegisterFile* register_file_;
-  CircularBuffer command_buffer_;
-  CircularBuffer state_buffer_;
-  CircularBuffer* array_data_buffer_;
-
-  GLuint tfbo_ = 0;
-  GLuint tfvbo_ = 0;
-  GLuint tfqo_ = 0;
-  PrimitiveType tfb_prim_type_ = PrimitiveType::kNone;
-  GLenum tfb_prim_type_gl_ = 0;
-  GLint tfb_prim_count_ = 0;
-  bool tfb_enabled_ = false;
-
-  struct BatchState {
-    bool needs_reconfigure;
-    PrimitiveType prim_type;
-    bool indexed;
-    GLenum index_type;
-
-    GL4Shader* vertex_shader;
-    GL4Shader* pixel_shader;
-    GLuint pipeline;
-
-    GLsizei command_stride;
-    GLsizei state_stride;
-    GLsizei float_consts_offset;
-    GLsizei bool_consts_offset;
-    GLsizei loop_consts_offset;
-
-    uintptr_t command_range_start;
-    uintptr_t command_range_length;
-    uintptr_t state_range_start;
-    uintptr_t state_range_length;
-    GLsizei draw_count;
-  } batch_state_;
-
-  // This must match GL4Shader's header.
-  struct CommonHeader {
-    float4 window_scale;  // sx,sy, ?, ?
-    float4 vtx_fmt;       //
-    float4 alpha_test;    // alpha test enable, func, ref, ?
-    int ps_param_gen;
-    int padding[3];
-
-    // TODO(benvanik): pack tightly
-    GLuint64 texture_samplers[32];
-    GLuint texture_swizzles[32];
-
-    float4 float_consts[512];
-    uint32_t bool_consts[8];
-    uint32_t loop_consts[32];
-  };
-  struct {
-    CircularBuffer::Allocation command_allocation;
-    CircularBuffer::Allocation state_allocation;
-
-    union {
-      DrawArraysIndirectCommand* draw_arrays_cmd;
-      DrawElementsIndirectCommand* draw_elements_cmd;
-      uintptr_t command_address;
-    };
-
-    CommonHeader* header;
-  } active_draw_;
-  bool draw_open_;
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_DRAW_BATCHER_H_
diff --git a/src/xenia/gpu/gl4/gl4_command_processor.cc b/src/xenia/gpu/gl4/gl4_command_processor.cc
deleted file mode 100644
index 5392c22d2..000000000
--- a/src/xenia/gpu/gl4/gl4_command_processor.cc
+++ /dev/null
@@ -1,2131 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/gl4_command_processor.h"
-
-#include <algorithm>
-
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/base/profiling.h"
-#include "xenia/gpu/gl4/gl4_gpu_flags.h"
-#include "xenia/gpu/gl4/gl4_graphics_system.h"
-#include "xenia/gpu/gpu_flags.h"
-#include "xenia/gpu/sampler_info.h"
-#include "xenia/gpu/texture_info.h"
-#include "xenia/gpu/xenos.h"
-
-#include "third_party/xxhash/xxhash.h"
-
-DEFINE_bool(draw_all_framebuffers, false,
-            "Copy all render targets to screen on swap");
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-using namespace xe::gpu::xenos;
-
-const GLuint kAnyTarget = UINT_MAX;
-
-// All uncached vertex/index data goes here. If it fills up we need to sync
-// with the GPU, so this should be large enough to prevent that in a normal
-// frame.
-const size_t kScratchBufferCapacity = 256 * 1024 * 1024;
-const size_t kScratchBufferAlignment = 256;
-
-GL4CommandProcessor::CachedPipeline::CachedPipeline()
-    : vertex_program(0), fragment_program(0), handles({0}) {}
-
-GL4CommandProcessor::CachedPipeline::~CachedPipeline() {
-  glDeleteProgramPipelines(1, &handles.default_pipeline);
-  glDeleteProgramPipelines(1, &handles.point_list_pipeline);
-  glDeleteProgramPipelines(1, &handles.rect_list_pipeline);
-  glDeleteProgramPipelines(1, &handles.quad_list_pipeline);
-  glDeleteProgramPipelines(1, &handles.line_quad_list_pipeline);
-}
-
-GL4CommandProcessor::GL4CommandProcessor(GL4GraphicsSystem* graphics_system,
-                                         kernel::KernelState* kernel_state)
-    : CommandProcessor(graphics_system, kernel_state),
-      shader_translator_(GlslShaderTranslator::Dialect::kGL45),
-      draw_batcher_(graphics_system_->register_file()),
-      scratch_buffer_(kScratchBufferCapacity, kScratchBufferAlignment),
-      shader_cache_(&shader_translator_) {}
-
-GL4CommandProcessor::~GL4CommandProcessor() = default;
-
-void GL4CommandProcessor::ClearCaches() {
-  texture_cache()->Clear();
-
-  for (auto& cached_framebuffer : cached_framebuffers_) {
-    glDeleteFramebuffers(1, &cached_framebuffer.framebuffer);
-  }
-  cached_framebuffers_.clear();
-
-  for (auto& cached_color_render_target : cached_color_render_targets_) {
-    glDeleteTextures(1, &cached_color_render_target.texture);
-  }
-  cached_color_render_targets_.clear();
-
-  for (auto& cached_depth_render_target : cached_depth_render_targets_) {
-    glDeleteTextures(1, &cached_depth_render_target.texture);
-  }
-  cached_depth_render_targets_.clear();
-
-  CommandProcessor::ClearCaches();
-}
-
-bool GL4CommandProcessor::SetupContext() {
-  if (!CommandProcessor::SetupContext()) {
-    XELOGE("Unable to initialize base command processor context");
-    return false;
-  }
-
-  // Circular buffer holding scratch vertex/index data.
-  if (!scratch_buffer_.Initialize()) {
-    XELOGE("Unable to initialize scratch buffer");
-    return false;
-  }
-
-  // Command buffer.
-  if (!draw_batcher_.Initialize(&scratch_buffer_)) {
-    XELOGE("Unable to initialize command buffer");
-    return false;
-  }
-
-  // Texture cache that keeps track of any textures/samplers used.
-  if (!texture_cache_.Initialize(memory_, &scratch_buffer_)) {
-    XELOGE("Unable to initialize texture cache");
-    return false;
-  }
-
-  const std::string geometry_header =
-      "#version 450\n"
-      "#extension all : warn\n"
-      "#extension GL_ARB_explicit_uniform_location : require\n"
-      "#extension GL_ARB_shading_language_420pack : require\n"
-      "in gl_PerVertex {\n"
-      "  vec4 gl_Position;\n"
-      "  float gl_PointSize;\n"
-      "  float gl_ClipDistance[];\n"
-      "} gl_in[];\n"
-      "out gl_PerVertex {\n"
-      "  vec4 gl_Position;\n"
-      "  float gl_PointSize;\n"
-      "  float gl_ClipDistance[];\n"
-      "};\n"
-      "struct VertexData {\n"
-      "  vec4 o[16];\n"
-      "};\n"
-      "\n"
-      "layout(location = 1) in VertexData in_vtx[];\n"
-      "layout(location = 1) out VertexData out_vtx;\n";
-  // TODO(benvanik): fetch default point size from register and use that if
-  //     the VS doesn't write oPointSize.
-  // TODO(benvanik): clamp to min/max.
-  // TODO(benvanik): figure out how to see which interpolator gets adjusted.
-  std::string point_list_shader =
-      geometry_header +
-      "layout(points) in;\n"
-      "layout(triangle_strip, max_vertices = 4) out;\n"
-      "void main() {\n"
-      "  const vec2 offsets[4] = {\n"
-      "    vec2(-1.0,  1.0),\n"
-      "    vec2( 1.0,  1.0),\n"
-      "    vec2(-1.0, -1.0),\n"
-      "    vec2( 1.0, -1.0),\n"
-      "  };\n"
-      "  vec4 pos = gl_in[0].gl_Position;\n"
-      "  float psize = gl_in[0].gl_PointSize;\n"
-      "  for (int i = 0; i < 4; ++i) {\n"
-      "    gl_Position = vec4(pos.xy + offsets[i] * psize, pos.zw);\n"
-      "    out_vtx = in_vtx[0];\n"
-      "    EmitVertex();\n"
-      "  }\n"
-      "  EndPrimitive();\n"
-      "}\n";
-  std::string rect_list_shader =
-      geometry_header +
-      "layout(triangles) in;\n"
-      "layout(triangle_strip, max_vertices = 6) out;\n"
-      "void main() {\n"
-      // Most games use the left-aligned form.
-      "  bool left_aligned = gl_in[0].gl_Position.x == \n"
-      "     gl_in[2].gl_Position.x;\n"
-      "  if (left_aligned) {\n"
-      //  0 ------ 1
-      //  |      - |
-      //  |   //   |
-      //  | -      |
-      //  2 ----- [3]
-      "    gl_Position = gl_in[0].gl_Position;\n"
-      "    gl_PointSize = gl_in[0].gl_PointSize;\n"
-      "    out_vtx = in_vtx[0];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[1].gl_Position;\n"
-      "    gl_PointSize = gl_in[1].gl_PointSize;\n"
-      "    out_vtx = in_vtx[1];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[2].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    out_vtx = in_vtx[2];\n"
-      "    EmitVertex();\n"
-      "    EndPrimitive();\n"
-      "    gl_Position = gl_in[2].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    out_vtx = in_vtx[2];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[1].gl_Position;\n"
-      "    gl_PointSize = gl_in[1].gl_PointSize;\n"
-      "    out_vtx = in_vtx[1];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = \n"
-      "       (gl_in[1].gl_Position + gl_in[2].gl_Position) - \n"
-      "       gl_in[0].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    for (int i = 0; i < 16; ++i) {\n"
-      "      out_vtx.o[i] = -in_vtx[0].o[i] + in_vtx[1].o[i] + \n"
-      "          in_vtx[2].o[i];\n"
-      "    }\n"
-      "    EmitVertex();\n"
-      "    EndPrimitive();\n"
-      "  } else {\n"
-      //  0 ------ 1
-      //  | -      |
-      //  |   \\   |
-      //  |      - |
-      // [3] ----- 2
-      "    gl_Position = gl_in[0].gl_Position;\n"
-      "    gl_PointSize = gl_in[0].gl_PointSize;\n"
-      "    out_vtx = in_vtx[0];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[1].gl_Position;\n"
-      "    gl_PointSize = gl_in[1].gl_PointSize;\n"
-      "    out_vtx = in_vtx[1];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[2].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    out_vtx = in_vtx[2];\n"
-      "    EmitVertex();\n"
-      "    EndPrimitive();\n"
-      "    gl_Position = gl_in[0].gl_Position;\n"
-      "    gl_PointSize = gl_in[0].gl_PointSize;\n"
-      "    out_vtx = in_vtx[0];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = gl_in[2].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    out_vtx = in_vtx[2];\n"
-      "    EmitVertex();\n"
-      "    gl_Position = (gl_in[0].gl_Position + gl_in[2].gl_Position) - \n"
-      "        gl_in[1].gl_Position;\n"
-      "    gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "    for (int i = 0; i < 16; ++i) {\n"
-      "      out_vtx.o[i] = in_vtx[0].o[i] + -in_vtx[1].o[i] + \n"
-      "          in_vtx[2].o[i];\n"
-      "    }\n"
-      "    EmitVertex();\n"
-      "    EndPrimitive();\n"
-      "  }\n"
-      "}\n";
-  std::string quad_list_shader =
-      geometry_header +
-      "layout(lines_adjacency) in;\n"
-      "layout(triangle_strip, max_vertices = 4) out;\n"
-      "void main() {\n"
-      "  const int order[4] = { 0, 1, 3, 2 };\n"
-      "  for (int i = 0; i < 4; ++i) {\n"
-      "    int input_index = order[i];\n"
-      "    gl_Position = gl_in[input_index].gl_Position;\n"
-      "    gl_PointSize = gl_in[input_index].gl_PointSize;\n"
-      "    out_vtx = in_vtx[input_index];\n"
-      "    EmitVertex();\n"
-      "  }\n"
-      "  EndPrimitive();\n"
-      "}\n";
-  std::string line_quad_list_shader =
-      geometry_header +
-      "layout(lines_adjacency) in;\n"
-      "layout(line_strip, max_vertices = 5) out;\n"
-      "void main() {\n"
-      "  gl_Position = gl_in[0].gl_Position;\n"
-      "  gl_PointSize = gl_in[0].gl_PointSize;\n"
-      "  out_vtx = in_vtx[0];\n"
-      "  EmitVertex();\n"
-      "  gl_Position = gl_in[1].gl_Position;\n"
-      "  gl_PointSize = gl_in[1].gl_PointSize;\n"
-      "  out_vtx = in_vtx[1];\n"
-      "  EmitVertex();\n"
-      "  gl_Position = gl_in[2].gl_Position;\n"
-      "  gl_PointSize = gl_in[2].gl_PointSize;\n"
-      "  out_vtx = in_vtx[2];\n"
-      "  EmitVertex();\n"
-      "  gl_Position = gl_in[3].gl_Position;\n"
-      "  gl_PointSize = gl_in[3].gl_PointSize;\n"
-      "  out_vtx = in_vtx[3];\n"
-      "  EmitVertex();\n"
-      "  gl_Position = gl_in[0].gl_Position;\n"
-      "  gl_PointSize = gl_in[0].gl_PointSize;\n"
-      "  out_vtx = in_vtx[0];\n"
-      "  EmitVertex();\n"
-      "  EndPrimitive();\n"
-      "}\n";
-  point_list_geometry_program_ = CreateGeometryProgram(point_list_shader);
-  rect_list_geometry_program_ = CreateGeometryProgram(rect_list_shader);
-  quad_list_geometry_program_ = CreateGeometryProgram(quad_list_shader);
-  line_quad_list_geometry_program_ =
-      CreateGeometryProgram(line_quad_list_shader);
-  if (!point_list_geometry_program_ || !rect_list_geometry_program_ ||
-      !quad_list_geometry_program_ || !line_quad_list_geometry_program_) {
-    return false;
-  }
-
-  glEnable(GL_SCISSOR_TEST);
-  glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE);
-  glPointParameteri(GL_POINT_SPRITE_COORD_ORIGIN, GL_UPPER_LEFT);
-
-  return true;
-}
-
-GLuint GL4CommandProcessor::CreateGeometryProgram(const std::string& source) {
-  auto source_str = source.c_str();
-  GLuint program = glCreateShaderProgramv(GL_GEOMETRY_SHADER, 1, &source_str);
-
-  // Get error log, if we failed to link.
-  GLint link_status = 0;
-  glGetProgramiv(program, GL_LINK_STATUS, &link_status);
-  if (!link_status) {
-    GLint log_length = 0;
-    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
-    std::string info_log;
-    info_log.resize(log_length - 1);
-    glGetProgramInfoLog(program, log_length, &log_length,
-                        const_cast<char*>(info_log.data()));
-    XELOGE("Unable to link program: %s", info_log.c_str());
-    glDeleteProgram(program);
-    return 0;
-  }
-
-  return program;
-}
-
-void GL4CommandProcessor::ShutdownContext() {
-  glDeleteProgram(point_list_geometry_program_);
-  glDeleteProgram(rect_list_geometry_program_);
-  glDeleteProgram(quad_list_geometry_program_);
-  glDeleteProgram(line_quad_list_geometry_program_);
-  texture_cache_.Shutdown();
-  draw_batcher_.Shutdown();
-  scratch_buffer_.Shutdown();
-
-  all_pipelines_.clear();
-  shader_cache_.Reset();
-
-  CommandProcessor::ShutdownContext();
-}
-
-void GL4CommandProcessor::MakeCoherent() {
-  RegisterFile* regs = register_file_;
-  auto status_host = regs->values[XE_GPU_REG_COHER_STATUS_HOST].u32;
-
-  CommandProcessor::MakeCoherent();
-
-  if (status_host & 0x80000000ul) {
-    scratch_buffer_.ClearCache();
-  }
-}
-
-void GL4CommandProcessor::PrepareForWait() {
-  SCOPE_profile_cpu_f("gpu");
-
-  CommandProcessor::PrepareForWait();
-
-  // TODO(benvanik): fences and fancy stuff. We should figure out a way to
-  // make interrupt callbacks from the GPU so that we don't have to do a full
-  // synchronize here.
-  glFlush();
-  // glFinish();
-
-  if (FLAGS_thread_safe_gl) {
-    context_->ClearCurrent();
-  }
-}
-
-void GL4CommandProcessor::ReturnFromWait() {
-  if (FLAGS_thread_safe_gl) {
-    context_->MakeCurrent();
-  }
-
-  CommandProcessor::ReturnFromWait();
-}
-
-void GL4CommandProcessor::PerformSwap(uint32_t frontbuffer_ptr,
-                                      uint32_t frontbuffer_width,
-                                      uint32_t frontbuffer_height) {
-  // Ensure we issue any pending draws.
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kMakeCoherent);
-
-  // One-time initialization.
-  // TODO(benvanik): move someplace more sane?
-  if (!swap_state_.front_buffer_texture) {
-    std::lock_guard<std::mutex> lock(swap_state_.mutex);
-    swap_state_.width = frontbuffer_width;
-    swap_state_.height = frontbuffer_height;
-    GLuint front_buffer_texture;
-    GLuint back_buffer_texture;
-    glCreateTextures(GL_TEXTURE_2D, 1, &front_buffer_texture);
-    glCreateTextures(GL_TEXTURE_2D, 1, &back_buffer_texture);
-    swap_state_.front_buffer_texture = front_buffer_texture;
-    swap_state_.back_buffer_texture = back_buffer_texture;
-    glTextureStorage2D(front_buffer_texture, 1, GL_RGBA8, swap_state_.width,
-                       swap_state_.height);
-    glTextureStorage2D(back_buffer_texture, 1, GL_RGBA8, swap_state_.width,
-                       swap_state_.height);
-  }
-
-  // Lookup the framebuffer in the recently-resolved list.
-  // TODO(benvanik): make this much more sophisticated.
-  // TODO(benvanik): handle not found cases.
-  // TODO(benvanik): handle dirty cases (resolved to sysmem, touched).
-  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-  // HACK: just use whatever our current framebuffer is.
-  GLuint framebuffer_texture = last_framebuffer_texture_;
-
-  if (last_framebuffer_texture_ == 0) {
-    framebuffer_texture =
-        active_framebuffer_ ? active_framebuffer_->color_targets[0] : 0;
-  }
-
-  // Copy the the given framebuffer to the current backbuffer.
-  Rect2D src_rect(0, 0, frontbuffer_width ? frontbuffer_width : 1280,
-                  frontbuffer_height ? frontbuffer_height : 720);
-  Rect2D dest_rect(0, 0, swap_state_.width, swap_state_.height);
-  if (framebuffer_texture != 0) {
-    reinterpret_cast<xe::ui::gl::GLContext*>(context_.get())
-        ->blitter()
-        ->CopyColorTexture2D(
-            framebuffer_texture, src_rect,
-            static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect,
-            GL_LINEAR, true);
-  }
-
-  if (FLAGS_draw_all_framebuffers) {
-    int32_t offsetx = (1280 - (1280 / 5));
-    int32_t offsety = 0;
-    int32_t doffsetx = 0;
-    for (int i = 0; i < cached_framebuffers_.size(); i++) {
-      bool has_colortargets = false;
-
-      // Copy color targets to top right corner
-      for (int j = 0; j < 4; j++) {
-        GLuint tex = cached_framebuffers_[i].color_targets[j];
-        if (!tex) {
-          continue;
-        }
-        has_colortargets = true;
-
-        dest_rect = {offsetx, offsety, 1280 / 5, 720 / 5};
-        reinterpret_cast<ui::gl::GLContext*>(context_.get())
-            ->blitter()
-            ->CopyColorTexture2D(
-                tex, src_rect,
-                static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect,
-                GL_LINEAR, true);
-
-        offsety += 720 / 5;
-      }
-
-      if (has_colortargets) {
-        offsetx -= 1280 / 5;
-      }
-
-      offsety = 0;
-
-      GLuint tex = cached_framebuffers_[i].depth_target;
-      if (!tex) {
-        continue;
-      }
-
-      // Copy depth targets to bottom left corner of screen
-      dest_rect = {doffsetx, (int32_t)swap_state_.height - (720 / 5), 1280 / 5,
-                   720 / 5};
-      reinterpret_cast<ui::gl::GLContext*>(context_.get())
-          ->blitter()
-          ->CopyColorTexture2D(
-              tex, src_rect,
-              static_cast<GLuint>(swap_state_.back_buffer_texture), dest_rect,
-              GL_LINEAR, false);
-
-      doffsetx += 1280 / 5;
-    }
-  }
-
-  // Need to finish to be sure the other context sees the right data.
-  // TODO(benvanik): prevent this? fences?
-  glFinish();
-
-  if (context_->WasLost()) {
-    // We've lost the context due to a TDR.
-    // TODO: Dump the current commands to a tracefile.
-    assert_always();
-  }
-
-  // Remove any dead textures, etc.
-  texture_cache_.Scavenge();
-}
-
-Shader* GL4CommandProcessor::LoadShader(ShaderType shader_type,
-                                        uint32_t guest_address,
-                                        const uint32_t* host_address,
-                                        uint32_t dword_count) {
-  return shader_cache_.LookupOrInsertShader(shader_type, host_address,
-                                            dword_count);
-}
-
-bool GL4CommandProcessor::IssueDraw(PrimitiveType prim_type,
-                                    uint32_t index_count,
-                                    IndexBufferInfo* index_buffer_info) {
-#if FINE_GRAINED_DRAW_SCOPES
-  SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-  bool draw_valid;
-  if (index_buffer_info) {
-    draw_valid = draw_batcher_.BeginDrawElements(prim_type, index_count,
-                                                 index_buffer_info->format);
-  } else {
-    draw_valid = draw_batcher_.BeginDrawArrays(prim_type, index_count);
-  }
-  if (!draw_valid) {
-    return false;
-  }
-
-  auto& regs = *register_file_;
-
-  auto enable_mode =
-      static_cast<ModeControl>(regs[XE_GPU_REG_RB_MODECONTROL].u32 & 0x7);
-  if (enable_mode == ModeControl::kIgnore) {
-    // Ignored.
-    draw_batcher_.DiscardDraw();
-    return true;
-  } else if (enable_mode == ModeControl::kCopy) {
-    // Special copy handling.
-    draw_batcher_.DiscardDraw();
-    return IssueCopy();
-  }
-
-#define CHECK_ISSUE_UPDATE_STATUS(status, mismatch, error_message) \
-  {                                                                \
-    if (status == UpdateStatus::kError) {                          \
-      XELOGE(error_message);                                       \
-      draw_batcher_.DiscardDraw();                                 \
-      return false;                                                \
-    } else if (status == UpdateStatus::kMismatch) {                \
-      mismatch = true;                                             \
-    }                                                              \
-  }
-
-  UpdateStatus status;
-  bool mismatch = false;
-  status = UpdateShaders(draw_batcher_.prim_type());
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to prepare draw shaders");
-  status = UpdateRenderTargets();
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup render targets");
-  if (!active_framebuffer_) {
-    // No framebuffer, so nothing we do will actually have an effect.
-    // Treat it as a no-op.
-    // TODO(benvanik): if we have a vs export, still allow it to go.
-    draw_batcher_.DiscardDraw();
-    return true;
-  }
-
-  status = UpdateState(draw_batcher_.prim_type());
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup render state");
-  status = PopulateSamplers();
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch,
-                            "Unable to prepare draw samplers");
-
-  status = PopulateIndexBuffer(index_buffer_info);
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup index buffer");
-  status = PopulateVertexBuffers();
-  CHECK_ISSUE_UPDATE_STATUS(status, mismatch, "Unable to setup vertex buffers");
-
-  if (!draw_batcher_.CommitDraw()) {
-    return false;
-  }
-
-  // TODO(benvanik): find a way to get around glVertexArrayVertexBuffer below.
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kMakeCoherent);
-  if (context_->WasLost()) {
-    // This draw lost us the context. This typically isn't hit.
-    assert_always();
-    return false;
-  }
-
-  return true;
-}
-
-bool GL4CommandProcessor::SetShadowRegister(uint32_t* dest,
-                                            uint32_t register_name) {
-  uint32_t value = register_file_->values[register_name].u32;
-  if (*dest == value) {
-    return false;
-  }
-  *dest = value;
-  return true;
-}
-
-bool GL4CommandProcessor::SetShadowRegister(float* dest,
-                                            uint32_t register_name) {
-  float value = register_file_->values[register_name].f32;
-  if (*dest == value) {
-    return false;
-  }
-  *dest = value;
-  return true;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateShaders(
-    PrimitiveType prim_type) {
-  auto& regs = update_shaders_regs_;
-
-  // These are the constant base addresses/ranges for shaders.
-  // We have these hardcoded right now cause nothing seems to differ.
-  assert_true(register_file_->values[XE_GPU_REG_SQ_VS_CONST].u32 ==
-                  0x000FF000 ||
-              register_file_->values[XE_GPU_REG_SQ_VS_CONST].u32 == 0x00000000);
-  assert_true(register_file_->values[XE_GPU_REG_SQ_PS_CONST].u32 ==
-                  0x000FF100 ||
-              register_file_->values[XE_GPU_REG_SQ_PS_CONST].u32 == 0x00000000);
-
-  bool dirty = false;
-  dirty |= SetShadowRegister(&regs.pa_su_sc_mode_cntl,
-                             XE_GPU_REG_PA_SU_SC_MODE_CNTL);
-  dirty |= SetShadowRegister(&regs.sq_program_cntl, XE_GPU_REG_SQ_PROGRAM_CNTL);
-  dirty |= SetShadowRegister(&regs.sq_context_misc, XE_GPU_REG_SQ_CONTEXT_MISC);
-  dirty |= regs.vertex_shader != active_vertex_shader_;
-  dirty |= regs.pixel_shader != active_pixel_shader_;
-  dirty |= regs.prim_type != prim_type;
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-  regs.vertex_shader = static_cast<GL4Shader*>(active_vertex_shader_);
-  regs.pixel_shader = static_cast<GL4Shader*>(active_pixel_shader_);
-  regs.prim_type = prim_type;
-
-  SCOPE_profile_cpu_f("gpu");
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  xe_gpu_program_cntl_t program_cntl;
-  program_cntl.dword_0 = regs.sq_program_cntl;
-
-  // Populate a register in the pixel shader with frag coord.
-  int ps_param_gen = (regs.sq_context_misc >> 8) & 0xFF;
-  draw_batcher_.set_ps_param_gen(program_cntl.param_gen ? ps_param_gen : -1);
-
-  // Normal vertex shaders only, for now.
-  // TODO(benvanik): transform feedback/memexport.
-  // https://github.com/freedreno/freedreno/blob/master/includes/a2xx.xml.h
-  // 0 = normal
-  // 2 = point size
-  assert_true(program_cntl.vs_export_mode == 0 ||
-              program_cntl.vs_export_mode == 2);
-
-  if (!regs.vertex_shader->is_valid()) {
-    XELOGE("Vertex shader invalid");
-    return UpdateStatus::kError;
-  }
-  if (!regs.pixel_shader->is_valid()) {
-    XELOGE("Pixel shader invalid");
-    return UpdateStatus::kError;
-  }
-
-  GLuint vertex_program = regs.vertex_shader->program();
-  GLuint fragment_program = regs.pixel_shader->program();
-
-  uint64_t key = (uint64_t(vertex_program) << 32) | fragment_program;
-  CachedPipeline* cached_pipeline = nullptr;
-  auto it = cached_pipelines_.find(key);
-  if (it == cached_pipelines_.end()) {
-    // Existing pipeline for these programs not found - create it.
-    auto new_pipeline = std::make_unique<CachedPipeline>();
-    new_pipeline->vertex_program = vertex_program;
-    new_pipeline->fragment_program = fragment_program;
-    new_pipeline->handles.default_pipeline = 0;
-    cached_pipeline = new_pipeline.get();
-    all_pipelines_.emplace_back(std::move(new_pipeline));
-    cached_pipelines_.insert({key, cached_pipeline});
-  } else {
-    // Found a pipeline container - it may or may not have what we want.
-    cached_pipeline = it->second;
-  }
-  if (!cached_pipeline->handles.default_pipeline) {
-    // Perhaps it's a bit wasteful to do all of these, but oh well.
-    GLuint pipelines[5];
-    glCreateProgramPipelines(GLsizei(xe::countof(pipelines)), pipelines);
-
-    glUseProgramStages(pipelines[0], GL_VERTEX_SHADER_BIT, vertex_program);
-    glUseProgramStages(pipelines[0], GL_FRAGMENT_SHADER_BIT, fragment_program);
-    cached_pipeline->handles.default_pipeline = pipelines[0];
-
-    glUseProgramStages(pipelines[1], GL_VERTEX_SHADER_BIT, vertex_program);
-    glUseProgramStages(pipelines[1], GL_GEOMETRY_SHADER_BIT,
-                       point_list_geometry_program_);
-    glUseProgramStages(pipelines[1], GL_FRAGMENT_SHADER_BIT, fragment_program);
-    cached_pipeline->handles.point_list_pipeline = pipelines[1];
-
-    glUseProgramStages(pipelines[2], GL_VERTEX_SHADER_BIT, vertex_program);
-    glUseProgramStages(pipelines[2], GL_GEOMETRY_SHADER_BIT,
-                       rect_list_geometry_program_);
-    glUseProgramStages(pipelines[2], GL_FRAGMENT_SHADER_BIT, fragment_program);
-    cached_pipeline->handles.rect_list_pipeline = pipelines[2];
-
-    glUseProgramStages(pipelines[3], GL_VERTEX_SHADER_BIT, vertex_program);
-    glUseProgramStages(pipelines[3], GL_GEOMETRY_SHADER_BIT,
-                       quad_list_geometry_program_);
-    glUseProgramStages(pipelines[3], GL_FRAGMENT_SHADER_BIT, fragment_program);
-    cached_pipeline->handles.quad_list_pipeline = pipelines[3];
-
-    glUseProgramStages(pipelines[4], GL_VERTEX_SHADER_BIT, vertex_program);
-    glUseProgramStages(pipelines[4], GL_GEOMETRY_SHADER_BIT,
-                       line_quad_list_geometry_program_);
-    glUseProgramStages(pipelines[4], GL_FRAGMENT_SHADER_BIT, fragment_program);
-    cached_pipeline->handles.line_quad_list_pipeline = pipelines[4];
-
-    // This can be set once, as the buffer never changes.
-    glVertexArrayElementBuffer(regs.vertex_shader->vao(),
-                               scratch_buffer_.handle());
-  }
-
-  bool line_mode = false;
-  if (((regs.pa_su_sc_mode_cntl >> 3) & 0x3) != 0) {
-    uint32_t front_poly_mode = (regs.pa_su_sc_mode_cntl >> 5) & 0x7;
-    if (front_poly_mode == 1) {
-      line_mode = true;
-    }
-  }
-
-  GLuint pipeline;
-  switch (regs.prim_type) {
-    default:
-      // Default pipeline used.
-      pipeline = cached_pipeline->handles.default_pipeline;
-      break;
-    case PrimitiveType::kPointList:
-      pipeline = cached_pipeline->handles.point_list_pipeline;
-      break;
-    case PrimitiveType::kRectangleList:
-      pipeline = cached_pipeline->handles.rect_list_pipeline;
-      break;
-    case PrimitiveType::kQuadList: {
-      if (line_mode) {
-        pipeline = cached_pipeline->handles.line_quad_list_pipeline;
-      } else {
-        pipeline = cached_pipeline->handles.quad_list_pipeline;
-      }
-      break;
-    }
-  }
-
-  draw_batcher_.ReconfigurePipeline(regs.vertex_shader, regs.pixel_shader,
-                                    pipeline);
-
-  glBindProgramPipeline(pipeline);
-  glBindVertexArray(regs.vertex_shader->vao());
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateRenderTargets() {
-  auto& regs = update_render_targets_regs_;
-
-  bool dirty = false;
-  dirty |= SetShadowRegister(&regs.rb_modecontrol, XE_GPU_REG_RB_MODECONTROL);
-  dirty |= SetShadowRegister(&regs.rb_surface_info, XE_GPU_REG_RB_SURFACE_INFO);
-  dirty |= SetShadowRegister(&regs.rb_color_info, XE_GPU_REG_RB_COLOR_INFO);
-  dirty |= SetShadowRegister(&regs.rb_color1_info, XE_GPU_REG_RB_COLOR1_INFO);
-  dirty |= SetShadowRegister(&regs.rb_color2_info, XE_GPU_REG_RB_COLOR2_INFO);
-  dirty |= SetShadowRegister(&regs.rb_color3_info, XE_GPU_REG_RB_COLOR3_INFO);
-  dirty |= SetShadowRegister(&regs.rb_color_mask, XE_GPU_REG_RB_COLOR_MASK);
-  dirty |= SetShadowRegister(&regs.rb_depthcontrol, XE_GPU_REG_RB_DEPTHCONTROL);
-  dirty |=
-      SetShadowRegister(&regs.rb_stencilrefmask, XE_GPU_REG_RB_STENCILREFMASK);
-  dirty |= SetShadowRegister(&regs.rb_depth_info, XE_GPU_REG_RB_DEPTH_INFO);
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-
-  SCOPE_profile_cpu_f("gpu");
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  auto enable_mode = static_cast<ModeControl>(regs.rb_modecontrol & 0x7);
-
-  // RB_SURFACE_INFO
-  // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
-  uint32_t surface_pitch = regs.rb_surface_info & 0x3FFF;
-  auto surface_msaa =
-      static_cast<MsaaSamples>((regs.rb_surface_info >> 16) & 0x3);
-
-  // Get/create all color render targets, if we are using them.
-  // In depth-only mode we don't need them.
-  // Note that write mask may be more permissive than we want, so we mix that
-  // with the actual targets the pixel shader writes to.
-  GLenum draw_buffers[4] = {GL_NONE, GL_NONE, GL_NONE, GL_NONE};
-  GLuint color_targets[4] = {kAnyTarget, kAnyTarget, kAnyTarget, kAnyTarget};
-  if (enable_mode == ModeControl::kColorDepth) {
-    uint32_t color_info[4] = {
-        regs.rb_color_info,
-        regs.rb_color1_info,
-        regs.rb_color2_info,
-        regs.rb_color3_info,
-    };
-    // A2XX_RB_COLOR_MASK_WRITE_* == D3DRS_COLORWRITEENABLE
-    for (int n = 0; n < xe::countof(color_info); n++) {
-      uint32_t write_mask = (regs.rb_color_mask >> (n * 4)) & 0xF;
-      if (!write_mask || !active_pixel_shader_->writes_color_target(n)) {
-        // Unused, so keep disabled and set to wildcard so we'll take any
-        // framebuffer that has it.
-        continue;
-      }
-      uint32_t color_base = color_info[n] & 0xFFF;
-      auto color_format =
-          static_cast<ColorRenderTargetFormat>((color_info[n] >> 16) & 0xF);
-      color_targets[n] = GetColorRenderTarget(surface_pitch, surface_msaa,
-                                              color_base, color_format);
-      draw_buffers[n] = GL_COLOR_ATTACHMENT0 + n;
-      glColorMaski(n, !!(write_mask & 0x1), !!(write_mask & 0x2),
-                   !!(write_mask & 0x4), !!(write_mask & 0x8));
-    }
-  }
-
-  // Get/create depth buffer, but only if we are going to use it.
-  bool uses_depth = (regs.rb_depthcontrol & 0x00000002) ||
-                    (regs.rb_depthcontrol & 0x00000004);
-  uint32_t stencil_write_mask = (regs.rb_stencilrefmask & 0x00FF0000) >> 16;
-  bool uses_stencil =
-      (regs.rb_depthcontrol & 0x00000001) || (stencil_write_mask != 0);
-  GLuint depth_target = kAnyTarget;
-  if (uses_depth || uses_stencil) {
-    uint32_t depth_base = regs.rb_depth_info & 0xFFF;
-    auto depth_format =
-        static_cast<DepthRenderTargetFormat>((regs.rb_depth_info >> 16) & 0x1);
-    depth_target = GetDepthRenderTarget(surface_pitch, surface_msaa, depth_base,
-                                        depth_format);
-    // TODO(benvanik): when a game switches does it expect to keep the same
-    //     depth buffer contents?
-  }
-
-  // Get/create a framebuffer with the required targets.
-  // Note that none may be returned if we really don't need one.
-  auto cached_framebuffer = GetFramebuffer(color_targets, depth_target);
-  active_framebuffer_ = cached_framebuffer;
-  if (active_framebuffer_) {
-    // Setup just the targets we want.
-    glNamedFramebufferDrawBuffers(cached_framebuffer->framebuffer, 4,
-                                  draw_buffers);
-
-    // Make active.
-    // TODO(benvanik): can we do this all named?
-    // TODO(benvanik): do we want this on READ too?
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, cached_framebuffer->framebuffer);
-  }
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateState(
-    PrimitiveType prim_type) {
-  bool mismatch = false;
-
-#define CHECK_UPDATE_STATUS(status, mismatch, error_message) \
-  {                                                          \
-    if (status == UpdateStatus::kError) {                    \
-      XELOGE(error_message);                                 \
-      return status;                                         \
-    } else if (status == UpdateStatus::kMismatch) {          \
-      mismatch = true;                                       \
-    }                                                        \
-  }
-
-  UpdateStatus status;
-  status = UpdateViewportState();
-  CHECK_UPDATE_STATUS(status, mismatch, "Unable to update viewport state");
-  status = UpdateRasterizerState(prim_type);
-  CHECK_UPDATE_STATUS(status, mismatch, "Unable to update rasterizer state");
-  status = UpdateBlendState();
-  CHECK_UPDATE_STATUS(status, mismatch, "Unable to update blend state");
-  status = UpdateDepthStencilState();
-  CHECK_UPDATE_STATUS(status, mismatch, "Unable to update depth/stencil state");
-
-  return mismatch ? UpdateStatus::kMismatch : UpdateStatus::kCompatible;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateViewportState() {
-  auto& regs = update_viewport_state_regs_;
-
-  bool dirty = false;
-  // dirty |= SetShadowRegister(&state_regs.pa_cl_clip_cntl,
-  //     XE_GPU_REG_PA_CL_CLIP_CNTL);
-  dirty |= SetShadowRegister(&regs.rb_surface_info, XE_GPU_REG_RB_SURFACE_INFO);
-  dirty |= SetShadowRegister(&regs.pa_cl_vte_cntl, XE_GPU_REG_PA_CL_VTE_CNTL);
-  dirty |= SetShadowRegister(&regs.pa_su_sc_mode_cntl,
-                             XE_GPU_REG_PA_SU_SC_MODE_CNTL);
-  dirty |= SetShadowRegister(&regs.pa_sc_window_offset,
-                             XE_GPU_REG_PA_SC_WINDOW_OFFSET);
-  dirty |= SetShadowRegister(&regs.pa_sc_window_scissor_tl,
-                             XE_GPU_REG_PA_SC_WINDOW_SCISSOR_TL);
-  dirty |= SetShadowRegister(&regs.pa_sc_window_scissor_br,
-                             XE_GPU_REG_PA_SC_WINDOW_SCISSOR_BR);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_xoffset,
-                             XE_GPU_REG_PA_CL_VPORT_XOFFSET);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_yoffset,
-                             XE_GPU_REG_PA_CL_VPORT_YOFFSET);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_zoffset,
-                             XE_GPU_REG_PA_CL_VPORT_ZOFFSET);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_xscale,
-                             XE_GPU_REG_PA_CL_VPORT_XSCALE);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_yscale,
-                             XE_GPU_REG_PA_CL_VPORT_YSCALE);
-  dirty |= SetShadowRegister(&regs.pa_cl_vport_zscale,
-                             XE_GPU_REG_PA_CL_VPORT_ZSCALE);
-
-  // Much of this state machine is extracted from:
-  // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c
-  // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
-  // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
-
-  // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
-  // VTX_XY_FMT = true: the incoming X, Y have already been multiplied by 1/W0.
-  //            = false: multiply the X, Y coordinates by 1/W0.
-  // VTX_Z_FMT = true: the incoming Z has already been multiplied by 1/W0.
-  //           = false: multiply the Z coordinate by 1/W0.
-  // VTX_W0_FMT = true: the incoming W0 is not 1/W0. Perform the reciprocal to
-  //                    get 1/W0.
-  draw_batcher_.set_vtx_fmt((regs.pa_cl_vte_cntl >> 8) & 0x1 ? 1.0f : 0.0f,
-                            (regs.pa_cl_vte_cntl >> 9) & 0x1 ? 1.0f : 0.0f,
-                            (regs.pa_cl_vte_cntl >> 10) & 0x1 ? 1.0f : 0.0f);
-
-  // Done in VS, no need to flush state.
-  if ((regs.pa_cl_vte_cntl & (1 << 0)) > 0) {
-    draw_batcher_.set_window_scalar(1.0f, 1.0f);
-  } else {
-    draw_batcher_.set_window_scalar(1.0f / 2560.0f, -1.0f / 2560.0f);
-  }
-
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  // Clipping.
-  // https://github.com/freedreno/amd-gpu/blob/master/include/reg/yamato/14/yamato_genenum.h#L1587
-  // bool clip_enabled = ((regs.pa_cl_clip_cntl >> 17) & 0x1) == 0;
-  // bool dx_clip = ((regs.pa_cl_clip_cntl >> 19) & 0x1) == 0x1;
-  //// TODO(benvanik): depth range?
-  // if (dx_clip) {
-  //  glClipControl(GL_UPPER_LEFT, GL_ZERO_TO_ONE);
-  //} else {
-  //  glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE);
-  //}
-
-  // Window parameters.
-  // http://ftp.tku.edu.tw/NetBSD/NetBSD-current/xsrc/external/mit/xf86-video-ati/dist/src/r600_reg_auto_r6xx.h
-  // See r200UpdateWindow:
-  // https://github.com/freedreno/mesa/blob/master/src/mesa/drivers/dri/r200/r200_state.c
-  int16_t window_offset_x = 0;
-  int16_t window_offset_y = 0;
-  if ((regs.pa_su_sc_mode_cntl >> 16) & 1) {
-    window_offset_x = regs.pa_sc_window_offset & 0x7FFF;
-    window_offset_y = (regs.pa_sc_window_offset >> 16) & 0x7FFF;
-    if (window_offset_x & 0x4000) {
-      window_offset_x |= 0x8000;
-    }
-    if (window_offset_y & 0x4000) {
-      window_offset_y |= 0x8000;
-    }
-  }
-
-  GLint ws_x = regs.pa_sc_window_scissor_tl & 0x7FFF;
-  GLint ws_y = (regs.pa_sc_window_scissor_tl >> 16) & 0x7FFF;
-  GLsizei ws_w = (regs.pa_sc_window_scissor_br & 0x7FFF) - ws_x;
-  GLsizei ws_h = ((regs.pa_sc_window_scissor_br >> 16) & 0x7FFF) - ws_y;
-  ws_x += window_offset_x;
-  ws_y += window_offset_y;
-  glScissorIndexed(0, ws_x, ws_y, ws_w, ws_h);
-
-  // HACK: no clue where to get these values.
-  // RB_SURFACE_INFO
-  auto surface_msaa =
-      static_cast<MsaaSamples>((regs.rb_surface_info >> 16) & 0x3);
-  // TODO(benvanik): ??
-  float window_width_scalar = 1;
-  float window_height_scalar = 1;
-  switch (surface_msaa) {
-    case MsaaSamples::k1X:
-      break;
-    case MsaaSamples::k2X:
-      window_width_scalar = 2;
-      break;
-    case MsaaSamples::k4X:
-      window_width_scalar = 2;
-      window_height_scalar = 2;
-      break;
-  }
-
-  // Whether each of the viewport settings are enabled.
-  // http://www.x.org/docs/AMD/old/evergreen_3D_registers_v2.pdf
-  bool vport_xscale_enable = (regs.pa_cl_vte_cntl & (1 << 0)) > 0;
-  bool vport_xoffset_enable = (regs.pa_cl_vte_cntl & (1 << 1)) > 0;
-  bool vport_yscale_enable = (regs.pa_cl_vte_cntl & (1 << 2)) > 0;
-  bool vport_yoffset_enable = (regs.pa_cl_vte_cntl & (1 << 3)) > 0;
-  bool vport_zscale_enable = (regs.pa_cl_vte_cntl & (1 << 4)) > 0;
-  bool vport_zoffset_enable = (regs.pa_cl_vte_cntl & (1 << 5)) > 0;
-  assert_true(vport_xscale_enable == vport_yscale_enable ==
-              vport_zscale_enable == vport_xoffset_enable ==
-              vport_yoffset_enable == vport_zoffset_enable);
-
-  if (vport_xscale_enable) {
-    float texel_offset_x = 0.0f;
-    float texel_offset_y = 0.0f;
-    float vox = vport_xoffset_enable ? regs.pa_cl_vport_xoffset : 0;
-    float voy = vport_yoffset_enable ? regs.pa_cl_vport_yoffset : 0;
-    float vsx = vport_xscale_enable ? regs.pa_cl_vport_xscale : 1;
-    float vsy = vport_yscale_enable ? regs.pa_cl_vport_yscale : 1;
-    window_width_scalar = window_height_scalar = 1;
-    float vpw = 2 * window_width_scalar * vsx;
-    float vph = -2 * window_height_scalar * vsy;
-    float vpx = window_width_scalar * vox - vpw / 2 + window_offset_x;
-    float vpy = window_height_scalar * voy - vph / 2 + window_offset_y;
-    glViewportIndexedf(0, vpx + texel_offset_x, vpy + texel_offset_y, vpw, vph);
-
-    // TODO(benvanik): depth range adjustment?
-    // float voz = vport_zoffset_enable ? regs.pa_cl_vport_zoffset : 0;
-    // float vsz = vport_zscale_enable ? regs.pa_cl_vport_zscale : 1;
-  } else {
-    float texel_offset_x = 0.0f;
-    float texel_offset_y = 0.0f;
-    float vpw = 2 * 2560.0f * window_width_scalar;
-    float vph = 2 * 2560.0f * window_height_scalar;
-    float vpx = -2560.0f * window_width_scalar + window_offset_x;
-    float vpy = -2560.0f * window_height_scalar + window_offset_y;
-    glViewportIndexedf(0, vpx + texel_offset_x, vpy + texel_offset_y, vpw, vph);
-  }
-  float voz = vport_zoffset_enable ? regs.pa_cl_vport_zoffset : 0;
-  float vsz = vport_zscale_enable ? regs.pa_cl_vport_zscale : 1;
-  glDepthRangef(voz, voz + vsz);
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateRasterizerState(
-    PrimitiveType prim_type) {
-  auto& regs = update_rasterizer_state_regs_;
-
-  bool dirty = false;
-  dirty |= SetShadowRegister(&regs.pa_su_sc_mode_cntl,
-                             XE_GPU_REG_PA_SU_SC_MODE_CNTL);
-  dirty |= SetShadowRegister(&regs.pa_sc_screen_scissor_tl,
-                             XE_GPU_REG_PA_SC_SCREEN_SCISSOR_TL);
-  dirty |= SetShadowRegister(&regs.pa_sc_screen_scissor_br,
-                             XE_GPU_REG_PA_SC_SCREEN_SCISSOR_BR);
-  dirty |= SetShadowRegister(&regs.multi_prim_ib_reset_index,
-                             XE_GPU_REG_VGT_MULTI_PRIM_IB_RESET_INDX);
-  dirty |= SetShadowRegister(&regs.pa_sc_viz_query, XE_GPU_REG_PA_SC_VIZ_QUERY);
-  dirty |= regs.prim_type != prim_type;
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-
-  regs.prim_type = prim_type;
-
-  SCOPE_profile_cpu_f("gpu");
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  // viz query enabled
-  // assert_zero(regs.pa_sc_viz_query & 0x01);
-
-  // Kill pix post early-z test
-  // assert_zero(regs.pa_sc_viz_query & 0x80);
-
-  // Scissoring.
-  // TODO(benvanik): is this used? we are using scissoring for window scissor.
-  if (regs.pa_sc_screen_scissor_tl != 0 &&
-      regs.pa_sc_screen_scissor_br != 0x20002000) {
-    assert_always();
-    // glEnable(GL_SCISSOR_TEST);
-    // TODO(benvanik): signed?
-    int32_t screen_scissor_x = regs.pa_sc_screen_scissor_tl & 0x7FFF;
-    int32_t screen_scissor_y = (regs.pa_sc_screen_scissor_tl >> 16) & 0x7FFF;
-    int32_t screen_scissor_w =
-        regs.pa_sc_screen_scissor_br & 0x7FFF - screen_scissor_x;
-    int32_t screen_scissor_h =
-        (regs.pa_sc_screen_scissor_br >> 16) & 0x7FFF - screen_scissor_y;
-    glScissor(screen_scissor_x, screen_scissor_y, screen_scissor_w,
-              screen_scissor_h);
-  } else {
-    // glDisable(GL_SCISSOR_TEST);
-  }
-
-  switch (regs.pa_su_sc_mode_cntl & 0x3) {
-    case 0:
-      glDisable(GL_CULL_FACE);
-      break;
-    case 1:
-      glEnable(GL_CULL_FACE);
-      glCullFace(GL_FRONT);
-      break;
-    case 2:
-      glEnable(GL_CULL_FACE);
-      glCullFace(GL_BACK);
-      break;
-  }
-  if (regs.pa_su_sc_mode_cntl & 0x4) {
-    glFrontFace(GL_CW);
-  } else {
-    glFrontFace(GL_CCW);
-  }
-
-  if (prim_type == PrimitiveType::kRectangleList) {
-    // Rectangle lists aren't culled. There may be other things they skip too.
-    glDisable(GL_CULL_FACE);
-  }
-
-  static const GLenum kFillModes[3] = {
-      GL_POINT,
-      GL_LINE,
-      GL_FILL,
-  };
-  bool poly_mode = ((regs.pa_su_sc_mode_cntl >> 3) & 0x3) != 0;
-  if (poly_mode) {
-    uint32_t front_poly_mode = (regs.pa_su_sc_mode_cntl >> 5) & 0x7;
-    uint32_t back_poly_mode = (regs.pa_su_sc_mode_cntl >> 8) & 0x7;
-    // GL only supports both matching.
-    assert_true(front_poly_mode == back_poly_mode);
-    glPolygonMode(GL_FRONT_AND_BACK, kFillModes[front_poly_mode]);
-  } else {
-    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-  }
-
-  if (regs.pa_su_sc_mode_cntl & (1 << 19)) {
-    glProvokingVertex(GL_LAST_VERTEX_CONVENTION);
-  } else {
-    glProvokingVertex(GL_FIRST_VERTEX_CONVENTION);
-  }
-
-  if (regs.pa_su_sc_mode_cntl & (1 << 21)) {
-    glEnable(GL_PRIMITIVE_RESTART);
-  } else {
-    glDisable(GL_PRIMITIVE_RESTART);
-  }
-  glPrimitiveRestartIndex(regs.multi_prim_ib_reset_index);
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::UpdateBlendState() {
-  auto& reg_file = *register_file_;
-  auto& regs = update_blend_state_regs_;
-
-  // Alpha testing -- ALPHAREF, ALPHAFUNC, ALPHATESTENABLE
-  // Deprecated in GL, implemented in shader.
-  // if(ALPHATESTENABLE && frag_out.a [<=/ALPHAFUNC] ALPHAREF) discard;
-  uint32_t color_control = reg_file[XE_GPU_REG_RB_COLORCONTROL].u32;
-  draw_batcher_.set_alpha_test((color_control & 0x8) != 0,  // ALPAHTESTENABLE
-                               color_control & 0x7,         // ALPHAFUNC
-                               reg_file[XE_GPU_REG_RB_ALPHA_REF].f32);
-
-  bool dirty = false;
-  dirty |=
-      SetShadowRegister(&regs.rb_blendcontrol[0], XE_GPU_REG_RB_BLENDCONTROL_0);
-  dirty |=
-      SetShadowRegister(&regs.rb_blendcontrol[1], XE_GPU_REG_RB_BLENDCONTROL_1);
-  dirty |=
-      SetShadowRegister(&regs.rb_blendcontrol[2], XE_GPU_REG_RB_BLENDCONTROL_2);
-  dirty |=
-      SetShadowRegister(&regs.rb_blendcontrol[3], XE_GPU_REG_RB_BLENDCONTROL_3);
-  dirty |= SetShadowRegister(&regs.rb_blend_rgba[0], XE_GPU_REG_RB_BLEND_RED);
-  dirty |= SetShadowRegister(&regs.rb_blend_rgba[1], XE_GPU_REG_RB_BLEND_GREEN);
-  dirty |= SetShadowRegister(&regs.rb_blend_rgba[2], XE_GPU_REG_RB_BLEND_BLUE);
-  dirty |= SetShadowRegister(&regs.rb_blend_rgba[3], XE_GPU_REG_RB_BLEND_ALPHA);
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-
-  SCOPE_profile_cpu_f("gpu");
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  static const GLenum blend_map[] = {
-      /*  0 */ GL_ZERO,
-      /*  1 */ GL_ONE,
-      /*  2 */ GL_ZERO,  // ?
-      /*  3 */ GL_ZERO,  // ?
-      /*  4 */ GL_SRC_COLOR,
-      /*  5 */ GL_ONE_MINUS_SRC_COLOR,
-      /*  6 */ GL_SRC_ALPHA,
-      /*  7 */ GL_ONE_MINUS_SRC_ALPHA,
-      /*  8 */ GL_DST_COLOR,
-      /*  9 */ GL_ONE_MINUS_DST_COLOR,
-      /* 10 */ GL_DST_ALPHA,
-      /* 11 */ GL_ONE_MINUS_DST_ALPHA,
-      /* 12 */ GL_CONSTANT_COLOR,
-      /* 13 */ GL_ONE_MINUS_CONSTANT_COLOR,
-      /* 14 */ GL_CONSTANT_ALPHA,
-      /* 15 */ GL_ONE_MINUS_CONSTANT_ALPHA,
-      /* 16 */ GL_SRC_ALPHA_SATURATE,
-  };
-  static const GLenum blend_op_map[] = {
-      /*  0 */ GL_FUNC_ADD,
-      /*  1 */ GL_FUNC_SUBTRACT,
-      /*  2 */ GL_MIN,
-      /*  3 */ GL_MAX,
-      /*  4 */ GL_FUNC_REVERSE_SUBTRACT,
-  };
-  for (int i = 0; i < xe::countof(regs.rb_blendcontrol); ++i) {
-    uint32_t blend_control = regs.rb_blendcontrol[i];
-    // A2XX_RB_BLEND_CONTROL_COLOR_SRCBLEND
-    auto src_blend = blend_map[(blend_control & 0x0000001F) >> 0];
-    // A2XX_RB_BLEND_CONTROL_COLOR_DESTBLEND
-    auto dest_blend = blend_map[(blend_control & 0x00001F00) >> 8];
-    // A2XX_RB_BLEND_CONTROL_COLOR_COMB_FCN
-    auto blend_op = blend_op_map[(blend_control & 0x000000E0) >> 5];
-    // A2XX_RB_BLEND_CONTROL_ALPHA_SRCBLEND
-    auto src_blend_alpha = blend_map[(blend_control & 0x001F0000) >> 16];
-    // A2XX_RB_BLEND_CONTROL_ALPHA_DESTBLEND
-    auto dest_blend_alpha = blend_map[(blend_control & 0x1F000000) >> 24];
-    // A2XX_RB_BLEND_CONTROL_ALPHA_COMB_FCN
-    auto blend_op_alpha = blend_op_map[(blend_control & 0x00E00000) >> 21];
-    // A2XX_RB_COLORCONTROL_BLEND_DISABLE ?? Can't find this!
-    // Just guess based on actions.
-    // bool blend_enable =
-    //     !((src_blend == GL_ONE) && (dest_blend == GL_ZERO) &&
-    //       (blend_op == GL_FUNC_ADD) && (src_blend_alpha == GL_ONE) &&
-    //       (dest_blend_alpha == GL_ZERO) && (blend_op_alpha == GL_FUNC_ADD));
-    bool blend_enable = !(color_control & 0x20);
-    if (blend_enable) {
-      glEnablei(GL_BLEND, i);
-      glBlendEquationSeparatei(i, blend_op, blend_op_alpha);
-      glBlendFuncSeparatei(i, src_blend, dest_blend, src_blend_alpha,
-                           dest_blend_alpha);
-    } else {
-      glDisablei(GL_BLEND, i);
-    }
-  }
-
-  glBlendColor(regs.rb_blend_rgba[0], regs.rb_blend_rgba[1],
-               regs.rb_blend_rgba[2], regs.rb_blend_rgba[3]);
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus
-GL4CommandProcessor::UpdateDepthStencilState() {
-  auto& regs = update_depth_stencil_state_regs_;
-
-  bool dirty = false;
-  dirty |= SetShadowRegister(&regs.rb_depthcontrol, XE_GPU_REG_RB_DEPTHCONTROL);
-  dirty |=
-      SetShadowRegister(&regs.rb_stencilrefmask, XE_GPU_REG_RB_STENCILREFMASK);
-  if (!dirty) {
-    return UpdateStatus::kCompatible;
-  }
-
-  SCOPE_profile_cpu_f("gpu");
-
-  draw_batcher_.Flush(DrawBatcher::FlushMode::kStateChange);
-
-  static const GLenum compare_func_map[] = {
-      /*  0 */ GL_NEVER,
-      /*  1 */ GL_LESS,
-      /*  2 */ GL_EQUAL,
-      /*  3 */ GL_LEQUAL,
-      /*  4 */ GL_GREATER,
-      /*  5 */ GL_NOTEQUAL,
-      /*  6 */ GL_GEQUAL,
-      /*  7 */ GL_ALWAYS,
-  };
-  static const GLenum stencil_op_map[] = {
-      /*  0 */ GL_KEEP,
-      /*  1 */ GL_ZERO,
-      /*  2 */ GL_REPLACE,
-      /*  3 */ GL_INCR_WRAP,
-      /*  4 */ GL_DECR_WRAP,
-      /*  5 */ GL_INVERT,
-      /*  6 */ GL_INCR,
-      /*  7 */ GL_DECR,
-  };
-  // A2XX_RB_DEPTHCONTROL_Z_ENABLE
-  if (regs.rb_depthcontrol & 0x00000002) {
-    glEnable(GL_DEPTH_TEST);
-  } else {
-    glDisable(GL_DEPTH_TEST);
-  }
-  // glDisable(GL_DEPTH_TEST);
-  // A2XX_RB_DEPTHCONTROL_Z_WRITE_ENABLE
-  glDepthMask((regs.rb_depthcontrol & 0x00000004) ? GL_TRUE : GL_FALSE);
-  // A2XX_RB_DEPTHCONTROL_EARLY_Z_ENABLE
-  // ?
-  // A2XX_RB_DEPTHCONTROL_ZFUNC
-  glDepthFunc(compare_func_map[(regs.rb_depthcontrol & 0x00000070) >> 4]);
-  // A2XX_RB_DEPTHCONTROL_STENCIL_ENABLE
-  if (regs.rb_depthcontrol & 0x00000001) {
-    glEnable(GL_STENCIL_TEST);
-  } else {
-    glDisable(GL_STENCIL_TEST);
-  }
-  // RB_STENCILREFMASK_STENCILREF
-  uint32_t stencil_ref = (regs.rb_stencilrefmask & 0x000000FF);
-  // RB_STENCILREFMASK_STENCILMASK
-  uint32_t stencil_read_mask = (regs.rb_stencilrefmask & 0x0000FF00) >> 8;
-  // RB_STENCILREFMASK_STENCILWRITEMASK
-  glStencilMask((regs.rb_stencilrefmask & 0x00FF0000) >> 16);
-  // A2XX_RB_DEPTHCONTROL_BACKFACE_ENABLE
-  bool backface_enabled = (regs.rb_depthcontrol & 0x00000080) != 0;
-  if (backface_enabled) {
-    // A2XX_RB_DEPTHCONTROL_STENCILFUNC
-    glStencilFuncSeparate(
-        GL_FRONT, compare_func_map[(regs.rb_depthcontrol & 0x00000700) >> 8],
-        stencil_ref, stencil_read_mask);
-    // A2XX_RB_DEPTHCONTROL_STENCILFAIL
-    // A2XX_RB_DEPTHCONTROL_STENCILZFAIL
-    // A2XX_RB_DEPTHCONTROL_STENCILZPASS
-    glStencilOpSeparate(
-        GL_FRONT, stencil_op_map[(regs.rb_depthcontrol & 0x00003800) >> 11],
-        stencil_op_map[(regs.rb_depthcontrol & 0x000E0000) >> 17],
-        stencil_op_map[(regs.rb_depthcontrol & 0x0001C000) >> 14]);
-    // A2XX_RB_DEPTHCONTROL_STENCILFUNC_BF
-    glStencilFuncSeparate(
-        GL_BACK, compare_func_map[(regs.rb_depthcontrol & 0x00700000) >> 20],
-        stencil_ref, stencil_read_mask);
-    // A2XX_RB_DEPTHCONTROL_STENCILFAIL_BF
-    // A2XX_RB_DEPTHCONTROL_STENCILZFAIL_BF
-    // A2XX_RB_DEPTHCONTROL_STENCILZPASS_BF
-    glStencilOpSeparate(
-        GL_BACK, stencil_op_map[(regs.rb_depthcontrol & 0x03800000) >> 23],
-        stencil_op_map[(regs.rb_depthcontrol & 0xE0000000) >> 29],
-        stencil_op_map[(regs.rb_depthcontrol & 0x1C000000) >> 26]);
-  } else {
-    // Backfaces disabled - treat backfaces as frontfaces.
-    glStencilFunc(compare_func_map[(regs.rb_depthcontrol & 0x00000700) >> 8],
-                  stencil_ref, stencil_read_mask);
-    glStencilOp(stencil_op_map[(regs.rb_depthcontrol & 0x00003800) >> 11],
-                stencil_op_map[(regs.rb_depthcontrol & 0x000E0000) >> 17],
-                stencil_op_map[(regs.rb_depthcontrol & 0x0001C000) >> 14]);
-  }
-
-  return UpdateStatus::kMismatch;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateIndexBuffer(
-    IndexBufferInfo* index_buffer_info) {
-  auto& regs = *register_file_;
-  if (!index_buffer_info || !index_buffer_info->guest_base) {
-    // No index buffer or auto draw.
-    return UpdateStatus::kCompatible;
-  }
-  auto& info = *index_buffer_info;
-
-#if FINE_GRAINED_DRAW_SCOPES
-  SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-  // Min/max index ranges for clamping. This is often [0g,FFFF|FFFFFF].
-  // All indices should be clamped to [min,max]. May be a way to do this in GL.
-  uint32_t min_index = regs[XE_GPU_REG_VGT_MIN_VTX_INDX].u32;
-  uint32_t max_index = regs[XE_GPU_REG_VGT_MAX_VTX_INDX].u32;
-  assert_true(min_index == 0);
-  assert_true(max_index == 0xFFFF || max_index == 0xFFFFFF);
-
-  assert_true(info.endianness == Endian::k8in16 ||
-              info.endianness == Endian::k8in32);
-
-  trace_writer_.WriteMemoryRead(info.guest_base, info.length);
-
-  size_t total_size =
-      info.count * (info.format == IndexFormat::kInt32 ? sizeof(uint32_t)
-                                                       : sizeof(uint16_t));
-  CircularBuffer::Allocation allocation;
-  if (!scratch_buffer_.AcquireCached(info.guest_base, total_size,
-                                     &allocation)) {
-    if (info.format == IndexFormat::kInt32) {
-      auto dest = reinterpret_cast<uint32_t*>(allocation.host_ptr);
-      auto src = memory_->TranslatePhysical<const uint32_t*>(info.guest_base);
-      xe::copy_and_swap_32_aligned(dest, src, info.count);
-    } else {
-      auto dest = reinterpret_cast<uint16_t*>(allocation.host_ptr);
-      auto src = memory_->TranslatePhysical<const uint16_t*>(info.guest_base);
-      xe::copy_and_swap_16_aligned(dest, src, info.count);
-    }
-    draw_batcher_.set_index_buffer(allocation);
-    scratch_buffer_.Commit(std::move(allocation));
-  } else {
-    draw_batcher_.set_index_buffer(allocation);
-  }
-
-  return UpdateStatus::kCompatible;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateVertexBuffers() {
-#if FINE_GRAINED_DRAW_SCOPES
-  SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-  auto& regs = *register_file_;
-  assert_not_null(active_vertex_shader_);
-
-  for (const auto& vertex_binding : active_vertex_shader_->vertex_bindings()) {
-    int r = XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 +
-            (vertex_binding.fetch_constant / 3) * 6;
-    const auto group = reinterpret_cast<xe_gpu_fetch_group_t*>(&regs.values[r]);
-    const xe_gpu_vertex_fetch_t* fetch = nullptr;
-    switch (vertex_binding.fetch_constant % 3) {
-      case 0:
-        fetch = &group->vertex_fetch_0;
-        break;
-      case 1:
-        fetch = &group->vertex_fetch_1;
-        break;
-      case 2:
-        fetch = &group->vertex_fetch_2;
-        break;
-    }
-    assert_true(fetch->endian == 2);
-
-    size_t valid_range = size_t(fetch->size * 4);
-
-    trace_writer_.WriteMemoryRead(fetch->address << 2, valid_range);
-
-    auto vertex_shader = static_cast<GL4Shader*>(active_vertex_shader_);
-    CircularBuffer::Allocation allocation;
-    if (!scratch_buffer_.AcquireCached(fetch->address << 2, valid_range,
-                                       &allocation)) {
-      // Copy and byte swap the entire buffer.
-      // We could be smart about this to save GPU bandwidth by building a CRC
-      // as we copy and only if it differs from the previous value committing
-      // it (and if it matches just discard and reuse).
-      xe::copy_and_swap_32_aligned(
-          allocation.host_ptr,
-          memory_->TranslatePhysical<const uint32_t*>(fetch->address << 2),
-          valid_range / 4);
-
-      // TODO(benvanik): if we could find a way to avoid this, we could use
-      // multidraw without flushing.
-      glVertexArrayVertexBuffer(
-          vertex_shader->vao(),
-          static_cast<GLuint>(vertex_binding.binding_index),
-          scratch_buffer_.handle(), allocation.offset,
-          vertex_binding.stride_words * 4);
-
-      scratch_buffer_.Commit(std::move(allocation));
-    } else {
-      // TODO(benvanik): if we could find a way to avoid this, we could use
-      // multidraw without flushing.
-      glVertexArrayVertexBuffer(
-          vertex_shader->vao(),
-          static_cast<GLuint>(vertex_binding.binding_index),
-          scratch_buffer_.handle(), allocation.offset,
-          vertex_binding.stride_words * 4);
-    }
-  }
-
-  return UpdateStatus::kCompatible;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateSamplers() {
-#if FINE_GRAINED_DRAW_SCOPES
-  SCOPE_profile_cpu_f("gpu");
-#endif  // FINE_GRAINED_DRAW_SCOPES
-
-  bool mismatch = false;
-
-  // VS and PS samplers are shared, but may be used exclusively.
-  // We walk each and setup lazily.
-  bool has_setup_sampler[32] = {false};
-
-  // Vertex texture samplers.
-  for (auto& texture_binding : active_vertex_shader_->texture_bindings()) {
-    if (has_setup_sampler[texture_binding.fetch_constant]) {
-      continue;
-    }
-    has_setup_sampler[texture_binding.fetch_constant] = true;
-    auto status = PopulateSampler(texture_binding);
-    if (status == UpdateStatus::kError) {
-      return status;
-    } else if (status == UpdateStatus::kMismatch) {
-      mismatch = true;
-    }
-  }
-
-  // Pixel shader texture sampler.
-  for (auto& texture_binding : active_pixel_shader_->texture_bindings()) {
-    if (has_setup_sampler[texture_binding.fetch_constant]) {
-      continue;
-    }
-    has_setup_sampler[texture_binding.fetch_constant] = true;
-    auto status = PopulateSampler(texture_binding);
-    if (status == UpdateStatus::kError) {
-      return UpdateStatus::kError;
-    } else if (status == UpdateStatus::kMismatch) {
-      mismatch = true;
-    }
-  }
-
-  return mismatch ? UpdateStatus::kMismatch : UpdateStatus::kCompatible;
-}
-
-GL4CommandProcessor::UpdateStatus GL4CommandProcessor::PopulateSampler(
-    const Shader::TextureBinding& texture_binding) {
-  auto& regs = *register_file_;
-  int r = XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 +
-          texture_binding.fetch_constant * 6;
-  auto group = reinterpret_cast<const xe_gpu_fetch_group_t*>(&regs.values[r]);
-  auto& fetch = group->texture_fetch;
-
-  // Reset slot.
-  // If we fail, we still draw but with an invalid texture.
-  draw_batcher_.set_texture_sampler(texture_binding.fetch_constant, 0, 0);
-
-  if (FLAGS_disable_textures) {
-    return UpdateStatus::kCompatible;
-  }
-
-  // ?
-  if (!fetch.type) {
-    return UpdateStatus::kCompatible;
-  }
-  assert_true(fetch.type == 0x2);
-
-  TextureInfo texture_info;
-  if (!TextureInfo::Prepare(fetch, &texture_info)) {
-    XELOGE("Unable to parse texture fetcher info");
-    return UpdateStatus::kCompatible;  // invalid texture used
-  }
-  SamplerInfo sampler_info;
-  if (!SamplerInfo::Prepare(fetch, texture_binding.fetch_instr,
-                            &sampler_info)) {
-    XELOGE("Unable to parse sampler info");
-    return UpdateStatus::kCompatible;  // invalid texture used
-  }
-
-  trace_writer_.WriteMemoryRead(texture_info.guest_address,
-                                texture_info.input_length);
-
-  auto entry_view = texture_cache_.Demand(texture_info, sampler_info);
-  if (!entry_view) {
-    // Unable to create/fetch/etc.
-    XELOGE("Failed to demand texture");
-    return UpdateStatus::kCompatible;
-  }
-
-  // Shaders will use bindless to fetch right from it.
-  draw_batcher_.set_texture_sampler(texture_binding.fetch_constant,
-                                    entry_view->texture_sampler_handle,
-                                    fetch.swizzle);
-
-  return UpdateStatus::kCompatible;
-}
-
-bool GL4CommandProcessor::IssueCopy() {
-  SCOPE_profile_cpu_f("gpu");
-  auto& regs = *register_file_;
-
-  // This is used to resolve surfaces, taking them from EDRAM render targets
-  // to system memory. It can optionally clear color/depth surfaces, too.
-  // The command buffer has stuff for actually doing this by drawing, however
-  // we should be able to do it without that much easier.
-
-  uint32_t copy_control = regs[XE_GPU_REG_RB_COPY_CONTROL].u32;
-  // Render targets 0-3, 4 = depth
-  uint32_t copy_src_select = copy_control & 0x7;
-  bool color_clear_enabled = (copy_control >> 8) & 0x1;
-  bool depth_clear_enabled = (copy_control >> 9) & 0x1;
-  auto copy_command = static_cast<CopyCommand>((copy_control >> 20) & 0x3);
-
-  uint32_t copy_dest_info = regs[XE_GPU_REG_RB_COPY_DEST_INFO].u32;
-  auto copy_dest_endian = static_cast<Endian128>(copy_dest_info & 0x7);
-  uint32_t copy_dest_array = (copy_dest_info >> 3) & 0x1;
-  assert_true(copy_dest_array == 0);
-  uint32_t copy_dest_slice = (copy_dest_info >> 4) & 0x7;
-  assert_true(copy_dest_slice == 0);
-  auto copy_dest_format =
-      static_cast<ColorFormat>((copy_dest_info >> 7) & 0x3F);
-  uint32_t copy_dest_number = (copy_dest_info >> 13) & 0x7;
-  // assert_true(copy_dest_number == 0); // ?
-  uint32_t copy_dest_bias = (copy_dest_info >> 16) & 0x3F;
-  // assert_true(copy_dest_bias == 0);
-  uint32_t copy_dest_swap = (copy_dest_info >> 25) & 0x1;
-
-  uint32_t copy_dest_base = regs[XE_GPU_REG_RB_COPY_DEST_BASE].u32;
-  uint32_t copy_dest_pitch = regs[XE_GPU_REG_RB_COPY_DEST_PITCH].u32;
-  uint32_t copy_dest_height = (copy_dest_pitch >> 16) & 0x3FFF;
-  copy_dest_pitch &= 0x3FFF;
-
-  // None of this is supported yet:
-  uint32_t copy_surface_slice = regs[XE_GPU_REG_RB_COPY_SURFACE_SLICE].u32;
-  assert_true(copy_surface_slice == 0);
-  uint32_t copy_func = regs[XE_GPU_REG_RB_COPY_FUNC].u32;
-  assert_true(copy_func == 0);
-  uint32_t copy_ref = regs[XE_GPU_REG_RB_COPY_REF].u32;
-  assert_true(copy_ref == 0);
-  uint32_t copy_mask = regs[XE_GPU_REG_RB_COPY_MASK].u32;
-  assert_true(copy_mask == 0);
-
-  // RB_SURFACE_INFO
-  // http://fossies.org/dox/MesaLib-10.3.5/fd2__gmem_8c_source.html
-  uint32_t surface_info = regs[XE_GPU_REG_RB_SURFACE_INFO].u32;
-  uint32_t surface_pitch = surface_info & 0x3FFF;
-  auto surface_msaa = static_cast<MsaaSamples>((surface_info >> 16) & 0x3);
-
-  // Depending on the source, pick the buffer we'll be sourcing.
-  // We then query for a cached framebuffer setup with that buffer active.
-  TextureFormat src_format = TextureFormat::kUnknown;
-  GLuint color_targets[4] = {kAnyTarget, kAnyTarget, kAnyTarget, kAnyTarget};
-  GLuint depth_target = kAnyTarget;
-  if (copy_src_select <= 3 || color_clear_enabled) {
-    // Source from a color target.
-    uint32_t color_info[4] = {
-        regs[XE_GPU_REG_RB_COLOR_INFO].u32,
-        regs[XE_GPU_REG_RB_COLOR1_INFO].u32,
-        regs[XE_GPU_REG_RB_COLOR2_INFO].u32,
-        regs[XE_GPU_REG_RB_COLOR3_INFO].u32,
-    };
-    uint32_t color_base = color_info[copy_src_select] & 0xFFF;
-    auto color_format = static_cast<ColorRenderTargetFormat>(
-        (color_info[copy_src_select] >> 16) & 0xF);
-    color_targets[copy_src_select] = GetColorRenderTarget(
-        surface_pitch, surface_msaa, color_base, color_format);
-
-    if (copy_src_select <= 3) {
-      src_format = ColorRenderTargetToTextureFormat(color_format);
-    }
-  }
-
-  // Grab the depth/stencil if we're sourcing from it or clear is enabled.
-  if (copy_src_select > 3 || depth_clear_enabled) {
-    uint32_t depth_info = regs[XE_GPU_REG_RB_DEPTH_INFO].u32;
-    uint32_t depth_base = depth_info & 0xFFF;
-    auto depth_format =
-        static_cast<DepthRenderTargetFormat>((depth_info >> 16) & 0x1);
-    depth_target = GetDepthRenderTarget(surface_pitch, surface_msaa, depth_base,
-                                        depth_format);
-
-    if (copy_src_select > 3) {
-      src_format = DepthRenderTargetToTextureFormat(depth_format);
-    }
-  }
-
-  auto source_framebuffer = GetFramebuffer(color_targets, depth_target);
-  if (!source_framebuffer) {
-    // If we get here we are likely missing some state checks.
-    assert_always("No framebuffer for copy source? no-op copy?");
-    XELOGE("No framebuffer for copy source");
-    return false;
-  }
-
-  active_framebuffer_ = source_framebuffer;
-
-  GLenum read_format;
-  GLenum read_type;
-  size_t read_size = 0;
-  switch (copy_dest_format) {
-    case ColorFormat::k_1_5_5_5:
-      read_format = GL_RGB5_A1;
-      read_type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
-      read_size = 16;
-      break;
-    case ColorFormat::k_2_10_10_10:
-      read_format = GL_RGB10_A2;
-      read_type = GL_UNSIGNED_INT_10_10_10_2;
-      read_size = 32;
-      break;
-    case ColorFormat::k_4_4_4_4:
-      read_format = GL_RGBA4;
-      read_type = GL_UNSIGNED_SHORT_4_4_4_4;
-      read_size = 16;
-      break;
-    case ColorFormat::k_5_6_5:
-      read_format = GL_RGB565;
-      read_type = GL_UNSIGNED_SHORT_5_6_5;
-      read_size = 16;
-      break;
-    case ColorFormat::k_8:
-      read_format = GL_R8;
-      read_type = GL_UNSIGNED_BYTE;
-      read_size = 8;
-      break;
-    case ColorFormat::k_8_8:
-      read_format = GL_RG8;
-      read_type = GL_UNSIGNED_BYTE;
-      read_size = 16;
-      break;
-    case ColorFormat::k_8_8_8_8:
-      read_format = copy_dest_swap ? GL_BGRA : GL_RGBA;
-      read_type = GL_UNSIGNED_BYTE;
-      read_size = 32;
-      break;
-    case ColorFormat::k_16:
-      read_format = GL_R16;
-      read_type = GL_UNSIGNED_SHORT;
-      read_size = 16;
-      break;
-    case ColorFormat::k_16_FLOAT:
-      read_format = GL_R16F;
-      read_type = GL_HALF_FLOAT;
-      read_size = 16;
-      break;
-    case ColorFormat::k_16_16:
-      read_format = GL_RG16;
-      read_type = GL_UNSIGNED_SHORT;
-      read_size = 32;
-      break;
-    case ColorFormat::k_16_16_FLOAT:
-      read_format = GL_RG16F;
-      read_type = GL_HALF_FLOAT;
-      read_size = 32;
-      break;
-    case ColorFormat::k_16_16_16_16:
-      read_format = GL_RGBA16;
-      read_type = GL_UNSIGNED_SHORT;
-      read_size = 64;
-      break;
-    case ColorFormat::k_16_16_16_16_FLOAT:
-      read_format = GL_RGBA16F;
-      read_type = GL_HALF_FLOAT;
-      read_size = 64;
-      break;
-    case ColorFormat::k_32_FLOAT:
-      read_format = GL_R32F;
-      read_type = GL_FLOAT;
-      read_size = 32;
-      break;
-    case ColorFormat::k_32_32_FLOAT:
-      read_format = GL_RG32F;
-      read_type = GL_FLOAT;
-      read_size = 64;
-      break;
-    case ColorFormat::k_32_32_32_32_FLOAT:
-      read_format = GL_RGBA32F;
-      read_type = GL_FLOAT;
-      read_size = 128;
-      break;
-    case ColorFormat::k_10_11_11:
-    case ColorFormat::k_11_11_10:
-      read_format = GL_R11F_G11F_B10F;
-      read_type = GL_UNSIGNED_INT_10F_11F_11F_REV;
-      read_size = 32;
-      break;
-    default:
-      assert_unhandled_case(copy_dest_format);
-      return false;
-  }
-
-  // TODO(benvanik): swap channel ordering on copy_dest_swap
-  //                 Can we use GL swizzles for this?
-
-  // Swap byte order during read.
-  // TODO(benvanik): handle other endian modes.
-  switch (copy_dest_endian) {
-    case Endian128::kUnspecified:
-      glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
-      break;
-    case Endian128::k8in32:
-      glPixelStorei(GL_PACK_SWAP_BYTES, GL_TRUE);
-      break;
-    default:
-      // assert_unhandled_case(copy_dest_endian);
-      glPixelStorei(GL_PACK_SWAP_BYTES, GL_TRUE);
-      break;
-  }
-
-  // TODO(benvanik): tweak alignments/strides.
-  // glPixelStorei(GL_PACK_ALIGNMENT, 1);
-  // glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-  // glPixelStorei(GL_PACK_IMAGE_HEIGHT, 0);
-
-  // TODO(benvanik): any way to scissor this? a200 has:
-  // REG_A2XX_RB_COPY_DEST_OFFSET = A2XX_RB_COPY_DEST_OFFSET_X(tile->xoff) |
-  //                                A2XX_RB_COPY_DEST_OFFSET_Y(tile->yoff);
-  // but I can't seem to find something similar.
-  uint32_t dest_logical_width = copy_dest_pitch;
-  uint32_t dest_logical_height = copy_dest_height;
-  uint32_t dest_block_width = xe::round_up(dest_logical_width, 32);
-  uint32_t dest_block_height = /*xe::round_up(*/ dest_logical_height /*, 32)*/;
-
-  uint32_t window_offset = regs[XE_GPU_REG_PA_SC_WINDOW_OFFSET].u32;
-  int16_t window_offset_x = window_offset & 0x7FFF;
-  int16_t window_offset_y = (window_offset >> 16) & 0x7FFF;
-  if (window_offset_x & 0x4000) {
-    window_offset_x |= 0x8000;
-  }
-  if (window_offset_y & 0x4000) {
-    window_offset_y |= 0x8000;
-  }
-
-  // HACK: vertices to use are always in vf0.
-  int copy_vertex_fetch_slot = 0;
-  int r =
-      XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 + (copy_vertex_fetch_slot / 3) * 6;
-  const auto group = reinterpret_cast<xe_gpu_fetch_group_t*>(&regs.values[r]);
-  const xe_gpu_vertex_fetch_t* fetch = nullptr;
-  switch (copy_vertex_fetch_slot % 3) {
-    case 0:
-      fetch = &group->vertex_fetch_0;
-      break;
-    case 1:
-      fetch = &group->vertex_fetch_1;
-      break;
-    case 2:
-      fetch = &group->vertex_fetch_2;
-      break;
-  }
-  assert_true(fetch->type == 3);
-  assert_true(fetch->endian == 2);
-  assert_true(fetch->size == 6);
-  const uint8_t* vertex_addr = memory_->TranslatePhysical(fetch->address << 2);
-  trace_writer_.WriteMemoryRead(fetch->address << 2, fetch->size * 4);
-  int32_t dest_min_x = int32_t((std::min(
-      std::min(
-          GpuSwap(xe::load<float>(vertex_addr + 0), Endian(fetch->endian)),
-          GpuSwap(xe::load<float>(vertex_addr + 8), Endian(fetch->endian))),
-      GpuSwap(xe::load<float>(vertex_addr + 16), Endian(fetch->endian)))));
-  int32_t dest_max_x = int32_t((std::max(
-      std::max(
-          GpuSwap(xe::load<float>(vertex_addr + 0), Endian(fetch->endian)),
-          GpuSwap(xe::load<float>(vertex_addr + 8), Endian(fetch->endian))),
-      GpuSwap(xe::load<float>(vertex_addr + 16), Endian(fetch->endian)))));
-  int32_t dest_min_y = int32_t((std::min(
-      std::min(
-          GpuSwap(xe::load<float>(vertex_addr + 4), Endian(fetch->endian)),
-          GpuSwap(xe::load<float>(vertex_addr + 12), Endian(fetch->endian))),
-      GpuSwap(xe::load<float>(vertex_addr + 20), Endian(fetch->endian)))));
-  int32_t dest_max_y = int32_t((std::max(
-      std::max(
-          GpuSwap(xe::load<float>(vertex_addr + 4), Endian(fetch->endian)),
-          GpuSwap(xe::load<float>(vertex_addr + 12), Endian(fetch->endian))),
-      GpuSwap(xe::load<float>(vertex_addr + 20), Endian(fetch->endian)))));
-  Rect2D dest_rect(dest_min_x, dest_min_y, dest_max_x - dest_min_x,
-                   dest_max_y - dest_min_y);
-  Rect2D src_rect(0, 0, dest_rect.width, dest_rect.height);
-
-  // The dest base address passed in has already been offset by the window
-  // offset, so to ensure texture lookup works we need to offset it.
-  // TODO(benvanik): allow texture cache to lookup partial textures.
-  // TODO(benvanik): change based on format.
-  int32_t dest_offset = window_offset_y * copy_dest_pitch * int(read_size / 8);
-  dest_offset += window_offset_x * 32 * int(read_size / 8);
-  copy_dest_base += dest_offset;
-
-  // Destination pointer in guest memory.
-  // We have GL throw bytes directly into it.
-  // TODO(benvanik): copy to staging texture then PBO back?
-  void* ptr = memory_->TranslatePhysical(copy_dest_base);
-  size_t size = copy_dest_pitch * copy_dest_height * (read_size / 8);
-
-  auto blitter = static_cast<xe::ui::gl::GLContext*>(context_.get())->blitter();
-
-  // Make active so glReadPixels reads from us.
-  switch (copy_command) {
-    case CopyCommand::kRaw: {
-      // This performs a byte-for-byte copy of the textures from src to dest
-      // with no conversion. Byte swapping may still occur.
-      if (copy_src_select <= 3) {
-        // Source from a bound render target.
-        // TODO(benvanik): RAW copy.
-        last_framebuffer_texture_ = texture_cache_.CopyTexture(
-            blitter, copy_dest_base, dest_logical_width, dest_logical_height,
-            dest_block_width, dest_block_height,
-            ColorFormatToTextureFormat(copy_dest_format),
-            copy_dest_swap ? true : false, color_targets[copy_src_select],
-            src_rect, dest_rect);
-        if (!FLAGS_disable_framebuffer_readback) {
-          // std::memset(ptr, 0xDE,
-          //             copy_dest_pitch * copy_dest_height * (read_size / 8));
-          // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, read_format,
-          //              read_type, ptr);
-        }
-      } else {
-        // Source from the bound depth/stencil target.
-        // TODO(benvanik): RAW copy.
-        texture_cache_.CopyTexture(
-            blitter, copy_dest_base, dest_logical_width, dest_logical_height,
-            dest_block_width, dest_block_height, src_format,
-            copy_dest_swap ? true : false, depth_target, src_rect, dest_rect);
-        if (!FLAGS_disable_framebuffer_readback) {
-          // std::memset(ptr, 0xDE,
-          //             copy_dest_pitch * copy_dest_height * (read_size / 8));
-          // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height,
-          //              GL_DEPTH_STENCIL, read_type, ptr);
-        }
-      }
-      break;
-    }
-    case CopyCommand::kConvert: {
-      if (copy_src_select <= 3) {
-        // Source from a bound render target.
-        // Either copy the readbuffer into an existing texture or create a new
-        // one in the cache so we can service future upload requests.
-        last_framebuffer_texture_ = texture_cache_.ConvertTexture(
-            blitter, copy_dest_base, dest_logical_width, dest_logical_height,
-            dest_block_width, dest_block_height,
-            ColorFormatToTextureFormat(copy_dest_format),
-            copy_dest_swap ? true : false, color_targets[copy_src_select],
-            src_rect, dest_rect);
-        if (!FLAGS_disable_framebuffer_readback) {
-          // std::memset(ptr, 0xDE,
-          //             copy_dest_pitch * copy_dest_height * (read_size / 8));
-          // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height, read_format,
-          //              read_type, ptr);
-        }
-      } else {
-        // Source from the bound depth/stencil target.
-        texture_cache_.ConvertTexture(
-            blitter, copy_dest_base, dest_logical_width, dest_logical_height,
-            dest_block_width, dest_block_height, src_format,
-            copy_dest_swap ? true : false, depth_target, src_rect, dest_rect);
-        if (!FLAGS_disable_framebuffer_readback) {
-          // std::memset(ptr, 0xDE,
-          //             copy_dest_pitch * copy_dest_height * (read_size / 8));
-          // glReadPixels(0, 0, copy_dest_pitch, copy_dest_height,
-          //              GL_DEPTH_STENCIL, read_type, ptr);
-        }
-      }
-      break;
-    }
-    case CopyCommand::kConstantOne:
-    case CopyCommand::kNull:
-    default:
-      // assert_unhandled_case(copy_command);
-      return false;
-  }
-
-  // Perform any requested clears.
-  uint32_t copy_depth_clear = regs[XE_GPU_REG_RB_DEPTH_CLEAR].u32;
-  uint32_t copy_color_clear = regs[XE_GPU_REG_RB_COLOR_CLEAR].u32;
-  uint32_t copy_color_clear_low = regs[XE_GPU_REG_RB_COLOR_CLEAR_LOW].u32;
-  assert_true(copy_color_clear == copy_color_clear_low);
-
-  if (color_clear_enabled) {
-    // Clear the render target we selected for copy.
-    assert_true(copy_src_select < 3);
-    // TODO(benvanik): verify color order.
-    float color[] = {(copy_color_clear & 0xFF) / 255.0f,
-                     ((copy_color_clear >> 8) & 0xFF) / 255.0f,
-                     ((copy_color_clear >> 16) & 0xFF) / 255.0f,
-                     ((copy_color_clear >> 24) & 0xFF) / 255.0f};
-    // TODO(benvanik): remove query.
-    GLboolean old_color_mask[4];
-    glGetBooleani_v(GL_COLOR_WRITEMASK, copy_src_select, old_color_mask);
-    glColorMaski(copy_src_select, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-    glClearNamedFramebufferfv(source_framebuffer->framebuffer, GL_COLOR,
-                              copy_src_select, color);
-    glColorMaski(copy_src_select, old_color_mask[0], old_color_mask[1],
-                 old_color_mask[2], old_color_mask[3]);
-  }
-
-  if (depth_clear_enabled && depth_target != kAnyTarget) {
-    // Clear the current depth buffer.
-    // TODO(benvanik): verify format.
-    GLfloat depth = {(copy_depth_clear & 0xFFFFFF00) /
-                     static_cast<float>(0xFFFFFF00)};
-    GLint stencil = copy_depth_clear & 0xFF;
-    GLint old_draw_framebuffer;
-    GLboolean old_depth_mask;
-    GLint old_stencil_mask;
-    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &old_draw_framebuffer);
-    glGetBooleanv(GL_DEPTH_WRITEMASK, &old_depth_mask);
-    glGetIntegerv(GL_STENCIL_WRITEMASK, &old_stencil_mask);
-    glDepthMask(GL_TRUE);
-    glStencilMask(0xFF);
-    // HACK: this should work, but throws INVALID_ENUM on nvidia drivers.
-    // GLEW signature differs from OpenGL docs?
-    // glClearNamedFramebufferfi(source_framebuffer->framebuffer,
-    //                           GL_DEPTH_STENCIL, depth, stencil);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, source_framebuffer->framebuffer);
-    glClearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, old_draw_framebuffer);
-    glDepthMask(old_depth_mask);
-    glStencilMask(old_stencil_mask);
-  }
-
-  return true;
-}
-
-GLuint GL4CommandProcessor::GetColorRenderTarget(
-    uint32_t pitch, MsaaSamples samples, uint32_t base,
-    ColorRenderTargetFormat format) {
-  // Because we don't know the height of anything, we allocate at full res.
-  // At 2560x2560, it's impossible for EDRAM to fit anymore.
-  uint32_t width = 2560;
-  uint32_t height = 2560;
-
-  // NOTE: we strip gamma formats down to normal ones.
-  if (format == ColorRenderTargetFormat::k_8_8_8_8_GAMMA) {
-    format = ColorRenderTargetFormat::k_8_8_8_8;
-  }
-
-  GLenum internal_format;
-  switch (format) {
-    case ColorRenderTargetFormat::k_8_8_8_8:
-    case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
-      internal_format = GL_RGBA8;
-      break;
-    case ColorRenderTargetFormat::k_2_10_10_10:
-    case ColorRenderTargetFormat::k_2_10_10_10_unknown:
-      internal_format = GL_RGB10_A2UI;
-      break;
-    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
-    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_unknown:
-      internal_format = GL_RGB10_A2;
-      break;
-    case ColorRenderTargetFormat::k_16_16:
-      internal_format = GL_RG16;
-      break;
-    case ColorRenderTargetFormat::k_16_16_FLOAT:
-      internal_format = GL_RG16F;
-      break;
-    case ColorRenderTargetFormat::k_16_16_16_16:
-      internal_format = GL_RGBA16;
-      break;
-    case ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
-      internal_format = GL_RGBA16F;
-      break;
-    case ColorRenderTargetFormat::k_32_FLOAT:
-      internal_format = GL_R32F;
-      break;
-    case ColorRenderTargetFormat::k_32_32_FLOAT:
-      internal_format = GL_RG32F;
-      break;
-    default:
-      assert_unhandled_case(format);
-      return 0;
-  }
-
-  for (auto it = cached_color_render_targets_.begin();
-       it != cached_color_render_targets_.end(); ++it) {
-    if (it->base == base && it->width == width && it->height == height &&
-        it->internal_format == internal_format) {
-      return it->texture;
-    }
-  }
-  cached_color_render_targets_.push_back(CachedColorRenderTarget());
-  auto cached = &cached_color_render_targets_.back();
-  cached->base = base;
-  cached->width = width;
-  cached->height = height;
-  cached->format = format;
-  cached->internal_format = internal_format;
-
-  glCreateTextures(GL_TEXTURE_2D, 1, &cached->texture);
-  glTextureStorage2D(cached->texture, 1, internal_format, width, height);
-
-  return cached->texture;
-}
-
-GLuint GL4CommandProcessor::GetDepthRenderTarget(
-    uint32_t pitch, MsaaSamples samples, uint32_t base,
-    DepthRenderTargetFormat format) {
-  uint32_t width = 2560;
-  uint32_t height = 2560;
-
-  GLenum internal_format;
-  switch (format) {
-    case DepthRenderTargetFormat::kD24S8:
-      internal_format = GL_DEPTH24_STENCIL8;
-      break;
-    case DepthRenderTargetFormat::kD24FS8:
-      // TODO(benvanik): not supported in GL?
-      internal_format = GL_DEPTH24_STENCIL8;
-      break;
-    default:
-      assert_unhandled_case(format);
-      return 0;
-  }
-
-  for (auto it = cached_depth_render_targets_.begin();
-       it != cached_depth_render_targets_.end(); ++it) {
-    if (it->base == base && it->width == width && it->height == height &&
-        it->format == format) {
-      return it->texture;
-    }
-  }
-  cached_depth_render_targets_.push_back(CachedDepthRenderTarget());
-  auto cached = &cached_depth_render_targets_.back();
-  cached->base = base;
-  cached->width = width;
-  cached->height = height;
-  cached->format = format;
-  cached->internal_format = internal_format;
-
-  glCreateTextures(GL_TEXTURE_2D, 1, &cached->texture);
-  glTextureStorage2D(cached->texture, 1, internal_format, width, height);
-
-  return cached->texture;
-}
-
-GL4CommandProcessor::CachedFramebuffer* GL4CommandProcessor::GetFramebuffer(
-    GLuint color_targets[4], GLuint depth_target) {
-  for (auto it = cached_framebuffers_.begin(); it != cached_framebuffers_.end();
-       ++it) {
-    if ((depth_target == kAnyTarget || it->depth_target == depth_target) &&
-        (color_targets[0] == kAnyTarget ||
-         it->color_targets[0] == color_targets[0]) &&
-        (color_targets[1] == kAnyTarget ||
-         it->color_targets[1] == color_targets[1]) &&
-        (color_targets[2] == kAnyTarget ||
-         it->color_targets[2] == color_targets[2]) &&
-        (color_targets[3] == kAnyTarget ||
-         it->color_targets[3] == color_targets[3])) {
-      return &*it;
-    }
-  }
-
-  GLuint real_color_targets[4];
-  bool any_set = false;
-  for (int i = 0; i < 4; ++i) {
-    if (color_targets[i] == kAnyTarget) {
-      real_color_targets[i] = 0;
-    } else {
-      any_set = true;
-      real_color_targets[i] = color_targets[i];
-    }
-  }
-  GLuint real_depth_target;
-  if (depth_target == kAnyTarget) {
-    real_depth_target = 0;
-  } else {
-    any_set = true;
-    real_depth_target = depth_target;
-  }
-  if (!any_set) {
-    // No framebuffer required.
-    return nullptr;
-  }
-
-  cached_framebuffers_.push_back(CachedFramebuffer());
-  auto cached = &cached_framebuffers_.back();
-  glCreateFramebuffers(1, &cached->framebuffer);
-  for (int i = 0; i < 4; ++i) {
-    cached->color_targets[i] = real_color_targets[i];
-    glNamedFramebufferTexture(cached->framebuffer, GL_COLOR_ATTACHMENT0 + i,
-                              real_color_targets[i], 0);
-  }
-  cached->depth_target = real_depth_target;
-  glNamedFramebufferTexture(cached->framebuffer, GL_DEPTH_STENCIL_ATTACHMENT,
-                            real_depth_target, 0);
-
-  return cached;
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/gl4_command_processor.h b/src/xenia/gpu/gl4/gl4_command_processor.h
deleted file mode 100644
index e3f45c9eb..000000000
--- a/src/xenia/gpu/gl4/gl4_command_processor.h
+++ /dev/null
@@ -1,237 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_
-#define XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_
-
-#include <atomic>
-#include <cstring>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <queue>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "xenia/base/threading.h"
-#include "xenia/gpu/command_processor.h"
-#include "xenia/gpu/gl4/draw_batcher.h"
-#include "xenia/gpu/gl4/gl4_shader.h"
-#include "xenia/gpu/gl4/gl4_shader_cache.h"
-#include "xenia/gpu/gl4/texture_cache.h"
-#include "xenia/gpu/glsl_shader_translator.h"
-#include "xenia/gpu/register_file.h"
-#include "xenia/gpu/xenos.h"
-#include "xenia/kernel/xthread.h"
-#include "xenia/memory.h"
-#include "xenia/ui/gl/circular_buffer.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-class GL4GraphicsSystem;
-
-class GL4CommandProcessor : public CommandProcessor {
- public:
-  GL4CommandProcessor(GL4GraphicsSystem* graphics_system,
-                      kernel::KernelState* kernel_state);
-  ~GL4CommandProcessor() override;
-
-  void ClearCaches() override;
-
-  // HACK: for debugging; would be good to have this in a base type.
-  TextureCache* texture_cache() { return &texture_cache_; }
-  DrawBatcher* draw_batcher() { return &draw_batcher_; }
-
-  GLuint GetColorRenderTarget(uint32_t pitch, MsaaSamples samples,
-                              uint32_t base, ColorRenderTargetFormat format);
-  GLuint GetDepthRenderTarget(uint32_t pitch, MsaaSamples samples,
-                              uint32_t base, DepthRenderTargetFormat format);
-
- private:
-  enum class UpdateStatus {
-    kCompatible,
-    kMismatch,
-    kError,
-  };
-
-  struct CachedFramebuffer {
-    GLuint color_targets[4];
-    GLuint depth_target;
-    GLuint framebuffer;
-  };
-  struct CachedColorRenderTarget {
-    uint32_t base;
-    uint32_t width;
-    uint32_t height;
-    ColorRenderTargetFormat format;
-    GLenum internal_format;
-    GLuint texture;
-  };
-  struct CachedDepthRenderTarget {
-    uint32_t base;
-    uint32_t width;
-    uint32_t height;
-    DepthRenderTargetFormat format;
-    GLenum internal_format;
-    GLuint texture;
-  };
-  struct CachedPipeline {
-    CachedPipeline();
-    ~CachedPipeline();
-    GLuint vertex_program;
-    GLuint fragment_program;
-    struct {
-      GLuint default_pipeline;
-      GLuint point_list_pipeline;
-      GLuint rect_list_pipeline;
-      GLuint quad_list_pipeline;
-      GLuint line_quad_list_pipeline;
-      // TODO(benvanik): others with geometry shaders.
-    } handles;
-  };
-
-  bool SetupContext() override;
-  void ShutdownContext() override;
-  GLuint CreateGeometryProgram(const std::string& source);
-
-  void MakeCoherent() override;
-  void PrepareForWait() override;
-  void ReturnFromWait() override;
-
-  void PerformSwap(uint32_t frontbuffer_ptr, uint32_t frontbuffer_width,
-                   uint32_t frontbuffer_height) override;
-
-  Shader* LoadShader(ShaderType shader_type, uint32_t guest_address,
-                     const uint32_t* host_address,
-                     uint32_t dword_count) override;
-
-  bool IssueDraw(PrimitiveType prim_type, uint32_t index_count,
-                 IndexBufferInfo* index_buffer_info) override;
-  UpdateStatus UpdateShaders(PrimitiveType prim_type);
-  UpdateStatus UpdateRenderTargets();
-  UpdateStatus UpdateState(PrimitiveType prim_type);
-  UpdateStatus UpdateViewportState();
-  UpdateStatus UpdateRasterizerState(PrimitiveType prim_type);
-  UpdateStatus UpdateBlendState();
-  UpdateStatus UpdateDepthStencilState();
-  UpdateStatus PopulateIndexBuffer(IndexBufferInfo* index_buffer_info);
-  UpdateStatus PopulateVertexBuffers();
-  UpdateStatus PopulateSamplers();
-  UpdateStatus PopulateSampler(const Shader::TextureBinding& texture_binding);
-  bool IssueCopy() override;
-
-  CachedFramebuffer* GetFramebuffer(GLuint color_targets[4],
-                                    GLuint depth_target);
-
-  GlslShaderTranslator shader_translator_;
-  GL4ShaderCache shader_cache_;
-  CachedFramebuffer* active_framebuffer_ = nullptr;
-  GLuint last_framebuffer_texture_ = 0;
-
-  std::vector<CachedFramebuffer> cached_framebuffers_;
-  std::vector<CachedColorRenderTarget> cached_color_render_targets_;
-  std::vector<CachedDepthRenderTarget> cached_depth_render_targets_;
-  std::vector<std::unique_ptr<CachedPipeline>> all_pipelines_;
-  std::unordered_map<uint64_t, CachedPipeline*> cached_pipelines_;
-  GLuint point_list_geometry_program_ = 0;
-  GLuint rect_list_geometry_program_ = 0;
-  GLuint quad_list_geometry_program_ = 0;
-  GLuint line_quad_list_geometry_program_ = 0;
-
-  TextureCache texture_cache_;
-
-  DrawBatcher draw_batcher_;
-  xe::ui::gl::CircularBuffer scratch_buffer_;
-
- private:
-  bool SetShadowRegister(uint32_t* dest, uint32_t register_name);
-  bool SetShadowRegister(float* dest, uint32_t register_name);
-  struct UpdateRenderTargetsRegisters {
-    uint32_t rb_modecontrol;
-    uint32_t rb_surface_info;
-    uint32_t rb_color_info;
-    uint32_t rb_color1_info;
-    uint32_t rb_color2_info;
-    uint32_t rb_color3_info;
-    uint32_t rb_color_mask;
-    uint32_t rb_depthcontrol;
-    uint32_t rb_stencilrefmask;
-    uint32_t rb_depth_info;
-
-    UpdateRenderTargetsRegisters() { Reset(); }
-    void Reset() { std::memset(this, 0, sizeof(*this)); }
-  } update_render_targets_regs_;
-  struct UpdateViewportStateRegisters {
-    // uint32_t pa_cl_clip_cntl;
-    uint32_t rb_surface_info;
-    uint32_t pa_cl_vte_cntl;
-    uint32_t pa_su_sc_mode_cntl;
-    uint32_t pa_sc_window_offset;
-    uint32_t pa_sc_window_scissor_tl;
-    uint32_t pa_sc_window_scissor_br;
-    float pa_cl_vport_xoffset;
-    float pa_cl_vport_yoffset;
-    float pa_cl_vport_zoffset;
-    float pa_cl_vport_xscale;
-    float pa_cl_vport_yscale;
-    float pa_cl_vport_zscale;
-
-    UpdateViewportStateRegisters() { Reset(); }
-    void Reset() { std::memset(this, 0, sizeof(*this)); }
-  } update_viewport_state_regs_;
-  struct UpdateRasterizerStateRegisters {
-    uint32_t pa_su_sc_mode_cntl;
-    uint32_t pa_sc_screen_scissor_tl;
-    uint32_t pa_sc_screen_scissor_br;
-    uint32_t multi_prim_ib_reset_index;
-    uint32_t pa_sc_viz_query;
-    PrimitiveType prim_type;
-
-    UpdateRasterizerStateRegisters() { Reset(); }
-    void Reset() { std::memset(this, 0, sizeof(*this)); }
-  } update_rasterizer_state_regs_;
-  struct UpdateBlendStateRegisters {
-    uint32_t rb_blendcontrol[4];
-    float rb_blend_rgba[4];
-
-    UpdateBlendStateRegisters() { Reset(); }
-    void Reset() { std::memset(this, 0, sizeof(*this)); }
-  } update_blend_state_regs_;
-  struct UpdateDepthStencilStateRegisters {
-    uint32_t rb_depthcontrol;
-    uint32_t rb_stencilrefmask;
-
-    UpdateDepthStencilStateRegisters() { Reset(); }
-    void Reset() { std::memset(this, 0, sizeof(*this)); }
-  } update_depth_stencil_state_regs_;
-  struct UpdateShadersRegisters {
-    PrimitiveType prim_type;
-    uint32_t pa_su_sc_mode_cntl;
-    uint32_t sq_program_cntl;
-    uint32_t sq_context_misc;
-    GL4Shader* vertex_shader;
-    GL4Shader* pixel_shader;
-
-    UpdateShadersRegisters() { Reset(); }
-    void Reset() {
-      sq_program_cntl = 0;
-      vertex_shader = pixel_shader = nullptr;
-    }
-  } update_shaders_regs_;
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_GL4_COMMAND_PROCESSOR_H_
diff --git a/src/xenia/gpu/gl4/gl4_gpu_flags.cc b/src/xenia/gpu/gl4/gl4_gpu_flags.cc
deleted file mode 100644
index 3844bfc95..000000000
--- a/src/xenia/gpu/gl4/gl4_gpu_flags.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/gl4_gpu_flags.h"
-
-DEFINE_bool(disable_framebuffer_readback, false,
-            "Disable framebuffer readback.");
-DEFINE_bool(disable_textures, false, "Disable textures and use colors only.");
-DEFINE_string(shader_cache_dir, "",
-              "GL4 Shader cache directory (relative to Xenia). Specify an "
-              "empty string to disable the cache.");
diff --git a/src/xenia/gpu/gl4/gl4_gpu_flags.h b/src/xenia/gpu/gl4/gl4_gpu_flags.h
deleted file mode 100644
index 9f68287f9..000000000
--- a/src/xenia/gpu/gl4/gl4_gpu_flags.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2013 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_GL4_GPU_FLAGS_H_
-#define XENIA_GPU_GL4_GL4_GPU_FLAGS_H_
-
-#include <gflags/gflags.h>
-
-DECLARE_bool(disable_framebuffer_readback);
-DECLARE_bool(disable_textures);
-DECLARE_string(shader_cache_dir);
-
-#define FINE_GRAINED_DRAW_SCOPES 0
-
-#endif  // XENIA_GPU_GL4_GL4_GPU_FLAGS_H_
diff --git a/src/xenia/gpu/gl4/gl4_graphics_system.cc b/src/xenia/gpu/gl4/gl4_graphics_system.cc
deleted file mode 100644
index efca2fa08..000000000
--- a/src/xenia/gpu/gl4/gl4_graphics_system.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/gl4_graphics_system.h"
-
-#include <algorithm>
-#include <cstring>
-
-#include "xenia/base/logging.h"
-#include "xenia/base/profiling.h"
-#include "xenia/cpu/processor.h"
-#include "xenia/gpu/gl4/gl4_command_processor.h"
-#include "xenia/gpu/gl4/gl4_gpu_flags.h"
-#include "xenia/gpu/gpu_flags.h"
-#include "xenia/ui/gl/gl_provider.h"
-#include "xenia/ui/window.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-GL4GraphicsSystem::GL4GraphicsSystem() = default;
-
-GL4GraphicsSystem::~GL4GraphicsSystem() = default;
-
-X_STATUS GL4GraphicsSystem::Setup(cpu::Processor* processor,
-                                  kernel::KernelState* kernel_state,
-                                  ui::Window* target_window) {
-  // Must create the provider so we can create contexts.
-  provider_ = xe::ui::gl::GLProvider::Create(target_window);
-
-  auto result = GraphicsSystem::Setup(processor, kernel_state, target_window);
-  if (result) {
-    return result;
-  }
-
-  display_context_ =
-      reinterpret_cast<xe::ui::gl::GLContext*>(target_window->context());
-
-  return X_STATUS_SUCCESS;
-}
-
-void GL4GraphicsSystem::Shutdown() { GraphicsSystem::Shutdown(); }
-
-std::unique_ptr<CommandProcessor> GL4GraphicsSystem::CreateCommandProcessor() {
-  return std::unique_ptr<CommandProcessor>(
-      new GL4CommandProcessor(this, kernel_state_));
-}
-
-void GL4GraphicsSystem::Swap(xe::ui::UIEvent* e) {
-  if (!command_processor_) {
-    return;
-  }
-  // Check for pending swap.
-  auto& swap_state = command_processor_->swap_state();
-  {
-    std::lock_guard<std::mutex> lock(swap_state.mutex);
-    if (swap_state.pending) {
-      swap_state.pending = false;
-      std::swap(swap_state.front_buffer_texture,
-                swap_state.back_buffer_texture);
-    }
-  }
-
-  if (!swap_state.front_buffer_texture) {
-    // Not yet ready.
-    return;
-  }
-
-  // Blit the frontbuffer.
-  display_context_->blitter()->BlitTexture2D(
-      static_cast<GLuint>(swap_state.front_buffer_texture),
-      Rect2D(0, 0, swap_state.width, swap_state.height),
-      Rect2D(0, 0, target_window_->width(), target_window_->height()),
-      GL_LINEAR, false);
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/gl4_graphics_system.h b/src/xenia/gpu/gl4/gl4_graphics_system.h
deleted file mode 100644
index 9644db075..000000000
--- a/src/xenia/gpu/gl4/gl4_graphics_system.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_
-#define XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_
-
-#include <memory>
-
-#include "xenia/gpu/graphics_system.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-class GL4GraphicsSystem : public GraphicsSystem {
- public:
-  GL4GraphicsSystem();
-  ~GL4GraphicsSystem() override;
-
-  std::wstring name() const override { return L"GL4"; }
-
-  X_STATUS Setup(cpu::Processor* processor, kernel::KernelState* kernel_state,
-                 ui::Window* target_window) override;
-  void Shutdown() override;
-
- private:
-  std::unique_ptr<CommandProcessor> CreateCommandProcessor() override;
-
-  void Swap(xe::ui::UIEvent* e) override;
-
-  xe::ui::gl::GLContext* display_context_ = nullptr;
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_GL4_GRAPHICS_SYSTEM_H_
diff --git a/src/xenia/gpu/gl4/gl4_shader.cc b/src/xenia/gpu/gl4/gl4_shader.cc
deleted file mode 100644
index 7f34b1957..000000000
--- a/src/xenia/gpu/gl4/gl4_shader.cc
+++ /dev/null
@@ -1,298 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/gl4_shader.h"
-
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-GL4Shader::GL4Shader(ShaderType shader_type, uint64_t data_hash,
-                     const uint32_t* dword_ptr, uint32_t dword_count)
-    : Shader(shader_type, data_hash, dword_ptr, dword_count) {}
-
-GL4Shader::~GL4Shader() {
-  glDeleteProgram(program_);
-  glDeleteVertexArrays(1, &vao_);
-}
-
-bool GL4Shader::Prepare() {
-  // Build static vertex array descriptor.
-  if (!PrepareVertexArrayObject()) {
-    XELOGE("Unable to prepare vertex shader array object");
-    return false;
-  }
-
-  bool success = true;
-  if (!CompileShader()) {
-    host_error_log_ = GetShaderInfoLog();
-    success = false;
-  }
-  if (success && !LinkProgram()) {
-    host_error_log_ = GetProgramInfoLog();
-    success = false;
-  }
-
-  if (success) {
-    host_binary_ = GetBinary();
-    host_disassembly_ = GetHostDisasmNV(host_binary_);
-  }
-  is_valid_ = success;
-
-  return success;
-}
-
-bool GL4Shader::LoadFromBinary(const uint8_t* blob, GLenum binary_format,
-                               size_t length) {
-  program_ = glCreateProgram();
-  glProgramBinary(program_, binary_format, blob, GLsizei(length));
-
-  GLint link_status = 0;
-  glGetProgramiv(program_, GL_LINK_STATUS, &link_status);
-  if (!link_status) {
-    // Failed to link. Not fatal - just clean up so we can get generated later.
-    XELOGD("GL4Shader::LoadFromBinary failed. Log:\n%s",
-           GetProgramInfoLog().c_str());
-    glDeleteProgram(program_);
-    program_ = 0;
-
-    return false;
-  }
-
-  // Build static vertex array descriptor.
-  if (!PrepareVertexArrayObject()) {
-    XELOGE("Unable to prepare vertex shader array object");
-    return false;
-  }
-
-  // Success!
-  host_binary_ = GetBinary();
-  host_disassembly_ = GetHostDisasmNV(host_binary_);
-
-  is_valid_ = true;
-  return true;
-}
-
-bool GL4Shader::PrepareVertexArrayObject() {
-  glCreateVertexArrays(1, &vao_);
-
-  for (const auto& vertex_binding : vertex_bindings()) {
-    for (const auto& attrib : vertex_binding.attributes) {
-      auto comp_count = GetVertexFormatComponentCount(
-          attrib.fetch_instr.attributes.data_format);
-      GLenum comp_type = 0;
-      bool is_signed = attrib.fetch_instr.attributes.is_signed;
-      switch (attrib.fetch_instr.attributes.data_format) {
-        case VertexFormat::k_8_8_8_8:
-          comp_type = is_signed ? GL_BYTE : GL_UNSIGNED_BYTE;
-          break;
-        case VertexFormat::k_2_10_10_10:
-          comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
-          comp_count = 1;
-          break;
-        case VertexFormat::k_10_11_11:
-          comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
-          comp_count = 1;
-          break;
-        case VertexFormat::k_11_11_10:
-          assert_true(is_signed);
-          comp_type = is_signed ? GL_R11F_G11F_B10F : 0;
-          break;
-        case VertexFormat::k_16_16:
-          comp_type = is_signed ? GL_SHORT : GL_UNSIGNED_SHORT;
-          break;
-        case VertexFormat::k_16_16_FLOAT:
-          comp_type = GL_HALF_FLOAT;
-          break;
-        case VertexFormat::k_16_16_16_16:
-          comp_type = is_signed ? GL_SHORT : GL_UNSIGNED_SHORT;
-          break;
-        case VertexFormat::k_16_16_16_16_FLOAT:
-          comp_type = GL_HALF_FLOAT;
-          break;
-        case VertexFormat::k_32:
-          comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
-          break;
-        case VertexFormat::k_32_32:
-          comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
-          break;
-        case VertexFormat::k_32_32_32_32:
-          comp_type = is_signed ? GL_INT : GL_UNSIGNED_INT;
-          break;
-        case VertexFormat::k_32_FLOAT:
-          comp_type = GL_FLOAT;
-          break;
-        case VertexFormat::k_32_32_FLOAT:
-          comp_type = GL_FLOAT;
-          break;
-        case VertexFormat::k_32_32_32_FLOAT:
-          comp_type = GL_FLOAT;
-          break;
-        case VertexFormat::k_32_32_32_32_FLOAT:
-          comp_type = GL_FLOAT;
-          break;
-        default:
-          assert_unhandled_case(attrib.fetch_instr.attributes.data_format);
-          return false;
-      }
-
-      glEnableVertexArrayAttrib(vao_, attrib.attrib_index);
-      glVertexArrayAttribBinding(vao_, attrib.attrib_index,
-                                 vertex_binding.binding_index);
-      glVertexArrayAttribFormat(vao_, attrib.attrib_index, comp_count,
-                                comp_type,
-                                !attrib.fetch_instr.attributes.is_integer,
-                                attrib.fetch_instr.attributes.offset * 4);
-    }
-  }
-
-  return true;
-}
-
-bool GL4Shader::CompileShader() {
-  assert_zero(program_);
-
-  shader_ =
-      glCreateShader(shader_type_ == ShaderType::kVertex ? GL_VERTEX_SHADER
-                                                         : GL_FRAGMENT_SHADER);
-  if (!shader_) {
-    XELOGE("OpenGL could not create a shader object!");
-    return false;
-  }
-
-  auto source_str = GetTranslatedBinaryString();
-  auto source_str_ptr = source_str.c_str();
-  GLint source_length = GLint(source_str.length());
-  glShaderSource(shader_, 1, &source_str_ptr, &source_length);
-  glCompileShader(shader_);
-
-  GLint status = 0;
-  glGetShaderiv(shader_, GL_COMPILE_STATUS, &status);
-
-  return status == GL_TRUE;
-}
-
-bool GL4Shader::LinkProgram() {
-  program_ = glCreateProgram();
-  if (!program_) {
-    XELOGE("OpenGL could not create a shader program!");
-    return false;
-  }
-
-  glAttachShader(program_, shader_);
-
-  // Enable TFB
-  if (shader_type_ == ShaderType::kVertex) {
-    const GLchar* feedbackVaryings = "gl_Position";
-    glTransformFeedbackVaryings(program_, 1, &feedbackVaryings,
-                                GL_SEPARATE_ATTRIBS);
-  }
-
-  glProgramParameteri(program_, GL_PROGRAM_SEPARABLE, GL_TRUE);
-  glLinkProgram(program_);
-
-  GLint link_status = 0;
-  glGetProgramiv(program_, GL_LINK_STATUS, &link_status);
-  if (!link_status) {
-    assert_always("Unable to link generated shader");
-    return false;
-  }
-
-  return true;
-}
-
-std::string GL4Shader::GetShaderInfoLog() {
-  if (!shader_) {
-    return "GL4Shader::GetShaderInfoLog(): Program is NULL";
-  }
-
-  std::string log;
-  GLint log_length = 0;
-  glGetShaderiv(shader_, GL_INFO_LOG_LENGTH, &log_length);
-  if (log_length > 0) {
-    log.resize(log_length - 1);
-    glGetShaderInfoLog(shader_, log_length, &log_length, &log[0]);
-  }
-
-  return log;
-}
-
-std::string GL4Shader::GetProgramInfoLog() {
-  if (!program_) {
-    return "GL4Shader::GetProgramInfoLog(): Program is NULL";
-  }
-
-  std::string log;
-  GLint log_length = 0;
-  glGetProgramiv(program_, GL_INFO_LOG_LENGTH, &log_length);
-  if (log_length > 0) {
-    log.resize(log_length - 1);
-    glGetProgramInfoLog(program_, log_length, &log_length, &log[0]);
-  }
-
-  return log;
-}
-
-std::vector<uint8_t> GL4Shader::GetBinary(GLenum* binary_format) {
-  std::vector<uint8_t> binary;
-
-  // Get program binary, if it's available.
-  GLint binary_length = 0;
-  glGetProgramiv(program_, GL_PROGRAM_BINARY_LENGTH, &binary_length);
-  if (binary_length) {
-    binary.resize(binary_length);
-    GLenum binary_format_tmp = 0;
-    glGetProgramBinary(program_, binary_length, &binary_length,
-                       &binary_format_tmp, binary.data());
-
-    if (binary_format) {
-      *binary_format = binary_format_tmp;
-    }
-  }
-
-  return binary;
-}
-
-std::string GL4Shader::GetHostDisasmNV(const std::vector<uint8_t>& binary) {
-  // If we are on nvidia, we can find the disassembly string.
-  // I haven't been able to figure out from the format how to do this
-  // without a search like this.
-  std::string disasm;
-
-  const char* disasm_start = nullptr;
-  size_t search_offset = 0;
-  const char* search_start = reinterpret_cast<const char*>(binary.data());
-  while (true) {
-    auto p = reinterpret_cast<const char*>(memchr(
-        binary.data() + search_offset, '!', binary.size() - search_offset));
-    if (!p) {
-      break;
-    }
-    if (p[0] == '!' && p[1] == '!' && p[2] == 'N' && p[3] == 'V') {
-      disasm_start = p;
-      break;
-    }
-    search_offset = p - search_start;
-    ++search_offset;
-  }
-  if (disasm_start) {
-    disasm = std::string(disasm_start);
-  } else {
-    disasm = std::string("Shader disassembly not available.");
-  }
-
-  return disasm;
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/gl4_shader.h b/src/xenia/gpu/gl4/gl4_shader.h
deleted file mode 100644
index 1f884ebf2..000000000
--- a/src/xenia/gpu/gl4/gl4_shader.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_GL4_SHADER_H_
-#define XENIA_GPU_GL4_GL4_SHADER_H_
-
-#include <string>
-
-#include "xenia/gpu/shader.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-class GL4Shader : public Shader {
- public:
-  GL4Shader(ShaderType shader_type, uint64_t data_hash,
-            const uint32_t* dword_ptr, uint32_t dword_count);
-  ~GL4Shader() override;
-
-  GLuint program() const { return program_; }
-  GLuint shader() const { return shader_; }
-  GLuint vao() const { return vao_; }
-
-  bool Prepare();
-  bool LoadFromBinary(const uint8_t* blob, GLenum binary_format, size_t length);
-  std::vector<uint8_t> GetBinary(GLenum* binary_format = nullptr);
-
- protected:
-  bool PrepareVertexArrayObject();
-  bool CompileShader();
-  bool LinkProgram();
-
-  std::string GetShaderInfoLog();
-  std::string GetProgramInfoLog();
-  static std::string GetHostDisasmNV(const std::vector<uint8_t>& binary);
-
-  GLuint program_ = 0;
-  GLuint shader_ = 0;
-  GLuint vao_ = 0;
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_GL4_SHADER_H_
diff --git a/src/xenia/gpu/gl4/gl4_shader_cache.cc b/src/xenia/gpu/gl4/gl4_shader_cache.cc
deleted file mode 100644
index 714de3e1d..000000000
--- a/src/xenia/gpu/gl4/gl4_shader_cache.cc
+++ /dev/null
@@ -1,187 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2016 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/gl4_shader_cache.h"
-
-#include <cinttypes>
-
-#include "xenia/base/filesystem.h"
-#include "xenia/base/logging.h"
-#include "xenia/base/mapped_memory.h"
-#include "xenia/gpu/gl4/gl4_gpu_flags.h"
-#include "xenia/gpu/gl4/gl4_shader.h"
-#include "xenia/gpu/glsl_shader_translator.h"
-#include "xenia/gpu/gpu_flags.h"
-
-#include "third_party/xxhash/xxhash.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-GL4ShaderCache::GL4ShaderCache(GlslShaderTranslator* shader_translator)
-    : shader_translator_(shader_translator) {}
-
-GL4ShaderCache::~GL4ShaderCache() {}
-
-void GL4ShaderCache::Reset() {
-  shader_map_.clear();
-  all_shaders_.clear();
-}
-
-GL4Shader* GL4ShaderCache::LookupOrInsertShader(ShaderType shader_type,
-                                                const uint32_t* dwords,
-                                                uint32_t dword_count) {
-  // Hash the input memory and lookup the shader.
-  GL4Shader* shader_ptr = nullptr;
-  uint64_t hash = XXH64(dwords, dword_count * sizeof(uint32_t), 0);
-  auto it = shader_map_.find(hash);
-  if (it != shader_map_.end()) {
-    // Shader has been previously loaded.
-    // TODO(benvanik): compare bytes? Likelihood of collision is low.
-    shader_ptr = it->second;
-  } else {
-    // Check filesystem cache.
-    shader_ptr = FindCachedShader(shader_type, hash, dwords, dword_count);
-    if (shader_ptr) {
-      // Found!
-      XELOGGPU("Loaded %s shader from cache (hash: %.16" PRIX64 ")",
-               shader_type == ShaderType::kVertex ? "vertex" : "pixel", hash);
-      return shader_ptr;
-    }
-
-    // Not found in cache - load from scratch.
-    auto shader =
-        std::make_unique<GL4Shader>(shader_type, hash, dwords, dword_count);
-    shader_ptr = shader.get();
-    shader_map_.insert({hash, shader_ptr});
-    all_shaders_.emplace_back(std::move(shader));
-
-    // Perform translation.
-    // If this fails the shader will be marked as invalid and ignored later.
-    if (shader_translator_->Translate(shader_ptr)) {
-      shader_ptr->Prepare();
-      if (shader_ptr->is_valid()) {
-        CacheShader(shader_ptr);
-
-        XELOGGPU("Generated %s shader at 0x%.16" PRIX64 " (%db):\n%s",
-                 shader_type == ShaderType::kVertex ? "vertex" : "pixel",
-                 dwords, dword_count * 4,
-                 shader_ptr->ucode_disassembly().c_str());
-      }
-
-      // Dump shader files if desired.
-      if (!FLAGS_dump_shaders.empty()) {
-        shader_ptr->Dump(FLAGS_dump_shaders, "gl4");
-      }
-    } else {
-      XELOGE("Shader failed translation");
-    }
-  }
-
-  return shader_ptr;
-}
-
-void GL4ShaderCache::CacheShader(GL4Shader* shader) {
-  if (FLAGS_shader_cache_dir.empty()) {
-    // Cache disabled.
-    return;
-  }
-
-  GLenum binary_format = 0;
-  auto binary = shader->GetBinary(&binary_format);
-  if (binary.size() == 0) {
-    // No binary returned.
-    return;
-  }
-
-  auto cache_dir = xe::to_absolute_path(xe::to_wstring(FLAGS_shader_cache_dir));
-  xe::filesystem::CreateFolder(cache_dir);
-  auto filename =
-      cache_dir + xe::format_string(
-                      L"%.16" PRIX64 ".%s", shader->ucode_data_hash(),
-                      shader->type() == ShaderType::kPixel ? L"frag" : L"vert");
-  auto file = xe::filesystem::OpenFile(filename, "wb");
-  if (!file) {
-    // Not fatal, but not too good.
-    return;
-  }
-
-  std::vector<uint8_t> cached_shader_mem;
-  // Resize this vector to the final filesize (- 1 to account for dummy array
-  // in CachedShader)
-  cached_shader_mem.resize(sizeof(CachedShader) + binary.size() - 1);
-  auto cached_shader =
-      reinterpret_cast<CachedShader*>(cached_shader_mem.data());
-  cached_shader->magic = xe::byte_swap('XSHD');
-  cached_shader->version = 0;  // TODO
-  cached_shader->shader_type = uint8_t(shader->type());
-  cached_shader->binary_len = uint32_t(binary.size());
-  cached_shader->binary_format = binary_format;
-  std::memcpy(cached_shader->binary, binary.data(), binary.size());
-
-  fwrite(cached_shader_mem.data(), cached_shader_mem.size(), 1, file);
-  fclose(file);
-}
-
-GL4Shader* GL4ShaderCache::FindCachedShader(ShaderType shader_type,
-                                            uint64_t hash,
-                                            const uint32_t* dwords,
-                                            uint32_t dword_count) {
-  if (FLAGS_shader_cache_dir.empty()) {
-    // Cache disabled.
-    return nullptr;
-  }
-
-  auto cache_dir = xe::to_absolute_path(xe::to_wstring(FLAGS_shader_cache_dir));
-  auto filename =
-      cache_dir +
-      xe::format_string(L"%.16" PRIX64 ".%s", hash,
-                        shader_type == ShaderType::kPixel ? L"frag" : L"vert");
-  if (!xe::filesystem::PathExists(filename)) {
-    return nullptr;
-  }
-
-  // Shader is cached. Open it up.
-  auto map = xe::MappedMemory::Open(filename, MappedMemory::Mode::kRead);
-  if (!map) {
-    // Should not fail
-    assert_always();
-    return nullptr;
-  }
-
-  auto cached_shader = reinterpret_cast<CachedShader*>(map->data());
-  // TODO: Compare versions
-  if (cached_shader->magic != xe::byte_swap('XSHD')) {
-    return nullptr;
-  }
-
-  auto shader =
-      std::make_unique<GL4Shader>(shader_type, hash, dwords, dword_count);
-
-  // Gather the binding points.
-  // TODO: Make Shader do this on construction.
-  // TODO: Regenerate microcode disasm/etc on load.
-  shader_translator_->GatherAllBindingInformation(shader.get());
-  if (!shader->LoadFromBinary(cached_shader->binary,
-                              cached_shader->binary_format,
-                              cached_shader->binary_len)) {
-    // Failed to load from binary.
-    return nullptr;
-  }
-
-  auto shader_ptr = shader.get();
-  shader_map_.insert({hash, shader_ptr});
-  all_shaders_.emplace_back(std::move(shader));
-  return shader_ptr;
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/gl4_shader_cache.h b/src/xenia/gpu/gl4/gl4_shader_cache.h
deleted file mode 100644
index 9c5c77cb2..000000000
--- a/src/xenia/gpu/gl4/gl4_shader_cache.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2016 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_SHADER_CACHE_H_
-#define XENIA_GPU_GL4_SHADER_CACHE_H_
-
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-#include "xenia/gpu/xenos.h"
-
-namespace xe {
-namespace gpu {
-class GlslShaderTranslator;
-
-namespace gl4 {
-
-class GL4Shader;
-
-class GL4ShaderCache {
- public:
-  GL4ShaderCache(GlslShaderTranslator* shader_translator);
-  ~GL4ShaderCache();
-
-  void Reset();
-  GL4Shader* LookupOrInsertShader(ShaderType shader_type,
-                                  const uint32_t* dwords, uint32_t dword_count);
-
- private:
-  // Cached shader file format.
-  struct CachedShader {
-    uint32_t magic;
-    uint32_t version;        // Version of the shader translator used.
-    uint8_t shader_type;     // ShaderType enum
-    uint32_t binary_len;     // Code length
-    uint32_t binary_format;  // Binary format (from OpenGL)
-    uint8_t binary[1];       // Code
-  };
-
-  void CacheShader(GL4Shader* shader);
-  GL4Shader* FindCachedShader(ShaderType shader_type, uint64_t hash,
-                              const uint32_t* dwords, uint32_t dword_count);
-
-  GlslShaderTranslator* shader_translator_ = nullptr;
-  std::vector<std::unique_ptr<GL4Shader>> all_shaders_;
-  std::unordered_map<uint64_t, GL4Shader*> shader_map_;
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_SHADER_CACHE_H_
diff --git a/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc b/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc
deleted file mode 100644
index c7d24001c..000000000
--- a/src/xenia/gpu/gl4/gl4_trace_viewer_main.cc
+++ /dev/null
@@ -1,109 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/base/logging.h"
-#include "xenia/base/main.h"
-#include "xenia/gpu/gl4/gl4_command_processor.h"
-#include "xenia/gpu/gl4/gl4_graphics_system.h"
-#include "xenia/gpu/trace_viewer.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-using namespace xe::gpu::xenos;
-
-class GL4TraceViewer : public TraceViewer {
- public:
-  std::unique_ptr<gpu::GraphicsSystem> CreateGraphicsSystem() override {
-    return std::unique_ptr<gpu::GraphicsSystem>(new GL4GraphicsSystem());
-  }
-
-  uintptr_t GetColorRenderTarget(uint32_t pitch, MsaaSamples samples,
-                                 uint32_t base,
-                                 ColorRenderTargetFormat format) override {
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-    return command_processor->GetColorRenderTarget(pitch, samples, base,
-                                                   format);
-  }
-
-  uintptr_t GetDepthRenderTarget(uint32_t pitch, MsaaSamples samples,
-                                 uint32_t base,
-                                 DepthRenderTargetFormat format) override {
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-    return command_processor->GetDepthRenderTarget(pitch, samples, base,
-                                                   format);
-  }
-
-  uintptr_t GetTextureEntry(const TextureInfo& texture_info,
-                            const SamplerInfo& sampler_info) override {
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-
-    auto entry_view =
-        command_processor->texture_cache()->Demand(texture_info, sampler_info);
-    if (!entry_view) {
-      return 0;
-    }
-    auto texture = entry_view->texture;
-    return static_cast<uintptr_t>(texture->handle);
-  }
-
-  size_t QueryVSOutputSize() override {
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-    auto draw_batcher = command_processor->draw_batcher();
-
-    return draw_batcher->QueryTFBSize();
-  }
-
-  size_t QueryVSOutputElementSize() override {
-    // vec4 always has 4 elements.
-    return 4;
-  }
-
-  bool QueryVSOutput(void* buffer, size_t size) override {
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-    auto draw_batcher = command_processor->draw_batcher();
-
-    return draw_batcher->ReadbackTFB(buffer, size);
-  }
-
-  bool Setup() override {
-    if (!TraceViewer::Setup()) {
-      return false;
-    }
-
-    // Enable TFB
-    auto command_processor = static_cast<GL4CommandProcessor*>(
-        graphics_system_->command_processor());
-    auto draw_batcher = command_processor->draw_batcher();
-    draw_batcher->set_tfb_enabled(true);
-
-    return true;
-  }
-
- private:
-};
-
-int trace_viewer_main(const std::vector<std::wstring>& args) {
-  GL4TraceViewer trace_viewer;
-  return trace_viewer.Main(args);
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-DEFINE_ENTRY_POINT(L"xenia-gpu-gl4-trace-viewer",
-                   L"xenia-gpu-gl4-trace-viewer some.trace",
-                   xe::gpu::gl4::trace_viewer_main);
diff --git a/src/xenia/gpu/gl4/premake5.lua b/src/xenia/gpu/gl4/premake5.lua
deleted file mode 100644
index 041ef8b2d..000000000
--- a/src/xenia/gpu/gl4/premake5.lua
+++ /dev/null
@@ -1,97 +0,0 @@
-project_root = "../../../.."
-include(project_root.."/tools/build")
-
-group("src")
-project("xenia-gpu-gl4")
-  uuid("da10149d-efb0-44aa-924c-a76a46e1f04d")
-  kind("StaticLib")
-  language("C++")
-  links({
-    "glew",
-    "xenia-base",
-    "xenia-gpu",
-    "xenia-ui",
-    "xenia-ui-gl",
-    "xxhash",
-  })
-  defines({
-    "GLEW_STATIC=1",
-    "GLEW_MX=1",
-  })
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
-  local_platform_files()
-
--- TODO(benvanik): kill this and move to the debugger UI.
-group("src")
-project("xenia-gpu-gl4-trace-viewer")
-  uuid("450f965b-a019-4ba5-bc6f-99901e5a4c8d")
-  kind("WindowedApp")
-  language("C++")
-  links({
-    "capstone",
-    "gflags",
-    "glew",
-    "imgui",
-    "libavcodec",
-    "libavutil",
-    "snappy",
-    "xenia-apu",
-    "xenia-apu-nop",
-    "xenia-base",
-    "xenia-core",
-    "xenia-cpu",
-    "xenia-cpu-backend-x64",
-    "xenia-gpu",
-    "xenia-gpu-gl4",
-    "xenia-hid",
-    "xenia-hid-nop",
-    "xenia-kernel",
-    "xenia-ui",
-    "xenia-ui-gl",
-    "xenia-vfs",
-    "xxhash",
-  })
-  flags({
-    "WinMain",  -- Use WinMain instead of main.
-  })
-  defines({
-    "GLEW_STATIC=1",
-    "GLEW_MX=1",
-  })
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
-  files({
-    "gl4_trace_viewer_main.cc",
-    "../../base/main_"..platform_suffix..".cc",
-  })
-
-  filter("platforms:Linux")
-    links({
-      "X11",
-      "xcb",
-      "X11-xcb",
-      "GL",
-      "vulkan",
-    })
-
-  filter("platforms:Windows")
-    links({
-      "xenia-apu-xaudio2",
-      "xenia-hid-winkey",
-      "xenia-hid-xinput",
-    })
-
-    -- Only create the .user file if it doesn't already exist.
-    local user_file = project_root.."/build/xenia-gpu-gl4-trace-viewer.vcxproj.user"
-    if not os.isfile(user_file) then
-      debugdir(project_root)
-      debugargs({
-        "--flagfile=scratch/flags.txt",
-        "2>&1",
-        "1>scratch/stdout-trace-viewer.txt",
-      })
-    end
-  
\ No newline at end of file
diff --git a/src/xenia/gpu/gl4/texture_cache.cc b/src/xenia/gpu/gl4/texture_cache.cc
deleted file mode 100644
index affd012bd..000000000
--- a/src/xenia/gpu/gl4/texture_cache.cc
+++ /dev/null
@@ -1,1101 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/gpu/gl4/texture_cache.h"
-
-#include <algorithm>
-#include <cstring>
-
-#include "xenia/base/assert.h"
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/base/memory.h"
-#include "xenia/base/profiling.h"
-#include "xenia/gpu/gpu_flags.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-struct TextureConfig {
-  TextureFormat texture_format;
-  GLenum internal_format;
-  GLenum format;
-  GLenum type;
-};
-
-// https://code.google.com/p/glsnewton/source/browse/trunk/Source/uDDSLoader.pas?r=62
-// http://dench.flatlib.jp/opengl/textures
-// http://fossies.org/linux/WebKit/Source/ThirdParty/ANGLE/src/libGLESv2/formatutils.cpp
-static const TextureConfig texture_configs[64] = {
-    {TextureFormat::k_1_REVERSE, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_1, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_8, GL_R8, GL_RED, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_1_5_5_5, GL_RGB5_A1, GL_RGBA,
-     GL_UNSIGNED_SHORT_1_5_5_5_REV},
-    {TextureFormat::k_5_6_5, GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV},
-    {TextureFormat::k_6_5_5, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_8_8_8_8, GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
-    {TextureFormat::k_2_10_10_10, GL_RGB10_A2, GL_RGBA,
-     GL_UNSIGNED_INT_2_10_10_10_REV},
-    {TextureFormat::k_8_A, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_8_B, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_8_8, GL_RG8, GL_RG, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_Cr_Y1_Cb_Y0, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_Y1_Cr_Y0_Cb, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_8_8_8_8_A, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_4_4_4_4, GL_RGBA4, GL_RGBA,
-     GL_UNSIGNED_SHORT_4_4_4_4_REV},
-    {TextureFormat::k_10_11_11, GL_R11F_G11F_B10F, GL_RGB,
-     GL_UNSIGNED_INT_10F_11F_11F_REV},  // ?
-    {TextureFormat::k_11_11_10, GL_R11F_G11F_B10F, GL_RGB,
-     GL_UNSIGNED_INT_10F_11F_11F_REV},  // ?
-    {TextureFormat::k_DXT1, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT2_3, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT4_5, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_24_8, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL,
-     GL_UNSIGNED_INT_24_8},
-    {TextureFormat::k_24_8_FLOAT, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL,
-     GL_FLOAT_32_UNSIGNED_INT_24_8_REV},
-    {TextureFormat::k_16, GL_R16, GL_RED, GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_16, GL_RG16, GL_RG, GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_16_16_16, GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_EXPAND, GL_R16, GL_RED, GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_16_EXPAND, GL_RG16, GL_RG, GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_16_16_16_EXPAND, GL_RGBA16, GL_RGBA,
-     GL_UNSIGNED_SHORT},
-    {TextureFormat::k_16_FLOAT, GL_R16F, GL_RED, GL_HALF_FLOAT},
-    {TextureFormat::k_16_16_FLOAT, GL_RG16F, GL_RG, GL_HALF_FLOAT},
-    {TextureFormat::k_16_16_16_16_FLOAT, GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},
-    {TextureFormat::k_32, GL_R32I, GL_RED, GL_UNSIGNED_INT},
-    {TextureFormat::k_32_32, GL_RG32I, GL_RG, GL_UNSIGNED_INT},
-    {TextureFormat::k_32_32_32_32, GL_RGBA32I, GL_RGBA, GL_UNSIGNED_INT},
-    {TextureFormat::k_32_FLOAT, GL_R32F, GL_RED, GL_FLOAT},
-    {TextureFormat::k_32_32_FLOAT, GL_RG32F, GL_RG, GL_FLOAT},
-    {TextureFormat::k_32_32_32_32_FLOAT, GL_RGBA32F, GL_RGBA, GL_FLOAT},
-    {TextureFormat::k_32_AS_8, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_32_AS_8_8, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_16_MPEG, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_16_16_MPEG, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_32_AS_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_32_AS_8_8_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_16_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_16_MPEG_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_16_16_MPEG_INTERLACED, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_DXN, GL_COMPRESSED_RG_RGTC2, GL_COMPRESSED_RG_RGTC2,
-     GL_INVALID_ENUM},
-    {TextureFormat::k_8_8_8_8_AS_16_16_16_16, GL_RGBA8, GL_RGBA,
-     GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT1_AS_16_16_16_16, GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
-     GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT2_3_AS_16_16_16_16, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT4_5_AS_16_16_16_16, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_2_10_10_10_AS_16_16_16_16, GL_RGB10_A2, GL_RGBA,
-     GL_UNSIGNED_INT_2_10_10_10_REV},
-    {TextureFormat::k_10_11_11_AS_16_16_16_16, GL_R11F_G11F_B10F, GL_RGB,
-     GL_UNSIGNED_INT_10F_11F_11F_REV},
-    {TextureFormat::k_11_11_10_AS_16_16_16_16, GL_R11F_G11F_B10F,
-     GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_32_32_32_FLOAT, GL_RGB32F, GL_RGB, GL_FLOAT},
-    {TextureFormat::k_DXT3A, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_DXT5A, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
-     GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_UNSIGNED_BYTE},
-    {TextureFormat::k_CTX1, GL_INVALID_ENUM, GL_INVALID_ENUM, GL_INVALID_ENUM},
-    {TextureFormat::k_DXT3A_AS_1_1_1_1, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-    {TextureFormat::kUnknown, GL_INVALID_ENUM, GL_INVALID_ENUM,
-     GL_INVALID_ENUM},
-};
-
-TextureCache::TextureCache() : memory_(nullptr), scratch_buffer_(nullptr) {
-  invalidated_textures_sets_[0].reserve(64);
-  invalidated_textures_sets_[1].reserve(64);
-  invalidated_textures_ = &invalidated_textures_sets_[0];
-}
-
-TextureCache::~TextureCache() { Shutdown(); }
-
-bool TextureCache::Initialize(Memory* memory, CircularBuffer* scratch_buffer) {
-  memory_ = memory;
-  scratch_buffer_ = scratch_buffer;
-  return true;
-}
-
-void TextureCache::Shutdown() { Clear(); }
-
-void TextureCache::Scavenge() {
-  invalidated_textures_mutex_.lock();
-  std::vector<TextureEntry*>& invalidated_textures = *invalidated_textures_;
-  if (invalidated_textures_ == &invalidated_textures_sets_[0]) {
-    invalidated_textures_ = &invalidated_textures_sets_[1];
-  } else {
-    invalidated_textures_ = &invalidated_textures_sets_[0];
-  }
-  invalidated_textures_mutex_.unlock();
-  if (invalidated_textures.empty()) {
-    return;
-  }
-
-  for (auto& entry : invalidated_textures) {
-    EvictTexture(entry);
-  }
-  invalidated_textures.clear();
-}
-
-void TextureCache::Clear() {
-  EvictAllTextures();
-
-  // Samplers must go last, as textures depend on them.
-  while (sampler_entries_.size()) {
-    auto entry = sampler_entries_.begin()->second;
-    EvictSampler(entry);
-  }
-}
-
-void TextureCache::EvictAllTextures() {
-  // Kill all textures - some may be in the eviction list, but that's fine
-  // as we will clear that below.
-  while (!texture_entries_.empty()) {
-    auto entry = texture_entries_.begin()->second;
-    EvictTexture(entry);
-  }
-
-  {
-    std::lock_guard<std::mutex> lock(invalidated_textures_mutex_);
-    invalidated_textures_sets_[0].clear();
-    invalidated_textures_sets_[1].clear();
-  }
-
-  // Kill all readbuffer textures.
-  while (!read_buffer_textures_.empty()) {
-    auto it = --read_buffer_textures_.end();
-    auto entry = *it;
-    glDeleteTextures(1, &entry->handle);
-    delete entry;
-    read_buffer_textures_.erase(it);
-  }
-}
-
-TextureCache::TextureEntryView* TextureCache::Demand(
-    const TextureInfo& texture_info, const SamplerInfo& sampler_info) {
-  uint64_t texture_hash = texture_info.hash();
-  auto texture_entry = LookupOrInsertTexture(texture_info, texture_hash);
-  if (!texture_entry) {
-    XELOGE("Failed to setup texture");
-    return nullptr;
-  }
-
-  // We likely have the sampler in the texture view listing, so scan for it.
-  uint64_t sampler_hash = sampler_info.hash();
-  for (auto& it : texture_entry->views) {
-    if (it->sampler_hash == sampler_hash) {
-      // Found.
-      return it.get();
-    }
-  }
-
-  // No existing view found - build it.
-  auto sampler_entry = LookupOrInsertSampler(sampler_info, sampler_hash);
-  if (!sampler_entry) {
-    XELOGE("Failed to setup texture sampler");
-    return nullptr;
-  }
-
-  auto view = std::make_unique<TextureEntryView>();
-  view->texture = texture_entry;
-  view->sampler = sampler_entry;
-  view->sampler_hash = sampler_hash;
-  view->texture_sampler_handle = 0;
-
-  // Get the uvec2 handle to the texture/sampler pair and make it resident.
-  // The handle can be passed directly to the shader.
-  view->texture_sampler_handle = glGetTextureSamplerHandleARB(
-      texture_entry->handle, sampler_entry->handle);
-  if (!view->texture_sampler_handle) {
-    assert_always("Unable to get texture handle?");
-    return nullptr;
-  }
-  glMakeTextureHandleResidentARB(view->texture_sampler_handle);
-
-  // Entry takes ownership.
-  auto view_ptr = view.get();
-  texture_entry->views.push_back(std::move(view));
-  return view_ptr;
-}
-
-TextureCache::SamplerEntry* TextureCache::LookupOrInsertSampler(
-    const SamplerInfo& sampler_info, uint64_t opt_hash) {
-  const uint64_t hash = opt_hash ? opt_hash : sampler_info.hash();
-  for (auto it = sampler_entries_.find(hash); it != sampler_entries_.end();
-       ++it) {
-    if (it->second->sampler_info == sampler_info) {
-      // Found in cache!
-      return it->second;
-    }
-  }
-
-  // Not found, create.
-  auto entry = std::make_unique<SamplerEntry>();
-  entry->sampler_info = sampler_info;
-  glCreateSamplers(1, &entry->handle);
-
-  // TODO(benvanik): border color from texture fetch.
-  GLfloat border_color[4] = {0.0f};
-  glSamplerParameterfv(entry->handle, GL_TEXTURE_BORDER_COLOR, border_color);
-
-  // TODO(benvanik): setup LODs for mipmapping.
-  glSamplerParameterf(entry->handle, GL_TEXTURE_LOD_BIAS, 0.0f);
-  glSamplerParameterf(entry->handle, GL_TEXTURE_MIN_LOD, 0.0f);
-  glSamplerParameterf(entry->handle, GL_TEXTURE_MAX_LOD, 0.0f);
-
-  // Texture wrapping modes.
-  // TODO(benvanik): not sure if the middle ones are correct.
-  static const GLenum wrap_map[] = {
-      GL_REPEAT,                      //
-      GL_MIRRORED_REPEAT,             //
-      GL_CLAMP_TO_EDGE,               //
-      GL_MIRROR_CLAMP_TO_EDGE,        //
-      GL_CLAMP_TO_BORDER,             // ?
-      GL_MIRROR_CLAMP_TO_BORDER_EXT,  // ?
-      GL_CLAMP_TO_BORDER,             //
-      GL_MIRROR_CLAMP_TO_BORDER_EXT,  //
-  };
-  glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_S,
-                      wrap_map[static_cast<int>(sampler_info.clamp_u)]);
-  glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_T,
-                      wrap_map[static_cast<int>(sampler_info.clamp_v)]);
-  glSamplerParameteri(entry->handle, GL_TEXTURE_WRAP_R,
-                      wrap_map[static_cast<int>(sampler_info.clamp_w)]);
-
-  // Texture level filtering.
-  GLenum min_filter;
-  switch (sampler_info.min_filter) {
-    case TextureFilter::kPoint:
-      switch (sampler_info.mip_filter) {
-        case TextureFilter::kBaseMap:
-          min_filter = GL_NEAREST;
-          break;
-        case TextureFilter::kPoint:
-          // min_filter = GL_NEAREST_MIPMAP_NEAREST;
-          min_filter = GL_NEAREST;
-          break;
-        case TextureFilter::kLinear:
-          // min_filter = GL_NEAREST_MIPMAP_LINEAR;
-          min_filter = GL_NEAREST;
-          break;
-        default:
-          assert_unhandled_case(sampler_info.mip_filter);
-          return nullptr;
-      }
-      break;
-    case TextureFilter::kLinear:
-      switch (sampler_info.mip_filter) {
-        case TextureFilter::kBaseMap:
-          min_filter = GL_LINEAR;
-          break;
-        case TextureFilter::kPoint:
-          // min_filter = GL_LINEAR_MIPMAP_NEAREST;
-          min_filter = GL_LINEAR;
-          break;
-        case TextureFilter::kLinear:
-          // min_filter = GL_LINEAR_MIPMAP_LINEAR;
-          min_filter = GL_LINEAR;
-          break;
-        default:
-          assert_unhandled_case(sampler_info.mip_filter);
-          return nullptr;
-      }
-      break;
-    default:
-      assert_unhandled_case(sampler_info.min_filter);
-      return nullptr;
-  }
-  GLenum mag_filter;
-  switch (sampler_info.mag_filter) {
-    case TextureFilter::kPoint:
-      mag_filter = GL_NEAREST;
-      break;
-    case TextureFilter::kLinear:
-      mag_filter = GL_LINEAR;
-      break;
-    default:
-      assert_unhandled_case(mag_filter);
-      return nullptr;
-  }
-  glSamplerParameteri(entry->handle, GL_TEXTURE_MIN_FILTER, min_filter);
-  glSamplerParameteri(entry->handle, GL_TEXTURE_MAG_FILTER, mag_filter);
-
-  GLfloat aniso;
-  switch (sampler_info.aniso_filter) {
-    case AnisoFilter::kDisabled:
-      aniso = 0.0f;
-      break;
-    case AnisoFilter::kMax_1_1:
-      aniso = 1.0f;
-      break;
-    case AnisoFilter::kMax_2_1:
-      aniso = 2.0f;
-      break;
-    case AnisoFilter::kMax_4_1:
-      aniso = 4.0f;
-      break;
-    case AnisoFilter::kMax_8_1:
-      aniso = 8.0f;
-      break;
-    case AnisoFilter::kMax_16_1:
-      aniso = 16.0f;
-      break;
-    default:
-      assert_unhandled_case(aniso);
-      return nullptr;
-  }
-
-  if (aniso) {
-    glSamplerParameterf(entry->handle, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso);
-  }
-
-  // Add to map - map takes ownership.
-  auto entry_ptr = entry.get();
-  sampler_entries_.insert({hash, entry.release()});
-  return entry_ptr;
-}
-
-void TextureCache::EvictSampler(SamplerEntry* entry) {
-  glDeleteSamplers(1, &entry->handle);
-
-  for (auto it = sampler_entries_.find(entry->sampler_info.hash());
-       it != sampler_entries_.end(); ++it) {
-    if (it->second == entry) {
-      sampler_entries_.erase(it);
-      break;
-    }
-  }
-
-  delete entry;
-}
-
-TextureCache::TextureEntry* TextureCache::LookupOrInsertTexture(
-    const TextureInfo& texture_info, uint64_t opt_hash) {
-  const uint64_t hash = opt_hash ? opt_hash : texture_info.hash();
-  for (auto it = texture_entries_.find(hash); it != texture_entries_.end();
-       ++it) {
-    if (it->second->pending_invalidation) {
-      // Whoa, we've been invalidated! Let's scavenge to cleanup and try again.
-      // TODO(benvanik): reuse existing texture storage.
-      Scavenge();
-      break;
-    }
-    if (it->second->texture_info == texture_info) {
-      // Found in cache!
-      return it->second;
-    }
-  }
-
-  // Not found, create.
-  auto entry = std::make_unique<TextureEntry>();
-  entry->texture_info = texture_info;
-  entry->access_watch_handle = 0;
-  entry->pending_invalidation = false;
-  entry->handle = 0;
-
-  // Check read buffer textures - there may be one waiting for us.
-  // TODO(benvanik): speed up existence check?
-  for (auto it = read_buffer_textures_.begin();
-       it != read_buffer_textures_.end(); ++it) {
-    auto read_buffer_entry = *it;
-    if (read_buffer_entry->guest_address == texture_info.guest_address &&
-        read_buffer_entry->block_width == texture_info.size_2d.block_width &&
-        read_buffer_entry->block_height == texture_info.size_2d.block_height) {
-      // Found! Acquire the handle and remove the readbuffer entry.
-      read_buffer_textures_.erase(it);
-      entry->handle = read_buffer_entry->handle;
-      entry->access_watch_handle = read_buffer_entry->access_watch_handle;
-      delete read_buffer_entry;
-      // TODO(benvanik): set more texture properties? swizzle/etc?
-      auto entry_ptr = entry.get();
-      texture_entries_.insert({hash, entry.release()});
-      return entry_ptr;
-    }
-  }
-
-  GLenum target;
-  switch (texture_info.dimension) {
-    case Dimension::k1D:
-      target = GL_TEXTURE_1D;
-      break;
-    case Dimension::k2D:
-      target = GL_TEXTURE_2D;
-      break;
-    case Dimension::k3D:
-      target = GL_TEXTURE_3D;
-      break;
-    case Dimension::kCube:
-      target = GL_TEXTURE_CUBE_MAP;
-      break;
-  }
-
-  // Setup the base texture.
-  glCreateTextures(target, 1, &entry->handle);
-
-  // TODO(benvanik): texture mip levels.
-  glTextureParameteri(entry->handle, GL_TEXTURE_BASE_LEVEL, 0);
-  glTextureParameteri(entry->handle, GL_TEXTURE_MAX_LEVEL, 1);
-
-  // Upload/convert.
-  bool uploaded = false;
-  switch (texture_info.dimension) {
-    case Dimension::k1D:
-      uploaded = UploadTexture1D(entry->handle, texture_info);
-      break;
-    case Dimension::k2D:
-      uploaded = UploadTexture2D(entry->handle, texture_info);
-      break;
-    case Dimension::kCube:
-      uploaded = UploadTextureCube(entry->handle, texture_info);
-      break;
-    case Dimension::k3D:
-      assert_unhandled_case(texture_info.dimension);
-      return nullptr;
-  }
-  if (!uploaded) {
-    XELOGE("Failed to convert/upload texture");
-    return nullptr;
-  }
-
-  // Add a write watch. If any data in the given range is touched we'll get a
-  // callback and evict the texture. We could reuse the storage, though the
-  // driver is likely in a better position to pool that kind of stuff.
-  entry->access_watch_handle = memory_->AddPhysicalAccessWatch(
-      texture_info.guest_address, texture_info.input_length,
-      cpu::MMIOHandler::kWatchWrite,
-      [](void* context_ptr, void* data_ptr, uint32_t address) {
-        auto self = reinterpret_cast<TextureCache*>(context_ptr);
-        auto touched_entry = reinterpret_cast<TextureEntry*>(data_ptr);
-        // Clear watch handle first so we don't redundantly
-        // remove.
-        touched_entry->access_watch_handle = 0;
-        touched_entry->pending_invalidation = true;
-        // Add to pending list so Scavenge will clean it up.
-        self->invalidated_textures_mutex_.lock();
-        self->invalidated_textures_->push_back(touched_entry);
-        self->invalidated_textures_mutex_.unlock();
-      },
-      this, entry.get());
-
-  // Add to map - map takes ownership.
-  auto entry_ptr = entry.get();
-  texture_entries_.insert({hash, entry.release()});
-  return entry_ptr;
-}
-
-TextureCache::TextureEntry* TextureCache::LookupAddress(uint32_t guest_address,
-                                                        uint32_t width,
-                                                        uint32_t height,
-                                                        TextureFormat format) {
-  // TODO(benvanik): worth speeding up?
-  for (auto it = texture_entries_.begin(); it != texture_entries_.end(); ++it) {
-    const auto& texture_info = it->second->texture_info;
-    if (texture_info.guest_address == guest_address &&
-        texture_info.dimension == Dimension::k2D &&
-        texture_info.size_2d.input_width == width &&
-        texture_info.size_2d.input_height == height) {
-      return it->second;
-    }
-  }
-  return nullptr;
-}
-
-GLuint TextureCache::CopyTexture(Blitter* blitter, uint32_t guest_address,
-                                 uint32_t logical_width,
-                                 uint32_t logical_height, uint32_t block_width,
-                                 uint32_t block_height, TextureFormat format,
-                                 bool swap_channels, GLuint src_texture,
-                                 Rect2D src_rect, Rect2D dest_rect) {
-  return ConvertTexture(blitter, guest_address, logical_width, logical_height,
-                        block_width, block_height, format, swap_channels,
-                        src_texture, src_rect, dest_rect);
-}
-
-GLuint TextureCache::ConvertTexture(Blitter* blitter, uint32_t guest_address,
-                                    uint32_t logical_width,
-                                    uint32_t logical_height,
-                                    uint32_t block_width, uint32_t block_height,
-                                    TextureFormat format, bool swap_channels,
-                                    GLuint src_texture, Rect2D src_rect,
-                                    Rect2D dest_rect) {
-  const auto& config = texture_configs[uint32_t(format)];
-  if (config.format == GL_INVALID_ENUM) {
-    assert_always("Unhandled destination texture format");
-    return 0;
-  }
-
-  // See if we have used a texture at this address before. If we have, we can
-  // reuse it.
-  // TODO(benvanik): better lookup matching format/etc?
-  auto texture_entry =
-      LookupAddress(guest_address, block_width, block_height, format);
-  if (texture_entry) {
-    // Have existing texture.
-    assert_false(texture_entry->pending_invalidation);
-    if (config.format == GL_DEPTH_STENCIL) {
-      blitter->CopyDepthTexture(src_texture, src_rect, texture_entry->handle,
-                                dest_rect);
-    } else {
-      blitter->CopyColorTexture2D(src_texture, src_rect, texture_entry->handle,
-                                  dest_rect, GL_LINEAR, swap_channels);
-    }
-
-    // Setup a read/write access watch. If the game tries to touch the memory
-    // we were supposed to populate with this texture, then we'll actually
-    // populate it.
-    if (texture_entry->access_watch_handle) {
-      memory_->CancelAccessWatch(texture_entry->access_watch_handle);
-      texture_entry->access_watch_handle = 0;
-    }
-
-    texture_entry->access_watch_handle = memory_->AddPhysicalAccessWatch(
-        guest_address, texture_entry->texture_info.input_length,
-        cpu::MMIOHandler::kWatchReadWrite,
-        [](void* context, void* data, uint32_t address) {
-          auto touched_entry = reinterpret_cast<TextureEntry*>(data);
-          touched_entry->access_watch_handle = 0;
-
-          // This happens. RDR resolves to a texture then upsizes it, BF1943
-          // writes to a resolved texture.
-          // TODO (for Vulkan): Copy this texture back into system memory.
-          // assert_always();
-        },
-        nullptr, texture_entry);
-
-    return texture_entry->handle;
-  }
-
-  // Check pending read buffer textures (for multiple resolves with no
-  // uploads inbetween).
-  for (auto it = read_buffer_textures_.begin();
-       it != read_buffer_textures_.end(); ++it) {
-    const auto& entry = *it;
-    if (entry->guest_address == guest_address &&
-        entry->logical_width == logical_width &&
-        entry->logical_height == logical_height && entry->format == format) {
-      // Found an existing entry - just reupload.
-      if (config.format == GL_DEPTH_STENCIL) {
-        blitter->CopyDepthTexture(src_texture, src_rect, entry->handle,
-                                  dest_rect);
-      } else {
-        blitter->CopyColorTexture2D(src_texture, src_rect, entry->handle,
-                                    dest_rect, GL_LINEAR, swap_channels);
-      }
-      return entry->handle;
-    }
-  }
-
-  // Need to create a new texture.
-  // As we don't know anything about this texture, we'll add it to the
-  // pending readbuffer list. If nobody claims it after a certain amount
-  // of time we'll dump it.
-  auto entry = std::make_unique<ReadBufferTexture>();
-  entry->guest_address = guest_address;
-  entry->logical_width = logical_width;
-  entry->logical_height = logical_height;
-  entry->block_width = block_width;
-  entry->block_height = block_height;
-  entry->format = format;
-
-  entry->access_watch_handle = memory_->AddPhysicalAccessWatch(
-      guest_address, block_height * block_width * 4,
-      cpu::MMIOHandler::kWatchReadWrite,
-      [](void* context, void* data, uint32_t address) {
-        auto entry = reinterpret_cast<ReadBufferTexture*>(data);
-        entry->access_watch_handle = 0;
-
-        // This happens. RDR resolves to a texture then upsizes it, BF1943
-        // writes to a resolved texture.
-        // TODO (for Vulkan): Copy this texture back into system memory.
-        // assert_always();
-      },
-      nullptr, entry.get());
-
-  glCreateTextures(GL_TEXTURE_2D, 1, &entry->handle);
-  glTextureParameteri(entry->handle, GL_TEXTURE_BASE_LEVEL, 0);
-  glTextureParameteri(entry->handle, GL_TEXTURE_MAX_LEVEL, 1);
-  glTextureStorage2D(entry->handle, 1, config.internal_format, logical_width,
-                     logical_height);
-  if (config.format == GL_DEPTH_STENCIL) {
-    blitter->CopyDepthTexture(src_texture, src_rect, entry->handle, dest_rect);
-  } else {
-    blitter->CopyColorTexture2D(src_texture, src_rect, entry->handle, dest_rect,
-                                GL_LINEAR, swap_channels);
-  }
-
-  GLuint handle = entry->handle;
-  read_buffer_textures_.push_back(entry.release());
-  return handle;
-}
-
-void TextureCache::EvictTexture(TextureEntry* entry) {
-  if (entry->access_watch_handle) {
-    memory_->CancelAccessWatch(entry->access_watch_handle);
-    entry->access_watch_handle = 0;
-  }
-
-  for (auto& view : entry->views) {
-    glMakeTextureHandleNonResidentARB(view->texture_sampler_handle);
-  }
-  glDeleteTextures(1, &entry->handle);
-
-  uint64_t texture_hash = entry->texture_info.hash();
-  for (auto it = texture_entries_.find(texture_hash);
-       it != texture_entries_.end(); ++it) {
-    if (it->second == entry) {
-      texture_entries_.erase(it);
-      break;
-    }
-  }
-
-  delete entry;
-}
-
-struct HostTextureInfo {
-  uint32_t output_length;
-
-  union {
-    struct {
-      uint32_t output_width;
-      uint32_t output_pitch;
-    } size_1d;
-    struct {
-      uint32_t output_width;
-      uint32_t output_height;
-      uint32_t output_pitch;
-    } size_2d;
-    struct {
-    } size_3d;
-    struct {
-      uint32_t output_width;
-      uint32_t output_height;
-      uint32_t output_pitch;
-      uint32_t output_face_length;
-    } size_cube;
-  };
-
-  static bool Setup(const TextureInfo& guest_info, HostTextureInfo* out_info) {
-    auto& info = *out_info;
-    auto format = guest_info.format_info();
-
-    switch (guest_info.dimension) {
-      case Dimension::k1D: {
-        uint32_t bytes_per_block =
-            format->block_width * format->bits_per_pixel / 8;
-        uint32_t block_width = xe::round_up(guest_info.size_1d.logical_width,
-                                            format->block_width) /
-                               format->block_width;
-        info.size_1d.output_width = block_width * format->block_width;
-        info.size_1d.output_pitch = block_width * bytes_per_block;
-        info.output_length = info.size_1d.output_pitch;
-        return true;
-      }
-      case Dimension::k2D: {
-        uint32_t bytes_per_block = format->block_width * format->block_height *
-                                   format->bits_per_pixel / 8;
-        uint32_t block_width = xe::round_up(guest_info.size_2d.logical_width,
-                                            format->block_width) /
-                               format->block_width;
-        uint32_t block_height = xe::round_up(guest_info.size_2d.logical_height,
-                                             format->block_height) /
-                                format->block_height;
-        info.size_2d.output_width = block_width * format->block_width;
-        info.size_2d.output_height = block_height * format->block_height;
-        info.size_2d.output_pitch = block_width * bytes_per_block;
-        info.output_length = info.size_2d.output_pitch * block_height;
-        return true;
-      };
-      case Dimension::k3D: {
-        return false;
-      }
-      case Dimension::kCube: {
-        uint32_t bytes_per_block = format->block_width * format->block_height *
-                                   format->bits_per_pixel / 8;
-        uint32_t block_width = xe::round_up(guest_info.size_cube.logical_width,
-                                            format->block_width) /
-                               format->block_width;
-        uint32_t block_height =
-            xe::round_up(guest_info.size_cube.logical_height,
-                         format->block_height) /
-            format->block_height;
-        info.size_cube.output_width = block_width * format->block_width;
-        info.size_cube.output_height = block_height * format->block_height;
-        info.size_cube.output_pitch = block_width * bytes_per_block;
-        info.size_cube.output_face_length =
-            info.size_cube.output_pitch * block_height;
-        info.output_length = info.size_cube.output_face_length * 6;
-        return true;
-      }
-    }
-    return false;
-  }
-};
-
-void TextureSwap(Endian endianness, void* dest, const void* src,
-                 size_t length) {
-  switch (endianness) {
-    case Endian::k8in16:
-      xe::copy_and_swap_16_aligned(dest, src, length / 2);
-      break;
-    case Endian::k8in32:
-      xe::copy_and_swap_32_aligned(dest, src, length / 4);
-      break;
-    case Endian::k16in32:  // Swap high and low 16 bits within a 32 bit word
-      xe::copy_and_swap_16_in_32_aligned(dest, src, length);
-      break;
-    default:
-    case Endian::kUnspecified:
-      std::memcpy(dest, src, length);
-      break;
-  }
-}
-
-bool TextureCache::UploadTexture1D(GLuint texture,
-                                   const TextureInfo& texture_info) {
-  SCOPE_profile_cpu_f("gpu");
-  const auto host_address =
-      memory_->TranslatePhysical(texture_info.guest_address);
-
-  const auto& config = texture_configs[uint32_t(texture_info.texture_format)];
-  if (config.format == GL_INVALID_ENUM) {
-    assert_always("Unhandled texture format");
-    return false;
-  }
-
-  HostTextureInfo host_info;
-  if (!HostTextureInfo::Setup(texture_info, &host_info)) {
-    assert_always("Failed to set up host texture info");
-    return false;
-  }
-
-  size_t unpack_length = host_info.output_length;
-  glTextureStorage1D(texture, 1, config.internal_format,
-                     host_info.size_1d.output_width);
-
-  auto allocation = scratch_buffer_->Acquire(unpack_length);
-
-  if (!texture_info.is_tiled) {
-    if (texture_info.size_1d.input_pitch == host_info.size_1d.output_pitch) {
-      TextureSwap(texture_info.endianness, allocation.host_ptr, host_address,
-                  unpack_length);
-    } else {
-      assert_always();
-    }
-  } else {
-    assert_always();
-  }
-  size_t unpack_offset = allocation.offset;
-  scratch_buffer_->Commit(std::move(allocation));
-  // TODO(benvanik): avoid flush on entire buffer by using another texture
-  // buffer.
-  scratch_buffer_->Flush();
-
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle());
-  if (texture_info.is_compressed()) {
-    glCompressedTextureSubImage1D(texture, 0, 0, host_info.size_1d.output_width,
-                                  config.format,
-                                  static_cast<GLsizei>(unpack_length),
-                                  reinterpret_cast<void*>(unpack_offset));
-  } else {
-    // Most of these don't seem to have an effect on compressed images.
-    // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE);
-    // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch);
-    // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    glTextureSubImage1D(texture, 0, 0, host_info.size_1d.output_width,
-                        config.format, config.type,
-                        reinterpret_cast<void*>(unpack_offset));
-  }
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-  return true;
-}
-
-bool TextureCache::UploadTexture2D(GLuint texture,
-                                   const TextureInfo& texture_info) {
-  SCOPE_profile_cpu_f("gpu");
-  const auto host_address =
-      memory_->TranslatePhysical(texture_info.guest_address);
-
-  const auto& config =
-      texture_configs[uint32_t(texture_info.format_info()->format)];
-  if (config.format == GL_INVALID_ENUM) {
-    assert_always("Unhandled texture format");
-    return false;
-  }
-
-  HostTextureInfo host_info;
-  if (!HostTextureInfo::Setup(texture_info, &host_info)) {
-    assert_always("Failed to set up host texture info");
-    return false;
-  }
-
-  size_t unpack_length = host_info.output_length;
-  glTextureStorage2D(texture, 1, config.internal_format,
-                     host_info.size_2d.output_width,
-                     host_info.size_2d.output_height);
-
-  auto allocation = scratch_buffer_->Acquire(unpack_length);
-
-  if (!texture_info.is_tiled) {
-    uint32_t offset_x, offset_y;
-    if (texture_info.has_packed_mips &&
-        TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y)) {
-      uint32_t bytes_per_block = texture_info.format_info()->block_width *
-                                 texture_info.format_info()->block_height *
-                                 texture_info.format_info()->bits_per_pixel / 8;
-      const uint8_t* src = host_address;
-      // TODO(gibbed): this needs checking
-      src += offset_y * texture_info.size_2d.input_pitch;
-      src += offset_x * bytes_per_block;
-      uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr);
-      uint32_t pitch = std::min(texture_info.size_2d.input_pitch,
-                                host_info.size_2d.output_pitch);
-      for (uint32_t y = 0; y < std::min(texture_info.size_2d.block_height,
-                                        texture_info.size_2d.logical_height);
-           y++) {
-        TextureSwap(texture_info.endianness, dest, src, pitch);
-        src += texture_info.size_2d.input_pitch;
-        dest += host_info.size_2d.output_pitch;
-      }
-    } else if (texture_info.size_2d.input_pitch ==
-               host_info.size_2d.output_pitch) {
-      // Fast path copy entire image.
-      TextureSwap(texture_info.endianness, allocation.host_ptr, host_address,
-                  unpack_length);
-    } else {
-      // Slow path copy row-by-row because strides differ.
-      // UNPACK_ROW_LENGTH only works for uncompressed images, and likely does
-      // this exact thing under the covers, so we just always do it here.
-      const uint8_t* src = host_address;
-      uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr);
-      uint32_t pitch = std::min(texture_info.size_2d.input_pitch,
-                                host_info.size_2d.output_pitch);
-      for (uint32_t y = 0; y < std::min(texture_info.size_2d.block_height,
-                                        texture_info.size_2d.logical_height);
-           y++) {
-        TextureSwap(texture_info.endianness, dest, src, pitch);
-        src += texture_info.size_2d.input_pitch;
-        dest += host_info.size_2d.output_pitch;
-      }
-    }
-  } else {
-    // Untile image.
-    // We could do this in a shader to speed things up, as this is pretty slow.
-
-    // TODO(benvanik): optimize this inner loop (or work by tiles).
-    const uint8_t* src = host_address;
-    uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr);
-    uint32_t bytes_per_block = texture_info.format_info()->block_width *
-                               texture_info.format_info()->block_height *
-                               texture_info.format_info()->bits_per_pixel / 8;
-
-    // Tiled textures can be packed; get the offset into the packed texture.
-    uint32_t offset_x;
-    uint32_t offset_y;
-    TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y);
-
-    auto bpp = (bytes_per_block >> 2) +
-               ((bytes_per_block >> 1) >> (bytes_per_block >> 2));
-    for (uint32_t y = 0, output_base_offset = 0;
-         y < std::min(texture_info.size_2d.block_height,
-                      texture_info.size_2d.logical_height);
-         y++, output_base_offset += host_info.size_2d.output_pitch) {
-      auto input_base_offset = TextureInfo::TiledOffset2DOuter(
-          offset_y + y,
-          (texture_info.size_2d.input_width /
-           texture_info.format_info()->block_width),
-          bpp);
-      for (uint32_t x = 0, output_offset = output_base_offset;
-           x < texture_info.size_2d.block_width;
-           x++, output_offset += bytes_per_block) {
-        auto input_offset =
-            TextureInfo::TiledOffset2DInner(offset_x + x, offset_y + y, bpp,
-                                            input_base_offset) >>
-            bpp;
-        TextureSwap(texture_info.endianness, dest + output_offset,
-                    src + input_offset * bytes_per_block, bytes_per_block);
-      }
-    }
-  }
-  size_t unpack_offset = allocation.offset;
-  scratch_buffer_->Commit(std::move(allocation));
-  // TODO(benvanik): avoid flush on entire buffer by using another texture
-  // buffer.
-  scratch_buffer_->Flush();
-
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle());
-  if (texture_info.is_compressed()) {
-    glCompressedTextureSubImage2D(
-        texture, 0, 0, 0, host_info.size_2d.output_width,
-        host_info.size_2d.output_height, config.format,
-        static_cast<GLsizei>(unpack_length),
-        reinterpret_cast<void*>(unpack_offset));
-  } else {
-    // Most of these don't seem to have an effect on compressed images.
-    // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE);
-    // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch);
-    // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    glTextureSubImage2D(texture, 0, 0, 0, host_info.size_2d.output_width,
-                        host_info.size_2d.output_height, config.format,
-                        config.type, reinterpret_cast<void*>(unpack_offset));
-  }
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-  return true;
-}
-
-bool TextureCache::UploadTextureCube(GLuint texture,
-                                     const TextureInfo& texture_info) {
-  SCOPE_profile_cpu_f("gpu");
-  const auto host_address =
-      memory_->TranslatePhysical(texture_info.guest_address);
-
-  const auto& config =
-      texture_configs[uint32_t(texture_info.format_info()->format)];
-  if (config.format == GL_INVALID_ENUM) {
-    assert_always("Unhandled texture format");
-    return false;
-  }
-
-  HostTextureInfo host_info;
-  if (!HostTextureInfo::Setup(texture_info, &host_info)) {
-    assert_always("Failed to set up host texture info");
-    return false;
-  }
-
-  size_t unpack_length = host_info.output_length;
-  glTextureStorage2D(texture, 1, config.internal_format,
-                     host_info.size_cube.output_width,
-                     host_info.size_cube.output_height);
-
-  auto allocation = scratch_buffer_->Acquire(unpack_length);
-  if (!texture_info.is_tiled) {
-    if (texture_info.size_cube.input_pitch ==
-        host_info.size_cube.output_pitch) {
-      // Fast path copy entire image.
-      TextureSwap(texture_info.endianness, allocation.host_ptr, host_address,
-                  unpack_length);
-    } else {
-      // Slow path copy row-by-row because strides differ.
-      // UNPACK_ROW_LENGTH only works for uncompressed images, and likely does
-      // this exact thing under the covers, so we just always do it here.
-      const uint8_t* src = host_address;
-      uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr);
-      for (int face = 0; face < 6; ++face) {
-        uint32_t pitch = std::min(texture_info.size_cube.input_pitch,
-                                  host_info.size_cube.output_pitch);
-        for (uint32_t y = 0; y < texture_info.size_cube.block_height; y++) {
-          TextureSwap(texture_info.endianness, dest, src, pitch);
-          src += texture_info.size_cube.input_pitch;
-          dest += host_info.size_cube.output_pitch;
-        }
-      }
-    }
-  } else {
-    // TODO(benvanik): optimize this inner loop (or work by tiles).
-    const uint8_t* src = host_address;
-    uint8_t* dest = reinterpret_cast<uint8_t*>(allocation.host_ptr);
-    uint32_t bytes_per_block = texture_info.format_info()->block_width *
-                               texture_info.format_info()->block_height *
-                               texture_info.format_info()->bits_per_pixel / 8;
-    // Tiled textures can be packed; get the offset into the packed texture.
-    uint32_t offset_x;
-    uint32_t offset_y;
-    TextureInfo::GetPackedTileOffset(texture_info, &offset_x, &offset_y);
-    auto bpp = (bytes_per_block >> 2) +
-               ((bytes_per_block >> 1) >> (bytes_per_block >> 2));
-    for (int face = 0; face < 6; ++face) {
-      for (uint32_t y = 0, output_base_offset = 0;
-           y < texture_info.size_cube.block_height;
-           y++, output_base_offset += host_info.size_cube.output_pitch) {
-        auto input_base_offset = TextureInfo::TiledOffset2DOuter(
-            offset_y + y,
-            (texture_info.size_cube.input_width /
-             texture_info.format_info()->block_width),
-            bpp);
-        for (uint32_t x = 0, output_offset = output_base_offset;
-             x < texture_info.size_cube.block_width;
-             x++, output_offset += bytes_per_block) {
-          auto input_offset =
-              TextureInfo::TiledOffset2DInner(offset_x + x, offset_y + y, bpp,
-                                              input_base_offset) >>
-              bpp;
-          TextureSwap(texture_info.endianness, dest + output_offset,
-                      src + input_offset * bytes_per_block, bytes_per_block);
-        }
-      }
-      src += texture_info.size_cube.input_face_length;
-      dest += host_info.size_cube.output_face_length;
-    }
-  }
-  size_t unpack_offset = allocation.offset;
-  scratch_buffer_->Commit(std::move(allocation));
-  // TODO(benvanik): avoid flush on entire buffer by using another texture
-  // buffer.
-  scratch_buffer_->Flush();
-
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, scratch_buffer_->handle());
-  if (texture_info.is_compressed()) {
-    glCompressedTextureSubImage3D(
-        texture, 0, 0, 0, 0, host_info.size_cube.output_width,
-        host_info.size_cube.output_height, 6, config.format,
-        static_cast<GLsizei>(unpack_length),
-        reinterpret_cast<void*>(unpack_offset));
-  } else {
-    // Most of these don't seem to have an effect on compressed images.
-    // glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_TRUE);
-    // glPixelStorei(GL_UNPACK_ALIGNMENT, texture_info.texel_pitch);
-    // glPixelStorei(GL_UNPACK_ROW_LENGTH, texture_info.size_2d.input_width);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    glTextureSubImage3D(texture, 0, 0, 0, 0, host_info.size_cube.output_width,
-                        host_info.size_cube.output_height, 6, config.format,
-                        config.type, reinterpret_cast<void*>(unpack_offset));
-  }
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-  return true;
-}
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
diff --git a/src/xenia/gpu/gl4/texture_cache.h b/src/xenia/gpu/gl4/texture_cache.h
deleted file mode 100644
index 4f018c329..000000000
--- a/src/xenia/gpu/gl4/texture_cache.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_GPU_GL4_TEXTURE_CACHE_H_
-#define XENIA_GPU_GL4_TEXTURE_CACHE_H_
-
-#include <mutex>
-#include <unordered_map>
-#include <vector>
-
-#include "xenia/gpu/sampler_info.h"
-#include "xenia/gpu/texture_info.h"
-#include "xenia/memory.h"
-#include "xenia/ui/gl/blitter.h"
-#include "xenia/ui/gl/circular_buffer.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace gpu {
-namespace gl4 {
-
-using xe::ui::gl::Blitter;
-using xe::ui::gl::CircularBuffer;
-using xe::ui::gl::Rect2D;
-
-class TextureCache {
- public:
-  struct TextureEntry;
-  struct SamplerEntry {
-    SamplerInfo sampler_info;
-    GLuint handle;
-  };
-  struct TextureEntryView {
-    TextureEntry* texture;
-    SamplerEntry* sampler;
-    uint64_t sampler_hash;
-    GLuint64 texture_sampler_handle;
-  };
-  struct TextureEntry {
-    TextureInfo texture_info;
-    uintptr_t access_watch_handle;
-    GLuint handle;
-    bool pending_invalidation;
-    std::vector<std::unique_ptr<TextureEntryView>> views;
-  };
-
-  TextureCache();
-  ~TextureCache();
-
-  bool Initialize(Memory* memory, CircularBuffer* scratch_buffer);
-  void Shutdown();
-
-  void Scavenge();
-  void Clear();
-  void EvictAllTextures();
-
-  TextureEntryView* Demand(const TextureInfo& texture_info,
-                           const SamplerInfo& sampler_info);
-
-  GLuint CopyTexture(Blitter* blitter, uint32_t guest_address,
-                     uint32_t logical_width, uint32_t logical_height,
-                     uint32_t block_width, uint32_t block_height,
-                     TextureFormat format, bool swap_channels,
-                     GLuint src_texture, Rect2D src_rect, Rect2D dest_rect);
-  GLuint ConvertTexture(Blitter* blitter, uint32_t guest_address,
-                        uint32_t logical_width, uint32_t logical_height,
-                        uint32_t block_width, uint32_t block_height,
-                        TextureFormat format, bool swap_channels,
-                        GLuint src_texture, Rect2D src_rect, Rect2D dest_rect);
-
-  TextureEntry* LookupAddress(uint32_t guest_address, uint32_t width,
-                              uint32_t height, TextureFormat format);
-
- private:
-  struct ReadBufferTexture {
-    uintptr_t access_watch_handle;
-    uint32_t guest_address;
-    uint32_t logical_width;
-    uint32_t logical_height;
-    uint32_t block_width;
-    uint32_t block_height;
-    TextureFormat format;
-    GLuint handle;
-  };
-
-  SamplerEntry* LookupOrInsertSampler(const SamplerInfo& sampler_info,
-                                      uint64_t opt_hash = 0);
-  void EvictSampler(SamplerEntry* entry);
-  TextureEntry* LookupOrInsertTexture(const TextureInfo& texture_info,
-                                      uint64_t opt_hash = 0);
-  void EvictTexture(TextureEntry* entry);
-
-  bool UploadTexture1D(GLuint texture, const TextureInfo& texture_info);
-  bool UploadTexture2D(GLuint texture, const TextureInfo& texture_info);
-  bool UploadTextureCube(GLuint texture, const TextureInfo& texture_info);
-
-  Memory* memory_;
-  CircularBuffer* scratch_buffer_;
-  std::unordered_map<uint64_t, SamplerEntry*> sampler_entries_;
-  std::unordered_map<uint64_t, TextureEntry*> texture_entries_;
-
-  std::vector<ReadBufferTexture*> read_buffer_textures_;
-
-  std::mutex invalidated_textures_mutex_;
-  std::vector<TextureEntry*>* invalidated_textures_;
-  std::vector<TextureEntry*> invalidated_textures_sets_[2];
-};
-
-}  // namespace gl4
-}  // namespace gpu
-}  // namespace xe
-
-#endif  // XENIA_GPU_GL4_TEXTURE_CACHE_H_
diff --git a/src/xenia/hid/premake5.lua b/src/xenia/hid/premake5.lua
index dbe4f7b81..b1044efa1 100644
--- a/src/xenia/hid/premake5.lua
+++ b/src/xenia/hid/premake5.lua
@@ -30,7 +30,6 @@ project("xenia-hid-demo")
     "xenia-hid",
     "xenia-hid-nop",
     "xenia-ui",
-    "xenia-ui-gl",
   })
   filter("platforms:Linux")
     links({
diff --git a/src/xenia/ui/gl/blitter.cc b/src/xenia/ui/gl/blitter.cc
deleted file mode 100644
index 7501758ca..000000000
--- a/src/xenia/ui/gl/blitter.cc
+++ /dev/null
@@ -1,315 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/blitter.h"
-
-#include <string>
-
-#include "xenia/base/assert.h"
-#include "xenia/base/math.h"
-#include "xenia/ui/gl/gl_context.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-Blitter::Blitter()
-    : vertex_program_(0),
-      color_fragment_program_(0),
-      depth_fragment_program_(0),
-      color_pipeline_(0),
-      depth_pipeline_(0),
-      vbo_(0),
-      vao_(0),
-      nearest_sampler_(0),
-      linear_sampler_(0),
-      scratch_framebuffer_(0) {}
-
-Blitter::~Blitter() = default;
-
-bool Blitter::Initialize() {
-  const std::string header =
-      R"(
-#version 450
-#extension GL_ARB_explicit_uniform_location : require
-#extension GL_ARB_shading_language_420pack : require
-precision highp float;
-precision highp int;
-layout(std140, column_major) uniform;
-layout(std430, column_major) buffer;
-)";
-  const std::string vs_source = header +
-                                R"(
-layout(location = 0) uniform vec4 src_uv;
-out gl_PerVertex {
-  vec4 gl_Position;
-  float gl_PointSize;
-  float gl_ClipDistance[];
-};
-layout(location = 0) in vec2 vfetch_pos;
-layout(location = 0) out vec2 vtx_uv;
-void main() {
-  gl_Position = vec4(vfetch_pos.xy * vec2(2.0, -2.0) -
-                vec2(1.0, -1.0), 0.0, 1.0);
-  vtx_uv = vfetch_pos.xy * src_uv.zw + src_uv.xy;
-})";
-  const std::string color_fs_source = header +
-                                      R"(
-layout(location = 1) uniform sampler2D src_texture;
-layout(location = 2) uniform bool swap;
-layout(location = 0) in vec2 vtx_uv;
-layout(location = 0) out vec4 oC;
-void main() {
-  oC = texture(src_texture, vtx_uv);
-  if (!swap) oC = oC.bgra;
-})";
-  const std::string depth_fs_source = header +
-                                      R"(
-layout(location = 1) uniform sampler2D src_texture;
-layout(location = 0) in vec2 vtx_uv;
-layout(location = 0) out vec4 oC;
-void main() {
-  gl_FragDepth = texture(src_texture, vtx_uv).r;
-})";
-
-  auto vs_source_str = vs_source.c_str();
-  vertex_program_ = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &vs_source_str);
-  auto color_fs_source_str = color_fs_source.c_str();
-  color_fragment_program_ =
-      glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &color_fs_source_str);
-  auto depth_fs_source_str = depth_fs_source.c_str();
-  depth_fragment_program_ =
-      glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &depth_fs_source_str);
-  glCreateProgramPipelines(1, &color_pipeline_);
-  glUseProgramStages(color_pipeline_, GL_VERTEX_SHADER_BIT, vertex_program_);
-  glUseProgramStages(color_pipeline_, GL_FRAGMENT_SHADER_BIT,
-                     color_fragment_program_);
-  glCreateProgramPipelines(1, &depth_pipeline_);
-  glUseProgramStages(depth_pipeline_, GL_VERTEX_SHADER_BIT, vertex_program_);
-  glUseProgramStages(depth_pipeline_, GL_FRAGMENT_SHADER_BIT,
-                     depth_fragment_program_);
-
-  glCreateBuffers(1, &vbo_);
-  static const GLfloat vbo_data[] = {
-      0, 0, 1, 0, 0, 1, 1, 1,
-  };
-  glNamedBufferStorage(vbo_, sizeof(vbo_data), vbo_data, 0);
-
-  glCreateVertexArrays(1, &vao_);
-  glEnableVertexArrayAttrib(vao_, 0);
-  glVertexArrayAttribBinding(vao_, 0, 0);
-  glVertexArrayAttribFormat(vao_, 0, 2, GL_FLOAT, GL_FALSE, 0);
-  glVertexArrayVertexBuffer(vao_, 0, vbo_, 0, sizeof(GLfloat) * 2);
-
-  glCreateSamplers(1, &nearest_sampler_);
-  glSamplerParameteri(nearest_sampler_, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-  glSamplerParameteri(nearest_sampler_, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  glSamplerParameteri(nearest_sampler_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glSamplerParameteri(nearest_sampler_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  glCreateSamplers(1, &linear_sampler_);
-  glSamplerParameteri(linear_sampler_, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  glSamplerParameteri(linear_sampler_, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  glSamplerParameteri(linear_sampler_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  glSamplerParameteri(linear_sampler_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-
-  glCreateFramebuffers(1, &scratch_framebuffer_);
-
-  return true;
-}
-
-void Blitter::Shutdown() {
-  glDeleteFramebuffers(1, &scratch_framebuffer_);
-  glDeleteProgram(vertex_program_);
-  glDeleteProgram(color_fragment_program_);
-  glDeleteProgram(depth_fragment_program_);
-  glDeleteProgramPipelines(1, &color_pipeline_);
-  glDeleteProgramPipelines(1, &depth_pipeline_);
-  glDeleteBuffers(1, &vbo_);
-  glDeleteVertexArrays(1, &vao_);
-  glDeleteSamplers(1, &nearest_sampler_);
-  glDeleteSamplers(1, &linear_sampler_);
-}
-
-struct SavedState {
-  GLboolean scissor_test_enabled;
-  GLboolean depth_test_enabled;
-  GLboolean depth_mask_enabled;
-  GLint depth_func;
-  GLboolean stencil_test_enabled;
-  GLboolean cull_face_enabled;
-  GLint cull_face;
-  GLint front_face;
-  GLint polygon_mode;
-  GLboolean color_mask_0_enabled[4];
-  GLboolean blend_0_enabled;
-  GLint draw_buffer;
-  GLfloat viewport[4];
-  GLint program_pipeline;
-  GLint vertex_array;
-  GLint texture_0;
-  GLint sampler_0;
-
-  void Save() {
-    scissor_test_enabled = glIsEnabled(GL_SCISSOR_TEST);
-    depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
-    glGetBooleanv(GL_DEPTH_WRITEMASK, &depth_mask_enabled);
-    glGetIntegerv(GL_DEPTH_FUNC, &depth_func);
-    stencil_test_enabled = glIsEnabled(GL_STENCIL_TEST);
-    cull_face_enabled = glIsEnabled(GL_CULL_FACE);
-    glGetIntegerv(GL_CULL_FACE_MODE, &cull_face);
-    glGetIntegerv(GL_FRONT_FACE, &front_face);
-    glGetIntegerv(GL_POLYGON_MODE, &polygon_mode);
-    glGetBooleani_v(GL_COLOR_WRITEMASK, 0,
-                    reinterpret_cast<GLboolean*>(&color_mask_0_enabled));
-    blend_0_enabled = glIsEnabledi(GL_BLEND, 0);
-    glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_buffer);
-    glGetFloati_v(GL_VIEWPORT, 0, viewport);
-    glGetIntegerv(GL_PROGRAM_PIPELINE_BINDING, &program_pipeline);
-    glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &vertex_array);
-    glGetIntegerv(GL_TEXTURE_BINDING_2D, &texture_0);
-    glGetIntegerv(GL_SAMPLER_BINDING, &sampler_0);
-  }
-
-  void Restore() {
-    scissor_test_enabled ? glEnable(GL_SCISSOR_TEST)
-                         : glDisable(GL_SCISSOR_TEST);
-    depth_test_enabled ? glEnable(GL_DEPTH_TEST) : glDisable(GL_DEPTH_TEST);
-    glDepthMask(depth_mask_enabled);
-    glDepthFunc(depth_func);
-    stencil_test_enabled ? glEnable(GL_STENCIL_TEST)
-                         : glDisable(GL_STENCIL_TEST);
-    cull_face_enabled ? glEnable(GL_CULL_FACE) : glDisable(GL_CULL_FACE);
-    glCullFace(cull_face);
-    glFrontFace(front_face);
-    glPolygonMode(GL_FRONT_AND_BACK, polygon_mode);
-    glColorMaski(0, color_mask_0_enabled[0], color_mask_0_enabled[1],
-                 color_mask_0_enabled[2], color_mask_0_enabled[3]);
-    blend_0_enabled ? glEnablei(GL_BLEND, 0) : glDisablei(GL_BLEND, 0);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_buffer);
-    glViewportIndexedf(0, viewport[0], viewport[1], viewport[2], viewport[3]);
-    glBindProgramPipeline(program_pipeline);
-    glBindVertexArray(vertex_array);
-    glBindTexture(GL_TEXTURE_2D, texture_0);
-    glBindSampler(0, sampler_0);
-  }
-};
-
-void Blitter::Draw(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect,
-                   GLenum filter) {
-  assert_not_zero(src_texture);
-
-  glDisable(GL_SCISSOR_TEST);
-  glDisable(GL_STENCIL_TEST);
-  glDisablei(GL_BLEND, 0);
-  glEnable(GL_CULL_FACE);
-  glCullFace(GL_BACK);
-  glFrontFace(GL_CW);
-  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-  glBindVertexArray(vao_);
-  glBindTextures(0, 1, &src_texture);
-  switch (filter) {
-    default:
-    case GL_NEAREST:
-      glBindSampler(0, nearest_sampler_);
-      break;
-    case GL_LINEAR:
-      glBindSampler(0, linear_sampler_);
-      break;
-  }
-
-  glViewportIndexedf(0, GLfloat(dest_rect.x), GLfloat(dest_rect.y),
-                     GLfloat(dest_rect.width), GLfloat(dest_rect.height));
-
-  // TODO(benvanik): avoid this?
-  GLint src_texture_width;
-  glGetTextureLevelParameteriv(src_texture, 0, GL_TEXTURE_WIDTH,
-                               &src_texture_width);
-  GLint src_texture_height;
-  glGetTextureLevelParameteriv(src_texture, 0, GL_TEXTURE_HEIGHT,
-                               &src_texture_height);
-  glProgramUniform4f(vertex_program_, 0,
-                     src_rect.x / static_cast<float>(src_texture_width),
-                     src_rect.y / static_cast<float>(src_texture_height),
-                     src_rect.width / static_cast<float>(src_texture_width),
-                     src_rect.height / static_cast<float>(src_texture_height));
-
-  // Useful for seeing the entire framebuffer/etc:
-  // glProgramUniform4f(vertex_program_, 0, 0.0f, 0.0f, 1.0f, 1.0f);
-
-  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-}
-
-void Blitter::BlitTexture2D(GLuint src_texture, Rect2D src_rect,
-                            Rect2D dest_rect, GLenum filter,
-                            bool swap_channels) {
-  SavedState state;
-  state.Save();
-
-  glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-  glDisable(GL_DEPTH_TEST);
-  glDepthMask(GL_FALSE);
-  glStencilMask(0xFF);
-  glBindProgramPipeline(color_pipeline_);
-
-  glProgramUniform1i(color_fragment_program_, 2, swap_channels ? 1 : 0);
-
-  Draw(src_texture, src_rect, dest_rect, filter);
-
-  state.Restore();
-}
-
-void Blitter::CopyColorTexture2D(GLuint src_texture, Rect2D src_rect,
-                                 GLuint dest_texture, Rect2D dest_rect,
-                                 GLenum filter, bool swap_channels) {
-  SavedState state;
-  state.Save();
-
-  glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-  glDisable(GL_DEPTH_TEST);
-  glDepthMask(GL_FALSE);
-  glBindProgramPipeline(color_pipeline_);
-
-  glProgramUniform1i(color_fragment_program_, 2, swap_channels ? 1 : 0);
-
-  glNamedFramebufferTexture(scratch_framebuffer_, GL_COLOR_ATTACHMENT0,
-                            dest_texture, 0);
-  glNamedFramebufferDrawBuffer(scratch_framebuffer_, GL_COLOR_ATTACHMENT0);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, scratch_framebuffer_);
-  Draw(src_texture, src_rect, dest_rect, filter);
-  glNamedFramebufferDrawBuffer(scratch_framebuffer_, GL_NONE);
-  glNamedFramebufferTexture(scratch_framebuffer_, GL_COLOR_ATTACHMENT0, GL_NONE,
-                            0);
-
-  state.Restore();
-}
-
-void Blitter::CopyDepthTexture(GLuint src_texture, Rect2D src_rect,
-                               GLuint dest_texture, Rect2D dest_rect) {
-  SavedState state;
-  state.Save();
-
-  glColorMaski(0, GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-  glEnable(GL_DEPTH_TEST);
-  glDepthFunc(GL_ALWAYS);
-  glDepthMask(GL_TRUE);
-  glBindProgramPipeline(depth_pipeline_);
-
-  glNamedFramebufferTexture(scratch_framebuffer_, GL_DEPTH_STENCIL_ATTACHMENT,
-                            dest_texture, 0);
-  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, scratch_framebuffer_);
-  Draw(src_texture, src_rect, dest_rect, GL_NEAREST);
-  glNamedFramebufferTexture(scratch_framebuffer_, GL_DEPTH_STENCIL_ATTACHMENT,
-                            GL_NONE, 0);
-
-  state.Restore();
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/blitter.h b/src/xenia/ui/gl/blitter.h
deleted file mode 100644
index 3080c6aaa..000000000
--- a/src/xenia/ui/gl/blitter.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_BLITTER_H_
-#define XENIA_UI_GL_BLITTER_H_
-
-#include <memory>
-
-#include "xenia/ui/gl/gl.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-struct Rect2D {
-  int32_t x;
-  int32_t y;
-  int32_t width;
-  int32_t height;
-  Rect2D() : x(0), y(0), width(0), height(0) {}
-  Rect2D(int32_t x_, int32_t y_, int32_t width_, int32_t height_)
-      : x(x_), y(y_), width(width_), height(height_) {}
-  int32_t right() const { return x + width; }
-  int32_t bottom() const { return y + height; }
-};
-
-class Blitter {
- public:
-  Blitter();
-  ~Blitter();
-
-  bool Initialize();
-  void Shutdown();
-
-  void BlitTexture2D(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect,
-                     GLenum filter, bool swap_channels);
-
-  void CopyColorTexture2D(GLuint src_texture, Rect2D src_rect,
-                          GLuint dest_texture, Rect2D dest_rect, GLenum filter,
-                          bool swap_channels);
-  void CopyDepthTexture(GLuint src_texture, Rect2D src_rect,
-                        GLuint dest_texture, Rect2D dest_rect);
-
- private:
-  void Draw(GLuint src_texture, Rect2D src_rect, Rect2D dest_rect,
-            GLenum filter);
-
-  GLuint vertex_program_;
-  GLuint color_fragment_program_;
-  GLuint depth_fragment_program_;
-  GLuint color_pipeline_;
-  GLuint depth_pipeline_;
-  GLuint vbo_;
-  GLuint vao_;
-  GLuint nearest_sampler_;
-  GLuint linear_sampler_;
-  GLuint scratch_framebuffer_;
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_BLITTER_H_
diff --git a/src/xenia/ui/gl/circular_buffer.cc b/src/xenia/ui/gl/circular_buffer.cc
deleted file mode 100644
index 863b1bd2d..000000000
--- a/src/xenia/ui/gl/circular_buffer.cc
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/circular_buffer.h"
-
-#include <algorithm>
-
-#include "xenia/base/assert.h"
-#include "xenia/base/math.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-CircularBuffer::CircularBuffer(size_t capacity, size_t alignment)
-    : capacity_(capacity),
-      alignment_(alignment),
-      write_head_(0),
-      dirty_start_(UINT64_MAX),
-      dirty_end_(0),
-      buffer_(0),
-      gpu_base_(0),
-      host_base_(nullptr) {}
-
-CircularBuffer::~CircularBuffer() { Shutdown(); }
-
-bool CircularBuffer::Initialize() {
-  glCreateBuffers(1, &buffer_);
-  glNamedBufferStorage(buffer_, capacity_, nullptr,
-                       GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT);
-  host_base_ = reinterpret_cast<uint8_t*>(glMapNamedBufferRange(
-      buffer_, 0, capacity_,
-      GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT));
-  assert_not_null(host_base_);
-  if (!host_base_) {
-    return false;
-  }
-
-  return true;
-}
-
-void CircularBuffer::Shutdown() {
-  if (!buffer_) {
-    return;
-  }
-  glUnmapNamedBuffer(buffer_);
-  glDeleteBuffers(1, &buffer_);
-  buffer_ = 0;
-}
-
-bool CircularBuffer::CanAcquire(size_t length) {
-  size_t aligned_length = xe::round_up(length, alignment_);
-  return write_head_ + aligned_length <= capacity_;
-}
-
-CircularBuffer::Allocation CircularBuffer::Acquire(size_t length) {
-  // Addresses must always be % 256.
-  size_t aligned_length = xe::round_up(length, alignment_);
-  assert_true(aligned_length <= capacity_, "Request too large");
-  if (write_head_ + aligned_length > capacity_) {
-    // Flush and wait.
-    WaitUntilClean();
-  }
-
-  Allocation allocation;
-  allocation.host_ptr = host_base_ + write_head_;
-  allocation.gpu_ptr = gpu_base_ + write_head_;
-  allocation.offset = write_head_;
-  allocation.length = length;
-  allocation.aligned_length = aligned_length;
-  allocation.cache_key = 0;
-  write_head_ += aligned_length;
-  return allocation;
-}
-
-bool CircularBuffer::AcquireCached(uint32_t key, size_t length,
-                                   Allocation* out_allocation) {
-  uint64_t full_key = key | (length << 32);
-  auto it = allocation_cache_.find(full_key);
-  if (it != allocation_cache_.end()) {
-    uintptr_t write_head = it->second;
-    size_t aligned_length = xe::round_up(length, alignment_);
-    out_allocation->host_ptr = host_base_ + write_head;
-    out_allocation->gpu_ptr = gpu_base_ + write_head;
-    out_allocation->offset = write_head;
-    out_allocation->length = length;
-    out_allocation->aligned_length = aligned_length;
-    out_allocation->cache_key = full_key;
-    return true;
-  } else {
-    *out_allocation = Acquire(length);
-    out_allocation->cache_key = full_key;
-    return false;
-  }
-}
-
-void CircularBuffer::Discard(Allocation allocation) {
-  write_head_ -= allocation.aligned_length;
-}
-
-void CircularBuffer::Commit(Allocation allocation) {
-  uintptr_t start = allocation.gpu_ptr - gpu_base_;
-  uintptr_t end = start + allocation.aligned_length;
-  dirty_start_ = std::min(dirty_start_, start);
-  dirty_end_ = std::max(dirty_end_, end);
-  assert_true(dirty_end_ <= capacity_);
-  if (allocation.cache_key) {
-    allocation_cache_.insert({allocation.cache_key, allocation.offset});
-  }
-}
-
-void CircularBuffer::Flush() {
-  if (dirty_start_ == dirty_end_ || dirty_start_ == UINT64_MAX) {
-    return;
-  }
-  glFlushMappedNamedBufferRange(buffer_, dirty_start_,
-                                dirty_end_ - dirty_start_);
-  dirty_start_ = UINT64_MAX;
-  dirty_end_ = 0;
-}
-
-void CircularBuffer::ClearCache() { allocation_cache_.clear(); }
-
-void CircularBuffer::WaitUntilClean() {
-  Flush();
-  glFinish();
-  write_head_ = 0;
-  ClearCache();
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/circular_buffer.h b/src/xenia/ui/gl/circular_buffer.h
deleted file mode 100644
index 3b9c119f8..000000000
--- a/src/xenia/ui/gl/circular_buffer.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_CIRCULAR_BUFFER_H_
-#define XENIA_UI_GL_CIRCULAR_BUFFER_H_
-
-#include <unordered_map>
-
-#include "xenia/ui/gl/gl.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-// TODO(benvanik): uh, make this circular.
-// TODO(benvanik): fences to prevent this from ever flushing.
-class CircularBuffer {
- public:
-  CircularBuffer(size_t capacity, size_t alignment = 256);
-  ~CircularBuffer();
-
-  struct Allocation {
-    void* host_ptr;
-    GLuint64 gpu_ptr;
-    size_t offset;
-    size_t length;
-    size_t aligned_length;
-    uint64_t cache_key;  // 0 if caching disabled.
-  };
-
-  bool Initialize();
-  void Shutdown();
-
-  GLuint handle() const { return buffer_; }
-  GLuint64 gpu_handle() const { return gpu_base_; }
-  size_t capacity() const { return capacity_; }
-
-  bool CanAcquire(size_t length);
-  Allocation Acquire(size_t length);
-  bool AcquireCached(uint32_t key, size_t length, Allocation* out_allocation);
-  void Discard(Allocation allocation);
-  void Commit(Allocation allocation);
-  void Flush();
-  void ClearCache();
-
-  void WaitUntilClean();
-
- private:
-  size_t capacity_;
-  size_t alignment_;
-  uintptr_t write_head_;
-  uintptr_t dirty_start_;
-  uintptr_t dirty_end_;
-  GLuint buffer_;
-  GLuint64 gpu_base_;
-  uint8_t* host_base_;
-
-  std::unordered_map<uint64_t, uintptr_t> allocation_cache_;
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_CIRCULAR_BUFFER_H_
diff --git a/src/xenia/ui/gl/gl.h b/src/xenia/ui/gl/gl.h
deleted file mode 100644
index 796248803..000000000
--- a/src/xenia/ui/gl/gl.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_GL_H_
-#define XENIA_UI_GL_GL_H_
-
-#include "xenia/base/platform.h"
-
-#include "third_party/GL/glew.h"
-
-typedef struct GLEWContextStruct GLEWContext;
-extern "C" GLEWContext* glewGetContext();
-
-#if XE_PLATFORM_WIN32
-// We avoid including wglew.h here as it includes windows.h and pollutes the
-// global namespace. As we don't need wglew most places we only do that as
-// required.
-typedef struct WGLEWContextStruct WGLEWContext;
-extern "C" WGLEWContext* wglewGetContext();
-#elif XE_PLATFORM_LINUX
-typedef struct GLXEWContextStruct GLXEWContext;
-extern "C" GLXEWContext* glxewGetContext();
-
-#endif
-
-#endif  // XENIA_UI_GL_GL_H_
diff --git a/src/xenia/ui/gl/gl_context.cc b/src/xenia/ui/gl/gl_context.cc
deleted file mode 100644
index afae0de6e..000000000
--- a/src/xenia/ui/gl/gl_context.cc
+++ /dev/null
@@ -1,268 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/gl_context.h"
-
-#include <gflags/gflags.h>
-
-#include <mutex>
-#include <string>
-
-#include "xenia/base/assert.h"
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/base/profiling.h"
-#include "xenia/ui/gl/gl_immediate_drawer.h"
-#include "xenia/ui/window.h"
-
-DEFINE_bool(thread_safe_gl, false,
-            "Only allow one GL context to be active at a time.");
-
-DEFINE_bool(disable_gl_context_reset, false,
-            "Do not aggressively reset the GL context (helps with capture "
-            "programs such as OBS or FRAPS).");
-
-DEFINE_bool(random_clear_color, false, "Randomizes GL clear color.");
-
-DEFINE_bool(gl_debug, false, "Enable OpenGL debug validation layer.");
-DEFINE_bool(gl_debug_output, false, "Dump ARB_debug_output to stderr.");
-DEFINE_bool(gl_debug_output_synchronous, true,
-            "ARB_debug_output will synchronize to be thread safe.");
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-std::recursive_mutex GLContext::global_gl_mutex_;
-
-void GLContext::FatalGLError(std::string error) {
-  xe::FatalError(
-      error +
-      "\nEnsure you have the latest drivers for your GPU and that it supports "
-      "OpenGL 4.5. See http://xenia.jp/faq/ for more information and a list"
-      "of supported GPUs.");
-}
-
-GLContext::GLContext(GraphicsProvider* provider, Window* target_window)
-    : GraphicsContext(provider, target_window) {}
-
-GLContext::~GLContext() {}
-
-void GLContext::AssertExtensionsPresent() {
-  if (!MakeCurrent()) {
-    FatalGLError("Unable to make GL context current.");
-    return;
-  }
-
-  // Check shader version at least 4.5 (matching GL 4.5).
-  auto glsl_version_raw =
-      reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION));
-  std::string glsl_version(glsl_version_raw);
-  if (glsl_version.find("4.5") == std::string::npos &&
-      glsl_version.find("4.6") == std::string::npos) {
-    FatalGLError("OpenGL GLSL version 4.50 or higher is required.");
-    return;
-  }
-
-  if (!GLEW_ARB_bindless_texture || !glMakeTextureHandleResidentARB) {
-    FatalGLError("OpenGL extension ARB_bindless_texture is required.");
-    return;
-  }
-
-  if (!GLEW_ARB_fragment_coord_conventions) {
-    FatalGLError(
-        "OpenGL extension ARB_fragment_coord_conventions is required.");
-    return;
-  }
-
-  ClearCurrent();
-}
-
-void GLContext::DebugMessage(GLenum source, GLenum type, GLuint id,
-                             GLenum severity, GLsizei length,
-                             const GLchar* message) {
-  const char* source_name = nullptr;
-  switch (source) {
-    case GL_DEBUG_SOURCE_API_ARB:
-      source_name = "OpenGL";
-      break;
-    case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:
-      source_name = "Windows";
-      break;
-    case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:
-      source_name = "Shader Compiler";
-      break;
-    case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:
-      source_name = "Third Party";
-      break;
-    case GL_DEBUG_SOURCE_APPLICATION_ARB:
-      source_name = "Application";
-      break;
-    case GL_DEBUG_SOURCE_OTHER_ARB:
-      source_name = "Other";
-      break;
-    default:
-      source_name = "(unknown source)";
-      break;
-  }
-
-  const char* type_name = nullptr;
-  switch (type) {
-    case GL_DEBUG_TYPE_ERROR:
-      type_name = "error";
-      break;
-    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
-      type_name = "deprecated behavior";
-      break;
-    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
-      type_name = "undefined behavior";
-      break;
-    case GL_DEBUG_TYPE_PORTABILITY:
-      type_name = "portability";
-      break;
-    case GL_DEBUG_TYPE_PERFORMANCE:
-      type_name = "performance";
-      break;
-    case GL_DEBUG_TYPE_OTHER:
-      type_name = "message";
-      break;
-    case GL_DEBUG_TYPE_MARKER:
-      type_name = "marker";
-      break;
-    case GL_DEBUG_TYPE_PUSH_GROUP:
-      type_name = "push group";
-      break;
-    case GL_DEBUG_TYPE_POP_GROUP:
-      type_name = "pop group";
-      break;
-    default:
-      type_name = "(unknown type)";
-      break;
-  }
-
-  const char* severity_name = nullptr;
-  switch (severity) {
-    case GL_DEBUG_SEVERITY_HIGH_ARB:
-      severity_name = "high";
-      break;
-    case GL_DEBUG_SEVERITY_MEDIUM_ARB:
-      severity_name = "medium";
-      break;
-    case GL_DEBUG_SEVERITY_LOW_ARB:
-      severity_name = "low";
-      break;
-    case GL_DEBUG_SEVERITY_NOTIFICATION:
-      severity_name = "notification";
-      break;
-    default:
-      severity_name = "(unknown severity)";
-      break;
-  }
-
-  XELOGE("GL4 %s: %s(%s) %d: %s", source_name, type_name, severity_name, id,
-         message);
-}
-
-void GLAPIENTRY GLContext::DebugMessageThunk(GLenum source, GLenum type,
-                                             GLuint id, GLenum severity,
-                                             GLsizei length,
-                                             const GLchar* message,
-                                             GLvoid* user_param) {
-  reinterpret_cast<GLContext*>(user_param)
-      ->DebugMessage(source, type, id, severity, length, message);
-}
-
-void GLContext::SetupDebugging() {
-  if (!FLAGS_gl_debug || !FLAGS_gl_debug_output) {
-    return;
-  }
-
-  glEnable(GL_DEBUG_OUTPUT);
-
-  // Synchronous output hurts, but is required if we want to line up the logs.
-  if (FLAGS_gl_debug_output_synchronous) {
-    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-  } else {
-    glDisable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
-  }
-
-  // Enable everything by default.
-  glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, NULL,
-                        GL_TRUE);
-
-  // Disable annoying messages.
-  GLuint disable_message_ids[] = {
-      0x00020004,  // Usage warning: Generic vertex attribute array 0 uses a
-                   // pointer with a small value (0x0000000000000000). Is this
-                   // intended to be used as an offset into a buffer object?
-  };
-  glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_OTHER, GL_DONT_CARE,
-                        GLsizei(xe::countof(disable_message_ids)),
-                        disable_message_ids, GL_FALSE);
-
-  // Callback will be made from driver threads.
-  glDebugMessageCallback(reinterpret_cast<GLDEBUGPROC>(&DebugMessageThunk),
-                         this);
-}
-
-ImmediateDrawer* GLContext::immediate_drawer() {
-  return immediate_drawer_.get();
-}
-
-bool GLContext::WasLost() {
-  if (!robust_access_supported_) {
-    // Can't determine if we lost the context.
-    return false;
-  }
-
-  if (context_lost_) {
-    return true;
-  }
-
-  auto status = glGetGraphicsResetStatusARB();
-  if (status != GL_NO_ERROR) {
-    // Graphics card reset.
-    XELOGE("============= TDR detected on context %p! Context %s =============",
-           handle(), status == GL_GUILTY_CONTEXT_RESET ? "guilty" : "innocent");
-    context_lost_ = true;
-    return true;
-  }
-
-  return false;
-}
-
-std::unique_ptr<RawImage> GLContext::Capture() {
-  GraphicsContextLock lock(this);
-
-  std::unique_ptr<RawImage> raw_image(new RawImage());
-  raw_image->width = target_window_->width();
-  raw_image->stride = raw_image->width * 4;
-  raw_image->height = target_window_->height();
-  raw_image->data.resize(raw_image->stride * raw_image->height);
-
-  glReadPixels(0, 0, target_window_->width(), target_window_->height(), GL_RGBA,
-               GL_UNSIGNED_BYTE, raw_image->data.data());
-
-  // Flip vertically in-place.
-  size_t yt = 0;
-  size_t yb = (raw_image->height - 1) * raw_image->stride;
-  while (yt < yb) {
-    for (size_t i = 0; i < raw_image->stride; ++i) {
-      std::swap(raw_image->data[yt + i], raw_image->data[yb + i]);
-    }
-    yt += raw_image->stride;
-    yb -= raw_image->stride;
-  }
-
-  return raw_image;
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/gl_context.h b/src/xenia/ui/gl/gl_context.h
deleted file mode 100644
index d71e209b2..000000000
--- a/src/xenia/ui/gl/gl_context.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_GL_CONTEXT_H_
-#define XENIA_UI_GL_GL_CONTEXT_H_
-
-#include <gflags/gflags.h>
-
-#include <memory>
-#include <mutex>
-
-#include "xenia/ui/gl/blitter.h"
-#include "xenia/ui/gl/gl.h"
-#include "xenia/ui/graphics_context.h"
-
-DECLARE_bool(thread_safe_gl);
-
-DECLARE_bool(disable_gl_context_reset);
-
-DECLARE_bool(random_clear_color);
-
-DECLARE_bool(gl_debug);
-DECLARE_bool(gl_debug_output);
-DECLARE_bool(gl_debug_output_synchronous);
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-class GLImmediateDrawer;
-class GLProvider;
-
-class GLContext : public GraphicsContext {
- public:
-  ~GLContext() override;
-
-  ImmediateDrawer* immediate_drawer() override;
-
-  virtual bool is_current() override = 0;
-  virtual bool MakeCurrent() override = 0;
-  virtual void ClearCurrent() override = 0;
-  bool WasLost() override;
-
-  virtual void BeginSwap() override = 0;
-  virtual void EndSwap() override = 0;
-  std::unique_ptr<RawImage> Capture() override;
-
-  Blitter* blitter() { return &blitter_; }
-
- protected:
-  Blitter blitter_;
-  std::unique_ptr<GLImmediateDrawer> immediate_drawer_;
-
-  static std::recursive_mutex global_gl_mutex_;
-  bool context_lost_ = false;
-  bool robust_access_supported_ = false;
-  static void FatalGLError(std::string error);
-  virtual bool Initialize(GLContext* share_context) = 0;
-  virtual void* handle() = 0;
-  GLContext(GraphicsProvider* provider, Window* target_window);
-  void SetupDebugging();
-  void AssertExtensionsPresent();
-  void DebugMessage(GLenum source, GLenum type, GLuint id, GLenum severity,
-                    GLsizei length, const GLchar* message);
-
- private:
-  friend class GLProvider;
-
-  static std::unique_ptr<GLContext> Create(GraphicsProvider* provider,
-                                           Window* target_window,
-                                           GLContext* share_context = nullptr);
-  static std::unique_ptr<GLContext> CreateOffscreen(GraphicsProvider* provider,
-                                                    GLContext* parent_context);
-
- private:
-  static void GLAPIENTRY DebugMessageThunk(GLenum source, GLenum type,
-                                           GLuint id, GLenum severity,
-                                           GLsizei length,
-                                           const GLchar* message,
-                                           GLvoid* user_param);
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_GL_CONTEXT_H_
diff --git a/src/xenia/ui/gl/gl_context_win.cc b/src/xenia/ui/gl/gl_context_win.cc
deleted file mode 100644
index 0ca66146c..000000000
--- a/src/xenia/ui/gl/gl_context_win.cc
+++ /dev/null
@@ -1,315 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/gl_context_win.h"
-
-#include <gflags/gflags.h>
-
-#include <mutex>
-#include <string>
-
-#include "xenia/base/assert.h"
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/base/platform_win.h"
-#include "xenia/base/profiling.h"
-#include "xenia/ui/gl/gl_immediate_drawer.h"
-#include "xenia/ui/window.h"
-
-#include "third_party/GL/wglew.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-thread_local GLEWContext* tls_glew_context_ = nullptr;
-thread_local WGLEWContext* tls_wglew_context_ = nullptr;
-extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; }
-extern "C" WGLEWContext* wglewGetContext() { return tls_wglew_context_; }
-
-std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
-                                             Window* target_window,
-                                             GLContext* share_context) {
-  auto context =
-      std::unique_ptr<GLContext>(new WGLContext(provider, target_window));
-  if (!context->Initialize(share_context)) {
-    return nullptr;
-  }
-  context->AssertExtensionsPresent();
-  return context;
-}
-
-std::unique_ptr<GLContext> GLContext::CreateOffscreen(
-    GraphicsProvider* provider, GLContext* parent_context) {
-  return WGLContext::CreateOffscreen(provider,
-                                     static_cast<WGLContext*>(parent_context));
-}
-
-WGLContext::WGLContext(GraphicsProvider* provider, Window* target_window)
-    : GLContext(provider, target_window) {
-  glew_context_.reset(new GLEWContext());
-  wglew_context_.reset(new WGLEWContext());
-}
-
-WGLContext::~WGLContext() {
-  MakeCurrent();
-  blitter_.Shutdown();
-  immediate_drawer_.reset();
-  ClearCurrent();
-  if (glrc_) {
-    wglDeleteContext(glrc_);
-  }
-  if (dc_) {
-    ReleaseDC(HWND(target_window_->native_handle()), dc_);
-  }
-}
-
-bool WGLContext::Initialize(GLContext* share_context_) {
-  WGLContext* share_context = static_cast<WGLContext*>(share_context_);
-  dc_ = GetDC(HWND(target_window_->native_handle()));
-
-  PIXELFORMATDESCRIPTOR pfd = {0};
-  pfd.nSize = sizeof(pfd);
-  pfd.nVersion = 1;
-  pfd.dwFlags = PFD_DOUBLEBUFFER | PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
-  pfd.iPixelType = PFD_TYPE_RGBA;
-  pfd.cColorBits = 32;
-  pfd.cDepthBits = 32;
-  pfd.iLayerType = PFD_MAIN_PLANE;
-  int pixel_format = ChoosePixelFormat(dc_, &pfd);
-  if (!pixel_format) {
-    FatalGLError("Unable to choose pixel format.");
-    return false;
-  }
-  if (!SetPixelFormat(dc_, pixel_format, &pfd)) {
-    FatalGLError("Unable to set pixel format.");
-    return false;
-  }
-
-  HGLRC temp_context = wglCreateContext(dc_);
-  if (!temp_context) {
-    FatalGLError("Unable to create temporary GL context.");
-    return false;
-  }
-  wglMakeCurrent(dc_, temp_context);
-
-  tls_glew_context_ = glew_context_.get();
-  tls_wglew_context_ = wglew_context_.get();
-  if (glewInit() != GLEW_OK) {
-    FatalGLError("Unable to initialize GLEW.");
-    return false;
-  }
-  if (wglewInit() != GLEW_OK) {
-    FatalGLError("Unable to initialize WGLEW.");
-    return false;
-  }
-
-  if (!WGLEW_ARB_create_context) {
-    FatalGLError("WGL_ARG_create_context not supported by GL ICD.");
-    return false;
-  }
-
-  if (GLEW_ARB_robustness) {
-    robust_access_supported_ = true;
-  }
-
-  int context_flags = 0;
-  if (FLAGS_gl_debug) {
-    context_flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
-  }
-  if (robust_access_supported_) {
-    context_flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
-  }
-
-  int attrib_list[] = {
-      WGL_CONTEXT_MAJOR_VERSION_ARB,
-      4,
-      WGL_CONTEXT_MINOR_VERSION_ARB,
-      5,
-      WGL_CONTEXT_FLAGS_ARB,
-      context_flags,
-      WGL_CONTEXT_PROFILE_MASK_ARB,
-      WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-      WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-      robust_access_supported_ ? WGL_LOSE_CONTEXT_ON_RESET_ARB : 0,
-      0};
-
-  glrc_ = wglCreateContextAttribsARB(
-      dc_, share_context ? share_context->glrc_ : nullptr, attrib_list);
-  wglMakeCurrent(nullptr, nullptr);
-  wglDeleteContext(temp_context);
-  if (!glrc_) {
-    FatalGLError("Unable to create real GL context.");
-    return false;
-  }
-
-  if (!MakeCurrent()) {
-    FatalGLError("Could not make real GL context current.");
-    return false;
-  }
-
-  XELOGI("Successfully created OpenGL context:");
-  XELOGI("  GL_VENDOR: %s", glGetString(GL_VENDOR));
-  XELOGI("  GL_VERSION: %s", glGetString(GL_VERSION));
-  XELOGI("  GL_RENDERER: %s", glGetString(GL_RENDERER));
-  XELOGI("  GL_SHADING_LANGUAGE_VERSION: %s",
-         glGetString(GL_SHADING_LANGUAGE_VERSION));
-
-  while (glGetError()) {
-    // Clearing errors.
-  }
-
-  SetupDebugging();
-
-  if (!blitter_.Initialize()) {
-    FatalGLError("Unable to initialize blitter.");
-    ClearCurrent();
-    return false;
-  }
-
-  immediate_drawer_ = std::make_unique<GLImmediateDrawer>(this);
-
-  ClearCurrent();
-
-  return true;
-}
-
-std::unique_ptr<WGLContext> WGLContext::CreateOffscreen(
-    GraphicsProvider* provider, WGLContext* parent_context) {
-  assert_not_null(parent_context->glrc_);
-
-  HGLRC new_glrc = nullptr;
-  {
-    GraphicsContextLock context_lock(parent_context);
-
-    int context_flags = 0;
-    if (FLAGS_gl_debug) {
-      context_flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
-    }
-
-    bool robust_access_supported = parent_context->robust_access_supported_;
-    if (robust_access_supported) {
-      context_flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
-    }
-
-    int attrib_list[] = {
-        WGL_CONTEXT_MAJOR_VERSION_ARB,
-        4,
-        WGL_CONTEXT_MINOR_VERSION_ARB,
-        5,
-        WGL_CONTEXT_FLAGS_ARB,
-        context_flags,
-        WGL_CONTEXT_PROFILE_MASK_ARB,
-        WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-        WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-        robust_access_supported ? WGL_LOSE_CONTEXT_ON_RESET_ARB : 0,
-        0};
-    new_glrc = wglCreateContextAttribsARB(parent_context->dc_,
-                                          parent_context->glrc_, attrib_list);
-    if (!new_glrc) {
-      FatalGLError("Could not create shared context.");
-      return nullptr;
-    }
-  }
-
-  auto new_context = std::unique_ptr<WGLContext>(
-      new WGLContext(provider, parent_context->target_window_));
-  new_context->glrc_ = new_glrc;
-  new_context->dc_ =
-      GetDC(HWND(parent_context->target_window_->native_handle()));
-  new_context->robust_access_supported_ =
-      parent_context->robust_access_supported_;
-  if (!new_context->MakeCurrent()) {
-    FatalGLError("Could not make new GL context current.");
-    return nullptr;
-  }
-  if (!glGetString(GL_EXTENSIONS)) {
-    new_context->ClearCurrent();
-    FatalGLError("New GL context did not have extensions.");
-    return nullptr;
-  }
-
-  if (glewInit() != GLEW_OK) {
-    new_context->ClearCurrent();
-    FatalGLError("Unable to initialize GLEW on shared context.");
-    return nullptr;
-  }
-  if (wglewInit() != GLEW_OK) {
-    new_context->ClearCurrent();
-    FatalGLError("Unable to initialize WGLEW on shared context.");
-    return nullptr;
-  }
-
-  new_context->SetupDebugging();
-
-  if (!new_context->blitter_.Initialize()) {
-    FatalGLError("Unable to initialize blitter on shared context.");
-    return nullptr;
-  }
-
-  new_context->ClearCurrent();
-
-  return new_context;
-}
-
-bool WGLContext::is_current() {
-  return tls_glew_context_ == glew_context_.get();
-}
-
-bool WGLContext::MakeCurrent() {
-  SCOPE_profile_cpu_f("gpu");
-  if (FLAGS_thread_safe_gl) {
-    global_gl_mutex_.lock();
-  }
-
-  if (!wglMakeCurrent(dc_, glrc_)) {
-    if (FLAGS_thread_safe_gl) {
-      global_gl_mutex_.unlock();
-    }
-    FatalGLError("Unable to make GL context current.");
-    return false;
-  }
-  tls_glew_context_ = glew_context_.get();
-  tls_wglew_context_ = wglew_context_.get();
-  return true;
-}
-
-void WGLContext::ClearCurrent() {
-  if (!FLAGS_disable_gl_context_reset) {
-    wglMakeCurrent(nullptr, nullptr);
-  }
-  tls_glew_context_ = nullptr;
-  tls_wglew_context_ = nullptr;
-
-  if (FLAGS_thread_safe_gl) {
-    global_gl_mutex_.unlock();
-  }
-}
-
-void WGLContext::BeginSwap() {
-  SCOPE_profile_cpu_i("gpu", "xe::ui::gl::WGLContext::BeginSwap");
-  float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f};
-  if (FLAGS_random_clear_color) {
-    clear_color[0] =
-        rand() / static_cast<float>(RAND_MAX);  // NOLINT(runtime/threadsafe_fn)
-    clear_color[1] = 1.0f;
-    clear_color[2] = 0.0f;
-    clear_color[3] = 1.0f;
-  }
-  glClearNamedFramebufferfv(0, GL_COLOR, 0, clear_color);
-}
-
-void WGLContext::EndSwap() {
-  SCOPE_profile_cpu_i("gpu", "xe::ui::gl::WGLContext::EndSwap");
-  SwapBuffers(dc_);
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/gl_context_win.h b/src/xenia/ui/gl/gl_context_win.h
deleted file mode 100644
index 772de4d3e..000000000
--- a/src/xenia/ui/gl/gl_context_win.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_WGL_CONTEXT_H_
-#define XENIA_UI_GL_WGL_CONTEXT_H_
-
-#include <gflags/gflags.h>
-
-#include <memory>
-
-#include "xenia/ui/gl/blitter.h"
-#include "xenia/ui/gl/gl.h"
-#include "xenia/ui/gl/gl_context.h"
-#include "xenia/ui/graphics_context.h"
-
-typedef struct HDC__* HDC;
-typedef struct HGLRC__* HGLRC;
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-class GLImmediateDrawer;
-class GLProvider;
-
-class WGLContext : public GLContext {
- public:
-  ~WGLContext() override;
-
-  bool is_current() override;
-  bool MakeCurrent() override;
-  void ClearCurrent() override;
-
-  void BeginSwap() override;
-  void EndSwap() override;
-
- protected:
-  friend class GLContext;
-  WGLContext(GraphicsProvider* provider, Window* target_window);
-  static std::unique_ptr<WGLContext> CreateOffscreen(
-      GraphicsProvider* provider, WGLContext* parent_context);
-
-  bool Initialize(GLContext* share_context) override;
-  void* handle() override { return glrc_; }
-
- private:
-  HDC dc_ = nullptr;
-  HGLRC glrc_ = nullptr;
-
-  std::unique_ptr<GLEWContext> glew_context_;
-  std::unique_ptr<WGLEWContext> wglew_context_;
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_GL_CONTEXT_H_
diff --git a/src/xenia/ui/gl/gl_context_x11.cc b/src/xenia/ui/gl/gl_context_x11.cc
deleted file mode 100644
index fc4b3176b..000000000
--- a/src/xenia/ui/gl/gl_context_x11.cc
+++ /dev/null
@@ -1,323 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/gl_context_x11.h"
-
-#include <gflags/gflags.h>
-
-#include <gdk/gdkx.h>
-#include <mutex>
-#include <string>
-
-#include "third_party/GL/glxew.h"
-#include "xenia/base/assert.h"
-#include "xenia/base/logging.h"
-#include "xenia/base/math.h"
-#include "xenia/base/platform_linux.h"
-#include "xenia/base/profiling.h"
-#include "xenia/ui/gl/gl_immediate_drawer.h"
-#include "xenia/ui/window.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-thread_local GLEWContext* tls_glew_context_ = nullptr;
-thread_local GLXEWContext* tls_glxew_context_ = nullptr;
-extern "C" GLEWContext* glewGetContext() { return tls_glew_context_; }
-extern "C" GLXEWContext* glxewGetContext() { return tls_glxew_context_; }
-
-std::unique_ptr<GLContext> GLContext::Create(GraphicsProvider* provider,
-                                             Window* target_window,
-                                             GLContext* share_context) {
-  auto context =
-      std::unique_ptr<GLContext>(new GLXContext(provider, target_window));
-  if (!context->Initialize(share_context)) {
-    return nullptr;
-  }
-  context->AssertExtensionsPresent();
-  return context;
-}
-
-std::unique_ptr<GLContext> GLContext::CreateOffscreen(
-    GraphicsProvider* provider, GLContext* parent_context) {
-  return GLXContext::CreateOffscreen(provider,
-                                     static_cast<GLXContext*>(parent_context));
-}
-
-GLXContext::GLXContext(GraphicsProvider* provider, Window* target_window)
-    : GLContext(provider, target_window) {
-  glew_context_.reset(new GLEWContext());
-  glxew_context_.reset(new GLXEWContext());
-}
-
-GLXContext::~GLXContext() {
-  MakeCurrent();
-  blitter_.Shutdown();
-  immediate_drawer_.reset();
-  ClearCurrent();
-  if (glx_context_) {
-    glXDestroyContext(disp_, glx_context_);
-  }
-  if (draw_area_) {
-    gtk_widget_destroy(draw_area_);
-  }
-}
-
-bool GLXContext::Initialize(GLContext* share_context) {
-  GtkWidget* window = GTK_WIDGET(target_window_->native_handle());
-  GtkWidget* draw_area = gtk_drawing_area_new();
-  int32_t width;
-  int32_t height;
-  gtk_window_get_size(GTK_WINDOW(window), &width, &height);
-  gtk_widget_set_size_request(draw_area, width, height);
-  gtk_container_add(GTK_CONTAINER(window), draw_area);
-  GdkVisual* visual = gdk_screen_get_system_visual(gdk_screen_get_default());
-
-  GdkDisplay* gdk_display = gtk_widget_get_display(window);
-  Display* display = gdk_x11_display_get_xdisplay(gdk_display);
-  disp_ = display;
-  ::Window root = gdk_x11_get_default_root_xwindow();
-  static int vis_attrib_list[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24,
-                                  GLX_DOUBLEBUFFER, None};
-  XVisualInfo* vi = glXChooseVisual(display, 0, vis_attrib_list);
-  if (vi == NULL) {
-    FatalGLError("No matching visuals for X display");
-    return false;
-  }
-
-  cmap_ = XCreateColormap(display, root, vi->visual, AllocNone);
-
-  ::GLXContext temp_context = glXCreateContext(display, vi, NULL, GL_TRUE);
-  if (!temp_context) {
-    FatalGLError("Unable to create temporary GLX context");
-    return false;
-  }
-  xid_ = GDK_WINDOW_XID(gtk_widget_get_window(window));
-  glXMakeCurrent(display, xid_, temp_context);
-
-  tls_glew_context_ = glew_context_.get();
-  tls_glxew_context_ = glxew_context_.get();
-  if (glewInit() != GLEW_OK) {
-    FatalGLError("Unable to initialize GLEW.");
-    return false;
-  }
-  if (glxewInit() != GLEW_OK) {
-    FatalGLError("Unable to initialize GLXEW.");
-    return false;
-  }
-
-  if (!GLXEW_ARB_create_context) {
-    FatalGLError("GLX_ARB_create_context not supported by GL ICD.");
-    return false;
-  }
-
-  if (GLEW_ARB_robustness) {
-    robust_access_supported_ = true;
-  }
-
-  int context_flags = 0;
-  if (FLAGS_gl_debug) {
-    context_flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
-  }
-  if (robust_access_supported_) {
-    context_flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
-  }
-
-  int attrib_list[] = {
-      GLX_CONTEXT_MAJOR_VERSION_ARB,
-      4,
-      GLX_CONTEXT_MINOR_VERSION_ARB,
-      5,
-      GLX_CONTEXT_FLAGS_ARB,
-      context_flags,
-      GLX_CONTEXT_PROFILE_MASK_ARB,
-      GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-      GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-      robust_access_supported_ ? GLX_LOSE_CONTEXT_ON_RESET_ARB : 0,
-      0};
-  GLXContext* share_context_glx = static_cast<GLXContext*>(share_context);
-  glx_context_ = glXCreateContextAttribsARB(
-      display, nullptr,
-      share_context ? share_context_glx->glx_context_ : nullptr, True,
-      attrib_list);
-  glXMakeCurrent(display, 0, nullptr);
-  glXDestroyContext(display, temp_context);
-  if (!glx_context_) {
-    FatalGLError("Unable to create real GL context.");
-    return false;
-  }
-
-  if (!MakeCurrent()) {
-    FatalGLError("Could not make real GL context current.");
-    return false;
-  }
-
-  XELOGI("Successfully created OpenGL context:");
-  XELOGI("  GL_VENDOR: %s", glGetString(GL_VENDOR));
-  XELOGI("  GL_VERSION: %s", glGetString(GL_VERSION));
-  XELOGI("  GL_RENDERER: %s", glGetString(GL_RENDERER));
-  XELOGI("  GL_SHADING_LANGUAGE_VERSION: %s",
-         glGetString(GL_SHADING_LANGUAGE_VERSION));
-
-  while (glGetError()) {
-    // Clearing errors.
-  }
-
-  SetupDebugging();
-
-  if (!blitter_.Initialize()) {
-    FatalGLError("Unable to initialize blitter.");
-    ClearCurrent();
-    return false;
-  }
-
-  immediate_drawer_ = std::make_unique<GLImmediateDrawer>(this);
-
-  ClearCurrent();
-
-  return true;
-}
-
-std::unique_ptr<GLXContext> GLXContext::CreateOffscreen(
-    GraphicsProvider* provider, GLXContext* parent_context) {
-  assert_not_null(parent_context->glx_context_);
-
-  ::GLXContext new_glrc;
-  {
-    GraphicsContextLock context_lock(parent_context);
-
-    int context_flags = 0;
-    if (FLAGS_gl_debug) {
-      context_flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
-    }
-
-    bool robust_access_supported = parent_context->robust_access_supported_;
-    if (robust_access_supported) {
-      context_flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB;
-    }
-
-    int attrib_list[] = {
-        GLX_CONTEXT_MAJOR_VERSION_ARB,
-        4,
-        GLX_CONTEXT_MINOR_VERSION_ARB,
-        5,
-        GLX_CONTEXT_FLAGS_ARB,
-        context_flags,
-        GLX_CONTEXT_PROFILE_MASK_ARB,
-        GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-        GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB,
-        robust_access_supported ? GLX_LOSE_CONTEXT_ON_RESET_ARB : 0,
-        0};
-    new_glrc = glXCreateContextAttribsARB(parent_context->disp_, nullptr,
-                                          parent_context->glx_context_, True,
-                                          attrib_list);
-    if (!new_glrc) {
-      FatalGLError("Could not create shared context.");
-      return nullptr;
-    }
-  }
-
-  auto new_context = std::unique_ptr<GLXContext>(
-      new GLXContext(provider, parent_context->target_window_));
-  new_context->glx_context_ = new_glrc;
-  new_context->window_ = parent_context->window_;
-  new_context->draw_area_ = parent_context->draw_area_;
-  new_context->disp_ = parent_context->disp_;
-  new_context->xid_ = parent_context->xid_;
-  new_context->robust_access_supported_ =
-      parent_context->robust_access_supported_;
-  if (!new_context->MakeCurrent()) {
-    FatalGLError("Could not make new GL context current.");
-    return nullptr;
-  }
-  if (!glGetString(GL_EXTENSIONS)) {
-    new_context->ClearCurrent();
-    FatalGLError("New GL context did not have extensions.");
-    return nullptr;
-  }
-
-  if (glewInit() != GLEW_OK) {
-    new_context->ClearCurrent();
-    FatalGLError("Unable to initialize GLEW on shared context.");
-    return nullptr;
-  }
-  if (glxewInit() != GLEW_OK) {
-    new_context->ClearCurrent();
-    FatalGLError("Unable to initialize GLXEW on shared context.");
-    return nullptr;
-  }
-
-  new_context->SetupDebugging();
-
-  if (!new_context->blitter_.Initialize()) {
-    FatalGLError("Unable to initialize blitter on shared context.");
-    return nullptr;
-  }
-
-  new_context->ClearCurrent();
-
-  return new_context;
-}
-
-bool GLXContext::is_current() {
-  return tls_glew_context_ == glew_context_.get();
-}
-
-bool GLXContext::MakeCurrent() {
-  SCOPE_profile_cpu_f("gpu");
-  if (FLAGS_thread_safe_gl) {
-    global_gl_mutex_.lock();
-  }
-
-  if (!glXMakeCurrent(disp_, xid_, glx_context_)) {
-    if (FLAGS_thread_safe_gl) {
-      global_gl_mutex_.unlock();
-    }
-    FatalGLError("Unable to make GL context current.");
-    return false;
-  }
-  tls_glew_context_ = glew_context_.get();
-  tls_glxew_context_ = glxew_context_.get();
-  return true;
-}
-
-void GLXContext::ClearCurrent() {
-  if (!FLAGS_disable_gl_context_reset) {
-    glXMakeCurrent(disp_, 0, nullptr);
-  }
-  tls_glew_context_ = nullptr;
-  tls_glxew_context_ = nullptr;
-
-  if (FLAGS_thread_safe_gl) {
-    global_gl_mutex_.unlock();
-  }
-}
-
-void GLXContext::BeginSwap() {
-  SCOPE_profile_cpu_i("gpu", "xe::ui::gl::GLXContext::BeginSwap");
-  float clear_color[] = {238 / 255.0f, 238 / 255.0f, 238 / 255.0f, 1.0f};
-  if (FLAGS_random_clear_color) {
-    clear_color[0] =
-        rand() / static_cast<float>(RAND_MAX);  // NOLINT(runtime/threadsafe_fn)
-    clear_color[1] = 1.0f;
-    clear_color[2] = 0.0f;
-    clear_color[3] = 1.0f;
-  }
-  glClearNamedFramebufferfv(0, GL_COLOR, 0, clear_color);
-}
-
-void GLXContext::EndSwap() {
-  SCOPE_profile_cpu_i("gpu", "xe::ui::gl::GLXContext::EndSwap");
-  glXSwapBuffers(disp_, xid_);
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/gl_context_x11.h b/src/xenia/ui/gl/gl_context_x11.h
deleted file mode 100644
index 6eea7fdb7..000000000
--- a/src/xenia/ui/gl/gl_context_x11.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2014 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_GLX_CONTEXT_H_
-#define XENIA_UI_GL_GLX_CONTEXT_H_
-
-#include <gflags/gflags.h>
-
-#include <memory>
-
-#include "third_party/GL/glxew.h"
-#include "xenia/base/platform_linux.h"
-#include "xenia/ui/gl/blitter.h"
-#include "xenia/ui/gl/gl.h"
-#include "xenia/ui/gl/gl_context.h"
-#include "xenia/ui/graphics_context.h"
-
-DECLARE_bool(thread_safe_gl);
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-class GLImmediateDrawer;
-class GLProvider;
-
-class GLXContext : public GLContext {
- public:
-  ~GLXContext() override;
-
-  bool is_current() override;
-
-  bool MakeCurrent() override;
-  void ClearCurrent() override;
-
-  void BeginSwap() override;
-  void EndSwap() override;
-
- protected:
-  static std::unique_ptr<GLXContext> CreateOffscreen(
-      GraphicsProvider* provider, GLXContext* parent_context);
-
-  bool Initialize(GLContext* share_context) override;
-  void* handle() override { return glx_context_; }
-
- private:
-  friend class GLContext;
-  GLXContext(GraphicsProvider* provider, Window* target_window);
-  std::unique_ptr<GLEWContext> glew_context_;
-  std::unique_ptr<GLXEWContext> glxew_context_;
-  ::GLXContext glx_context_;
-  GtkWidget* window_;
-  GtkWidget* draw_area_;
-  Colormap cmap_;
-  Display* disp_;
-  int xid_;
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_GL_CONTEXT_H_
diff --git a/src/xenia/ui/gl/gl_immediate_drawer.cc b/src/xenia/ui/gl/gl_immediate_drawer.cc
deleted file mode 100644
index 998ff7c50..000000000
--- a/src/xenia/ui/gl/gl_immediate_drawer.cc
+++ /dev/null
@@ -1,283 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/gl_immediate_drawer.h"
-
-#include <string>
-
-#include "xenia/base/assert.h"
-#include "xenia/ui/graphics_context.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-constexpr uint32_t kMaxDrawVertices = 64 * 1024;
-constexpr uint32_t kMaxDrawIndices = 64 * 1024;
-
-class GLImmediateTexture : public ImmediateTexture {
- public:
-  GLImmediateTexture(uint32_t width, uint32_t height,
-                     ImmediateTextureFilter filter, bool repeat)
-      : ImmediateTexture(width, height) {
-    GLuint gl_handle;
-    glCreateTextures(GL_TEXTURE_2D, 1, &gl_handle);
-
-    GLenum gl_filter = GL_NEAREST;
-    switch (filter) {
-      case ImmediateTextureFilter::kNearest:
-        gl_filter = GL_NEAREST;
-        break;
-      case ImmediateTextureFilter::kLinear:
-        gl_filter = GL_LINEAR;
-        break;
-    }
-    glTextureParameteri(gl_handle, GL_TEXTURE_MIN_FILTER, gl_filter);
-    glTextureParameteri(gl_handle, GL_TEXTURE_MAG_FILTER, gl_filter);
-
-    glTextureParameteri(gl_handle, GL_TEXTURE_WRAP_S,
-                        repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE);
-    glTextureParameteri(gl_handle, GL_TEXTURE_WRAP_T,
-                        repeat ? GL_REPEAT : GL_CLAMP_TO_EDGE);
-
-    glTextureStorage2D(gl_handle, 1, GL_RGBA8, width, height);
-
-    handle = static_cast<uintptr_t>(gl_handle);
-  }
-
-  ~GLImmediateTexture() override {
-    GLuint gl_handle = static_cast<GLuint>(handle);
-    glDeleteTextures(1, &gl_handle);
-  }
-};
-
-GLImmediateDrawer::GLImmediateDrawer(GraphicsContext* graphics_context)
-    : ImmediateDrawer(graphics_context) {
-  glCreateBuffers(1, &vertex_buffer_);
-  glNamedBufferStorage(vertex_buffer_,
-                       kMaxDrawVertices * sizeof(ImmediateVertex), nullptr,
-                       GL_DYNAMIC_STORAGE_BIT);
-  glCreateBuffers(1, &index_buffer_);
-  glNamedBufferStorage(index_buffer_, kMaxDrawIndices * sizeof(uint16_t),
-                       nullptr, GL_DYNAMIC_STORAGE_BIT);
-
-  glCreateVertexArrays(1, &vao_);
-  glEnableVertexArrayAttrib(vao_, 0);
-  glVertexArrayAttribBinding(vao_, 0, 0);
-  glVertexArrayAttribFormat(vao_, 0, 2, GL_FLOAT, GL_FALSE,
-                            offsetof(ImmediateVertex, x));
-  glEnableVertexArrayAttrib(vao_, 1);
-  glVertexArrayAttribBinding(vao_, 1, 0);
-  glVertexArrayAttribFormat(vao_, 1, 2, GL_FLOAT, GL_FALSE,
-                            offsetof(ImmediateVertex, u));
-  glEnableVertexArrayAttrib(vao_, 2);
-  glVertexArrayAttribBinding(vao_, 2, 0);
-  glVertexArrayAttribFormat(vao_, 2, 4, GL_UNSIGNED_BYTE, GL_TRUE,
-                            offsetof(ImmediateVertex, color));
-  glVertexArrayVertexBuffer(vao_, 0, vertex_buffer_, 0,
-                            sizeof(ImmediateVertex));
-
-  InitializeShaders();
-}
-
-GLImmediateDrawer::~GLImmediateDrawer() {
-  GraphicsContextLock lock(graphics_context_);
-  glDeleteBuffers(1, &vertex_buffer_);
-  glDeleteBuffers(1, &index_buffer_);
-  glDeleteVertexArrays(1, &vao_);
-  glDeleteProgram(program_);
-}
-
-void GLImmediateDrawer::InitializeShaders() {
-  const std::string header =
-      R"(
-#version 450
-#extension GL_ARB_explicit_uniform_location : require
-#extension GL_ARB_shading_language_420pack : require
-precision highp float;
-layout(std140, column_major) uniform;
-layout(std430, column_major) buffer;
-)";
-  const std::string vertex_shader_source = header +
-                                           R"(
-layout(location = 0) uniform mat4 projection_matrix;
-layout(location = 0) in vec2 in_pos;
-layout(location = 1) in vec2 in_uv;
-layout(location = 2) in vec4 in_color;
-layout(location = 0) out vec2 vtx_uv;
-layout(location = 1) out vec4 vtx_color;
-void main() {
-  gl_Position = projection_matrix * vec4(in_pos.xy, 0.0, 1.0);
-  vtx_uv = in_uv;
-  vtx_color = in_color;
-})";
-  const std::string fragment_shader_source = header +
-                                             R"(
-layout(location = 1) uniform sampler2D texture_sampler;
-layout(location = 2) uniform int restrict_texture_samples;
-layout(location = 0) in vec2 vtx_uv;
-layout(location = 1) in vec4 vtx_color;
-layout(location = 0) out vec4 out_color;
-void main() {
-  out_color = vtx_color;
-  if (restrict_texture_samples == 0 || vtx_uv.x <= 1.0) {
-    vec4 tex_color = texture(texture_sampler, vtx_uv);
-    out_color *= tex_color;
-    // TODO(benvanik): microprofiler shadows.
-  }
-})";
-
-  GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
-  const char* vertex_shader_source_ptr = vertex_shader_source.c_str();
-  GLint vertex_shader_source_length = GLint(vertex_shader_source.size());
-  glShaderSource(vertex_shader, 1, &vertex_shader_source_ptr,
-                 &vertex_shader_source_length);
-  glCompileShader(vertex_shader);
-
-  GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
-  const char* fragment_shader_source_ptr = fragment_shader_source.c_str();
-  GLint fragment_shader_source_length = GLint(fragment_shader_source.size());
-  glShaderSource(fragment_shader, 1, &fragment_shader_source_ptr,
-                 &fragment_shader_source_length);
-  glCompileShader(fragment_shader);
-
-  program_ = glCreateProgram();
-  glAttachShader(program_, vertex_shader);
-  glAttachShader(program_, fragment_shader);
-  glLinkProgram(program_);
-  glDeleteShader(vertex_shader);
-  glDeleteShader(fragment_shader);
-}
-
-std::unique_ptr<ImmediateTexture> GLImmediateDrawer::CreateTexture(
-    uint32_t width, uint32_t height, ImmediateTextureFilter filter, bool repeat,
-    const uint8_t* data) {
-  GraphicsContextLock lock(graphics_context_);
-  auto texture =
-      std::make_unique<GLImmediateTexture>(width, height, filter, repeat);
-  if (data) {
-    UpdateTexture(texture.get(), data);
-  }
-  return std::unique_ptr<ImmediateTexture>(texture.release());
-}
-
-void GLImmediateDrawer::UpdateTexture(ImmediateTexture* texture,
-                                      const uint8_t* data) {
-  GraphicsContextLock lock(graphics_context_);
-  glTextureSubImage2D(static_cast<GLuint>(texture->handle), 0, 0, 0,
-                      texture->width, texture->height, GL_RGBA,
-                      GL_UNSIGNED_BYTE, data);
-}
-
-void GLImmediateDrawer::Begin(int render_target_width,
-                              int render_target_height) {
-  was_current_ = graphics_context_->is_current();
-  if (!was_current_) {
-    graphics_context_->MakeCurrent();
-  }
-
-  // Setup render state.
-  glEnablei(GL_BLEND, 0);
-  glBlendEquationi(0, GL_FUNC_ADD);
-  glBlendFunci(0, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  glDisable(GL_DEPTH_TEST);
-  glDisable(GL_SCISSOR_TEST);
-
-  // Prepare drawing resources.
-  glUseProgram(program_);
-  glBindVertexArray(vao_);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
-
-  // Setup orthographic projection matrix and viewport.
-  const float ortho_projection[4][4] = {
-      {2.0f / render_target_width, 0.0f, 0.0f, 0.0f},
-      {0.0f, 2.0f / -render_target_height, 0.0f, 0.0f},
-      {0.0f, 0.0f, -1.0f, 0.0f},
-      {-1.0f, 1.0f, 0.0f, 1.0f},
-  };
-  glProgramUniformMatrix4fv(program_, 0, 1, GL_FALSE, &ortho_projection[0][0]);
-  glViewport(0, 0, render_target_width, render_target_height);
-}
-
-void GLImmediateDrawer::BeginDrawBatch(const ImmediateDrawBatch& batch) {
-  assert_true(batch.vertex_count <= kMaxDrawVertices);
-  glNamedBufferSubData(vertex_buffer_, 0,
-                       batch.vertex_count * sizeof(ImmediateVertex),
-                       batch.vertices);
-  if (batch.indices) {
-    assert_true(batch.index_count <= kMaxDrawIndices);
-    glNamedBufferSubData(index_buffer_, 0, batch.index_count * sizeof(uint16_t),
-                         batch.indices);
-  }
-
-  batch_has_index_buffer_ = !!batch.indices;
-}
-
-void GLImmediateDrawer::Draw(const ImmediateDraw& draw) {
-  if (draw.scissor) {
-    glEnable(GL_SCISSOR_TEST);
-    glScissorIndexed(0, draw.scissor_rect[0], draw.scissor_rect[1],
-                     draw.scissor_rect[2], draw.scissor_rect[3]);
-  } else {
-    glDisable(GL_SCISSOR_TEST);
-  }
-
-  if (draw.alpha_blend) {
-    glEnablei(GL_BLEND, 0);
-    glBlendEquationi(0, GL_FUNC_ADD);
-    glBlendFunci(0, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-  } else {
-    glDisablei(GL_BLEND, 0);
-  }
-
-  if (draw.texture_handle) {
-    glBindTextureUnit(0, static_cast<GLuint>(draw.texture_handle));
-  } else {
-    glBindTextureUnit(0, 0);
-  }
-  glProgramUniform1i(program_, 2, draw.restrict_texture_samples ? 1 : 0);
-
-  GLenum mode = GL_TRIANGLES;
-  switch (draw.primitive_type) {
-    case ImmediatePrimitiveType::kLines:
-      mode = GL_LINES;
-      break;
-    case ImmediatePrimitiveType::kTriangles:
-      mode = GL_TRIANGLES;
-      break;
-  }
-
-  if (batch_has_index_buffer_) {
-    glDrawElementsBaseVertex(
-        mode, draw.count, GL_UNSIGNED_SHORT,
-        reinterpret_cast<void*>(draw.index_offset * sizeof(uint16_t)),
-        draw.base_vertex);
-  } else {
-    glDrawArrays(mode, draw.base_vertex, draw.count);
-  }
-}
-
-void GLImmediateDrawer::EndDrawBatch() { glFlush(); }
-
-void GLImmediateDrawer::End() {
-  // Restore modified state.
-  glDisable(GL_SCISSOR_TEST);
-  glBindTextureUnit(0, 0);
-  glUseProgram(0);
-  glBindVertexArray(0);
-  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-
-  if (!was_current_) {
-    graphics_context_->ClearCurrent();
-  }
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/gl_immediate_drawer.h b/src/xenia/ui/gl/gl_immediate_drawer.h
deleted file mode 100644
index e9e02798e..000000000
--- a/src/xenia/ui/gl/gl_immediate_drawer.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_
-#define XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_
-
-#include <memory>
-
-#include "xenia/ui/gl/gl.h"
-#include "xenia/ui/immediate_drawer.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-class GLImmediateDrawer : public ImmediateDrawer {
- public:
-  GLImmediateDrawer(GraphicsContext* graphics_context);
-  ~GLImmediateDrawer() override;
-
-  std::unique_ptr<ImmediateTexture> CreateTexture(uint32_t width,
-                                                  uint32_t height,
-                                                  ImmediateTextureFilter filter,
-                                                  bool repeat,
-                                                  const uint8_t* data) override;
-  void UpdateTexture(ImmediateTexture* texture, const uint8_t* data) override;
-
-  void Begin(int render_target_width, int render_target_height) override;
-  void BeginDrawBatch(const ImmediateDrawBatch& batch) override;
-  void Draw(const ImmediateDraw& draw) override;
-  void EndDrawBatch() override;
-  void End() override;
-
- private:
-  void InitializeShaders();
-
-  GLuint program_ = 0;
-  GLuint vao_ = 0;
-  GLuint vertex_buffer_ = 0;
-  GLuint index_buffer_ = 0;
-
-  bool was_current_ = false;
-  bool batch_has_index_buffer_ = false;
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_GL_IMMEDIATE_DRAWER_H_
diff --git a/src/xenia/ui/gl/gl_provider.cc b/src/xenia/ui/gl/gl_provider.cc
deleted file mode 100644
index b53bc9696..000000000
--- a/src/xenia/ui/gl/gl_provider.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include "xenia/ui/gl/gl_provider.h"
-
-#include "xenia/ui/gl/gl_context.h"
-#include "xenia/ui/window.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-std::unique_ptr<GraphicsProvider> GLProvider::Create(Window* main_window) {
-  std::unique_ptr<GLProvider> provider(new GLProvider(main_window));
-
-  //
-
-  return std::unique_ptr<GraphicsProvider>(provider.release());
-}
-
-GLProvider::GLProvider(Window* main_window) : GraphicsProvider(main_window) {}
-
-GLProvider::~GLProvider() = default;
-
-std::unique_ptr<GraphicsContext> GLProvider::CreateContext(
-    Window* target_window) {
-  auto share_context = main_window_->context();
-  return std::unique_ptr<GraphicsContext>(
-      GLContext::Create(this, target_window,
-                        static_cast<GLContext*>(share_context))
-          .release());
-}
-
-std::unique_ptr<GraphicsContext> GLProvider::CreateOffscreenContext() {
-  auto share_context = main_window_->context();
-  return std::unique_ptr<GraphicsContext>(
-      GLContext::CreateOffscreen(this, static_cast<GLContext*>(share_context))
-          .release());
-}
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
diff --git a/src/xenia/ui/gl/gl_provider.h b/src/xenia/ui/gl/gl_provider.h
deleted file mode 100644
index 5c3303f32..000000000
--- a/src/xenia/ui/gl/gl_provider.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#ifndef XENIA_UI_GL_GL_PROVIDER_H_
-#define XENIA_UI_GL_GL_PROVIDER_H_
-
-#include <memory>
-
-#include "xenia/ui/graphics_provider.h"
-
-namespace xe {
-namespace ui {
-namespace gl {
-
-class GLProvider : public GraphicsProvider {
- public:
-  ~GLProvider() override;
-
-  static std::unique_ptr<GraphicsProvider> Create(Window* main_window);
-
-  std::unique_ptr<GraphicsContext> CreateContext(
-      Window* target_window) override;
-
-  std::unique_ptr<GraphicsContext> CreateOffscreenContext() override;
-
- protected:
-  explicit GLProvider(Window* main_window);
-};
-
-}  // namespace gl
-}  // namespace ui
-}  // namespace xe
-
-#endif  // XENIA_UI_GL_GL_PROVIDER_H_
diff --git a/src/xenia/ui/gl/gl_window_demo.cc b/src/xenia/ui/gl/gl_window_demo.cc
deleted file mode 100644
index 6b39ab40f..000000000
--- a/src/xenia/ui/gl/gl_window_demo.cc
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- ******************************************************************************
- * Xenia : Xbox 360 Emulator Research Project                                 *
- ******************************************************************************
- * Copyright 2015 Ben Vanik. All rights reserved.                             *
- * Released under the BSD license - see LICENSE in the root for more details. *
- ******************************************************************************
- */
-
-#include <string>
-#include <vector>
-
-#include "xenia/base/main.h"
-#include "xenia/ui/gl/gl_provider.h"
-#include "xenia/ui/window.h"
-
-namespace xe {
-namespace ui {
-
-int window_demo_main(const std::vector<std::wstring>& args);
-
-std::unique_ptr<GraphicsProvider> CreateDemoGraphicsProvider(Window* window) {
-  return xe::ui::gl::GLProvider::Create(window);
-}
-
-}  // namespace ui
-}  // namespace xe
-
-DEFINE_ENTRY_POINT(L"xenia-ui-window-gl-demo", L"xenia-ui-window-gl-demo",
-                   xe::ui::window_demo_main);
diff --git a/src/xenia/ui/gl/premake5.lua b/src/xenia/ui/gl/premake5.lua
deleted file mode 100644
index c562290a8..000000000
--- a/src/xenia/ui/gl/premake5.lua
+++ /dev/null
@@ -1,65 +0,0 @@
-project_root = "../../../.."
-include(project_root.."/tools/build")
-
-group("src")
-project("xenia-ui-gl")
-  uuid("623300e3-0085-4ccc-af46-d60e88cb43aa")
-  kind("StaticLib")
-  language("C++")
-  links({
-    "glew",
-    "xenia-base",
-    "xenia-ui",
-  })
-  defines({
-    "GLEW_STATIC=1",
-    "GLEW_MX=1",
-  })
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
-  local_platform_files()
-  removefiles({"*_demo.cc"})
-
-group("demos")
-project("xenia-ui-window-gl-demo")
-  uuid("e0a687e5-d1f4-4c18-b2f7-012c53ec1ee4")
-  kind("WindowedApp")
-  language("C++")
-  links({
-    "gflags",
-    "glew",
-    "imgui",
-    "xenia-base",
-    "xenia-ui",
-    "xenia-ui-gl",
-  })
-  filter("platforms:Linux")
-    links({
-      "X11",
-      "xcb",
-      "X11-xcb",
-      "GL",
-      "vulkan",
-    })
-  filter()
-  flags({
-    "WinMain",  -- Use WinMain instead of main.
-  })
-  defines({
-    "GLEW_STATIC=1",
-    "GLEW_MX=1",
-  })
-  includedirs({
-    project_root.."/third_party/gflags/src",
-  })
-  files({
-    "../window_demo.cc",
-    "gl_window_demo.cc",
-    project_root.."/src/xenia/base/main_"..platform_suffix..".cc",
-  })
-  files({
-  })
-  resincludedirs({
-    project_root,
-  })

From 88729e2ac4fcf964031e439f5db408dd7ba7bfd7 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 12:10:26 -0500
Subject: [PATCH 49/56] [GPU] Initial (and possibly incorrect) texture size
 calculation for 1D and 3D

---
 src/xenia/gpu/texture_info.cc | 96 ++++++++++++++++++++++++++++++++---
 src/xenia/gpu/texture_info.h  |  6 +--
 2 files changed, 92 insertions(+), 10 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index 8025e82fc..d80aae0c2 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -73,16 +73,16 @@ bool TextureInfo::Prepare(const xe_gpu_texture_fetch_t& fetch,
   // Must be called here when we know the format.
   switch (info.dimension) {
     case Dimension::k1D: {
-      assert_always();
+      info.CalculateTextureSizes1D(fetch.size_1d.width + 1);
     } break;
     case Dimension::k2D: {
       info.CalculateTextureSizes2D(fetch.size_2d.width + 1,
                                    fetch.size_2d.height + 1);
     } break;
     case Dimension::k3D: {
-      // TODO(benvanik): calculate size.
-      assert_always();
-      return false;
+      info.CalculateTextureSizes3D(fetch.size_3d.width + 1,
+                                   fetch.size_3d.height + 1,
+                                   fetch.size_3d.depth + 1);
     }
     case Dimension::kCube: {
       info.CalculateTextureSizesCube(fetch.size_stack.width + 1,
@@ -123,6 +123,42 @@ bool TextureInfo::PrepareResolve(uint32_t physical_address,
   return true;
 }
 
+void TextureInfo::CalculateTextureSizes1D(uint32_t width) {
+  size_1d.logical_width = width;
+
+  auto format = format_info();
+
+  // width in blocks.
+  uint32_t block_width =
+      xe::round_up(size_1d.logical_width, format->block_width) /
+      format->block_width;
+
+  if (is_tiled) {
+    // If the texture is tiled, its dimensions must be a multiple of tile
+    // dimensions (32x32 blocks).
+    size_1d.block_width = xe::round_up(block_width, 32);
+  } else {
+    size_1d.block_width = block_width;
+  }
+
+  uint32_t bytes_per_block = format->block_width * format->bits_per_pixel / 8;
+  uint32_t byte_pitch = size_1d.block_width * bytes_per_block;
+
+  uint32_t texel_width;
+  if (!is_tiled) {
+    // Each row must be a multiple of 256 in linear textures.
+    byte_pitch = xe::round_up(byte_pitch, 256);
+    texel_width = (byte_pitch / bytes_per_block) * format->block_width;
+  } else {
+    texel_width = size_2d.block_width * format->block_width;
+  }
+
+  size_1d.input_width = texel_width;
+  size_1d.input_pitch = byte_pitch;
+
+  input_length = size_1d.input_pitch;
+}
+
 void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) {
   size_2d.logical_width = width;
   size_2d.logical_height = height;
@@ -167,6 +203,52 @@ void TextureInfo::CalculateTextureSizes2D(uint32_t width, uint32_t height) {
   input_length = size_2d.input_pitch * size_2d.block_height;
 }
 
+void TextureInfo::CalculateTextureSizes3D(uint32_t width, uint32_t height,
+                                          uint32_t depth) {
+  size_3d.logical_width = width;
+  size_3d.logical_height = height;
+
+  auto format = format_info();
+
+  // w/h in blocks must be a multiple of block size.
+  uint32_t block_width =
+      xe::round_up(size_3d.logical_width, format->block_width) /
+      format->block_width;
+  uint32_t block_height =
+      xe::round_up(size_3d.logical_height, format->block_height) /
+      format->block_height;
+
+  if (is_tiled) {
+    // If the texture is tiled, its dimensions must be a multiple of tile
+    // dimensions (32x32 blocks).
+    size_3d.block_width = xe::round_up(block_width, 32);
+    size_3d.block_height = xe::round_up(block_height, 32);
+  } else {
+    size_3d.block_width = block_width;
+    size_3d.block_height = block_height;
+  }
+
+  uint32_t bytes_per_block =
+      format->block_width * format->block_height * format->bits_per_pixel / 8;
+  uint32_t byte_pitch = size_3d.block_width * bytes_per_block;
+
+  uint32_t texel_width;
+  if (!is_tiled) {
+    // Each row must be a multiple of 256 in linear textures.
+    byte_pitch = xe::round_up(byte_pitch, 256);
+    texel_width = (byte_pitch / bytes_per_block) * format->block_width;
+  } else {
+    texel_width = size_3d.block_width * format->block_width;
+  }
+
+  size_3d.input_width = texel_width;
+  size_3d.input_height = size_3d.block_height * format->block_height;
+  size_3d.input_pitch = byte_pitch;
+
+  size_3d.input_face_length = size_3d.input_pitch * size_3d.block_height;
+  input_length = size_3d.input_face_length * depth;
+}
+
 void TextureInfo::CalculateTextureSizesCube(uint32_t width, uint32_t height,
                                             uint32_t depth) {
   assert_true(depth == 6);
@@ -400,7 +482,7 @@ uint32_t TextureInfo::GetMipSize(const TextureInfo& src, uint32_t mip) {
 
   // Minimum of one tile, which is 32x32 blocks.
   uint32_t tile_size = 32 * 32 * bytes_per_block;
-  return std::max(size, tile_size);
+  return std::max(size, tile_size) * (src.depth + 1);
 }
 
 uint32_t TextureInfo::GetMipLinearSize(const TextureInfo& src, uint32_t mip) {
@@ -409,8 +491,8 @@ uint32_t TextureInfo::GetMipLinearSize(const TextureInfo& src, uint32_t mip) {
                              src.format_info()->bits_per_pixel / 8;
   uint32_t size = src.input_length >> (mip * 2);
 
-  // The size is at least one block large.
-  return std::max(size, bytes_per_block);
+  // The size is a multiple of the block size.
+  return xe::round_up(size, bytes_per_block);
 }
 
 bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
diff --git a/src/xenia/gpu/texture_info.h b/src/xenia/gpu/texture_info.h
index 6b7bbfecb..cfce4cc43 100644
--- a/src/xenia/gpu/texture_info.h
+++ b/src/xenia/gpu/texture_info.h
@@ -284,8 +284,6 @@ struct TextureInfo {
       uint32_t input_height;  // texel height
       uint32_t input_pitch;   // byte pitch
     } size_2d;
-    struct {
-    } size_3d;
     struct {
       uint32_t logical_width;
       uint32_t logical_height;
@@ -295,7 +293,7 @@ struct TextureInfo {
       uint32_t input_height;       // texel height
       uint32_t input_pitch;        // byte pitch
       uint32_t input_face_length;  // byte pitch of face
-    } size_cube;
+    } size_3d, size_cube;
   };
 
   static bool Prepare(const xenos::xe_gpu_texture_fetch_t& fetch,
@@ -341,7 +339,9 @@ struct TextureInfo {
   }
 
  private:
+  void CalculateTextureSizes1D(uint32_t width);
   void CalculateTextureSizes2D(uint32_t width, uint32_t height);
+  void CalculateTextureSizes3D(uint32_t width, uint32_t height, uint32_t depth);
   void CalculateTextureSizesCube(uint32_t width, uint32_t height,
                                  uint32_t depth);
 };

From e971e38cdb70bede2aa944740caa8793609c23c3 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 12:13:44 -0500
Subject: [PATCH 50/56] [HID] Swap the HID demo over to the vulkan backend

---
 src/xenia/hid/hid_demo.cc  | 4 ++--
 src/xenia/hid/premake5.lua | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/xenia/hid/hid_demo.cc b/src/xenia/hid/hid_demo.cc
index 70c84a35f..5afe6eef4 100644
--- a/src/xenia/hid/hid_demo.cc
+++ b/src/xenia/hid/hid_demo.cc
@@ -17,8 +17,8 @@
 #include "xenia/base/main.h"
 #include "xenia/base/threading.h"
 #include "xenia/hid/input_system.h"
-#include "xenia/ui/gl/gl_provider.h"
 #include "xenia/ui/imgui_drawer.h"
+#include "xenia/ui/vulkan/vulkan_provider.h"
 #include "xenia/ui/window.h"
 
 // Available input drivers:
@@ -67,7 +67,7 @@ std::vector<std::unique_ptr<hid::InputDriver>> CreateInputDrivers(
 
 std::unique_ptr<xe::ui::GraphicsProvider> CreateDemoGraphicsProvider(
     xe::ui::Window* window) {
-  return xe::ui::gl::GLProvider::Create(window);
+  return xe::ui::vulkan::VulkanProvider::Create(window);
 }
 
 void DrawInputStatus();
diff --git a/src/xenia/hid/premake5.lua b/src/xenia/hid/premake5.lua
index b1044efa1..de7e44f35 100644
--- a/src/xenia/hid/premake5.lua
+++ b/src/xenia/hid/premake5.lua
@@ -30,6 +30,7 @@ project("xenia-hid-demo")
     "xenia-hid",
     "xenia-hid-nop",
     "xenia-ui",
+    "xenia-ui-vulkan",
   })
   filter("platforms:Linux")
     links({

From 61e47167c0adc55ad1be58d8ebb6acc41a5ba1a6 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 16:49:46 -0500
Subject: [PATCH 51/56] [Vulkan] Replace vulkan-loader with volk

---
 .gitmodules                                   |    3 +
 premake5.lua                                  |    2 +-
 src/xenia/app/premake5.lua                    |    2 +-
 src/xenia/gpu/vulkan/buffer_cache.cc          |    9 +-
 src/xenia/gpu/vulkan/premake5.lua             |    6 +-
 src/xenia/gpu/vulkan/texture_cache.cc         |    8 +-
 src/xenia/ui/vulkan/premake5.lua              |    2 +-
 src/xenia/ui/vulkan/vulkan.h                  |    4 +-
 src/xenia/ui/vulkan/vulkan_instance.cc        |    8 +
 src/xenia/ui/vulkan/vulkan_mem_alloc.h        |   44 +
 src/xenia/ui/vulkan/vulkan_util.cc            |    2 +-
 third_party/volk                              |    1 +
 third_party/volk.lua                          |   30 +
 third_party/vulkan/loader/cJSON.c             | 1212 ----
 third_party/vulkan/loader/cJSON.h             |  174 -
 third_party/vulkan/loader/debug_report.c      |  466 --
 third_party/vulkan/loader/debug_report.h      |  138 -
 .../vulkan/loader/dev_ext_trampoline.c        |  538 --
 third_party/vulkan/loader/dirent_on_windows.c |  128 -
 third_party/vulkan/loader/dirent_on_windows.h |   51 -
 third_party/vulkan/loader/extension_manual.c  | 1345 ----
 third_party/vulkan/loader/extension_manual.h  |  160 -
 third_party/vulkan/loader/gpa_helper.h        |  204 -
 third_party/vulkan/loader/loader.c            | 6065 -----------------
 third_party/vulkan/loader/loader.h            |  490 --
 .../vulkan/loader/loader_cmake_config.h       |    2 -
 third_party/vulkan/loader/murmurhash.c        |   97 -
 third_party/vulkan/loader/murmurhash.h        |   52 -
 third_party/vulkan/loader/phys_dev_ext.c      | 1056 ---
 third_party/vulkan/loader/premake5.lua        |   41 -
 third_party/vulkan/loader/trampoline.c        | 1994 ------
 third_party/vulkan/loader/unknown_ext_chain.c |  819 ---
 .../vulkan/loader/unknown_ext_chain_gas.asm   |  873 ---
 .../vulkan/loader/unknown_ext_chain_masm.asm  |  883 ---
 .../vulkan/loader/vk_loader_extensions.c      | 2760 --------
 .../vulkan/loader/vk_loader_extensions.h      |  342 -
 third_party/vulkan/loader/vk_loader_layer.h   |   31 -
 .../vulkan/loader/vk_loader_platform.h        |  359 -
 third_party/vulkan/loader/wsi.c               | 1547 -----
 third_party/vulkan/loader/wsi.h               |  145 -
 40 files changed, 106 insertions(+), 21987 deletions(-)
 create mode 100644 src/xenia/ui/vulkan/vulkan_mem_alloc.h
 create mode 160000 third_party/volk
 create mode 100644 third_party/volk.lua
 delete mode 100644 third_party/vulkan/loader/cJSON.c
 delete mode 100644 third_party/vulkan/loader/cJSON.h
 delete mode 100644 third_party/vulkan/loader/debug_report.c
 delete mode 100644 third_party/vulkan/loader/debug_report.h
 delete mode 100644 third_party/vulkan/loader/dev_ext_trampoline.c
 delete mode 100644 third_party/vulkan/loader/dirent_on_windows.c
 delete mode 100644 third_party/vulkan/loader/dirent_on_windows.h
 delete mode 100644 third_party/vulkan/loader/extension_manual.c
 delete mode 100644 third_party/vulkan/loader/extension_manual.h
 delete mode 100644 third_party/vulkan/loader/gpa_helper.h
 delete mode 100644 third_party/vulkan/loader/loader.c
 delete mode 100644 third_party/vulkan/loader/loader.h
 delete mode 100644 third_party/vulkan/loader/loader_cmake_config.h
 delete mode 100644 third_party/vulkan/loader/murmurhash.c
 delete mode 100644 third_party/vulkan/loader/murmurhash.h
 delete mode 100644 third_party/vulkan/loader/phys_dev_ext.c
 delete mode 100644 third_party/vulkan/loader/premake5.lua
 delete mode 100644 third_party/vulkan/loader/trampoline.c
 delete mode 100644 third_party/vulkan/loader/unknown_ext_chain.c
 delete mode 100644 third_party/vulkan/loader/unknown_ext_chain_gas.asm
 delete mode 100644 third_party/vulkan/loader/unknown_ext_chain_masm.asm
 delete mode 100644 third_party/vulkan/loader/vk_loader_extensions.c
 delete mode 100644 third_party/vulkan/loader/vk_loader_extensions.h
 delete mode 100644 third_party/vulkan/loader/vk_loader_layer.h
 delete mode 100644 third_party/vulkan/loader/vk_loader_platform.h
 delete mode 100644 third_party/vulkan/loader/wsi.c
 delete mode 100644 third_party/vulkan/loader/wsi.h

diff --git a/.gitmodules b/.gitmodules
index d2a04bcb6..3a3621c2d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -37,3 +37,6 @@
 [submodule "third_party/spirv-headers"]
 	path = third_party/spirv-headers
 	url = https://github.com/KhronosGroup/SPIRV-Headers
+[submodule "third_party/volk"]
+	path = third_party/volk
+	url = https://github.com/zeux/volk.git
diff --git a/premake5.lua b/premake5.lua
index a3dd2a3c8..686c77e84 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -228,7 +228,7 @@ solution("xenia")
   include("third_party/libav.lua")
   include("third_party/snappy.lua")
   include("third_party/spirv-tools.lua")
-  include("third_party/vulkan/loader")
+  include("third_party/volk.lua")
   include("third_party/xxhash.lua")
   include("third_party/yaml-cpp.lua")
 
diff --git a/src/xenia/app/premake5.lua b/src/xenia/app/premake5.lua
index d4d9bb8e1..3b4b4b9c6 100644
--- a/src/xenia/app/premake5.lua
+++ b/src/xenia/app/premake5.lua
@@ -17,7 +17,7 @@ project("xenia-app")
     "libavutil",
     "snappy",
     "spirv-tools",
-    "vulkan-loader",
+    "volk",
     "xenia-apu",
     "xenia-apu-nop",
     "xenia-base",
diff --git a/src/xenia/gpu/vulkan/buffer_cache.cc b/src/xenia/gpu/vulkan/buffer_cache.cc
index 23e93e67a..0a0162d35 100644
--- a/src/xenia/gpu/vulkan/buffer_cache.cc
+++ b/src/xenia/gpu/vulkan/buffer_cache.cc
@@ -15,8 +15,7 @@
 #include "xenia/base/profiling.h"
 #include "xenia/gpu/gpu_flags.h"
 #include "xenia/gpu/vulkan/vulkan_gpu_flags.h"
-
-#include "third_party/vulkan/vk_mem_alloc.h"
+#include "xenia/ui/vulkan/vulkan_mem_alloc.h"
 
 using namespace xe::gpu::xenos;
 
@@ -120,9 +119,13 @@ VkResult BufferCache::Initialize() {
   }
 
   // Create a memory allocator for textures.
+  VmaVulkanFunctions vulkan_funcs = {};
+  ui::vulkan::FillVMAVulkanFunctions(&vulkan_funcs);
+
   VmaAllocatorCreateInfo alloc_info = {
-      0, *device_, *device_, 0, 0, nullptr, nullptr,
+      0, *device_, *device_, 0, 0, nullptr, nullptr, 0, nullptr, &vulkan_funcs,
   };
+
   status = vmaCreateAllocator(&alloc_info, &mem_allocator_);
   if (status != VK_SUCCESS) {
     return status;
diff --git a/src/xenia/gpu/vulkan/premake5.lua b/src/xenia/gpu/vulkan/premake5.lua
index 146ac2bd7..b399914a8 100644
--- a/src/xenia/gpu/vulkan/premake5.lua
+++ b/src/xenia/gpu/vulkan/premake5.lua
@@ -7,7 +7,7 @@ project("xenia-gpu-vulkan")
   kind("StaticLib")
   language("C++")
   links({
-    "vulkan-loader",
+    "volk",
     "xenia-base",
     "xenia-gpu",
     "xenia-ui",
@@ -40,7 +40,7 @@ project("xenia-gpu-vulkan-trace-viewer")
     "libavutil",
     "snappy",
     "spirv-tools",
-    "vulkan-loader",
+    "volk",
     "xenia-apu",
     "xenia-apu-nop",
     "xenia-base",
@@ -112,7 +112,7 @@ project("xenia-gpu-vulkan-trace-dump")
     "libavutil",
     "snappy",
     "spirv-tools",
-    "vulkan-loader",
+    "volk",
     "xenia-apu",
     "xenia-apu-nop",
     "xenia-base",
diff --git a/src/xenia/gpu/vulkan/texture_cache.cc b/src/xenia/gpu/vulkan/texture_cache.cc
index 15369643a..95ed924c5 100644
--- a/src/xenia/gpu/vulkan/texture_cache.cc
+++ b/src/xenia/gpu/vulkan/texture_cache.cc
@@ -17,8 +17,7 @@
 #include "xenia/gpu/sampler_info.h"
 #include "xenia/gpu/texture_info.h"
 #include "xenia/gpu/vulkan/vulkan_gpu_flags.h"
-
-#include "third_party/vulkan/vk_mem_alloc.h"
+#include "xenia/ui/vulkan/vulkan_mem_alloc.h"
 
 namespace xe {
 namespace gpu {
@@ -198,8 +197,11 @@ VkResult TextureCache::Initialize() {
   }
 
   // Create a memory allocator for textures.
+  VmaVulkanFunctions vulkan_funcs = {};
+  ui::vulkan::FillVMAVulkanFunctions(&vulkan_funcs);
+
   VmaAllocatorCreateInfo alloc_info = {
-      0, *device_, *device_, 0, 0, nullptr, nullptr,
+      0, *device_, *device_, 0, 0, nullptr, nullptr, 0, nullptr, &vulkan_funcs,
   };
   status = vmaCreateAllocator(&alloc_info, &mem_allocator_);
   if (status != VK_SUCCESS) {
diff --git a/src/xenia/ui/vulkan/premake5.lua b/src/xenia/ui/vulkan/premake5.lua
index ab31e3b90..51fd69aa5 100644
--- a/src/xenia/ui/vulkan/premake5.lua
+++ b/src/xenia/ui/vulkan/premake5.lua
@@ -31,7 +31,7 @@ project("xenia-ui-window-vulkan-demo")
   links({
     "gflags",
     "imgui",
-    "vulkan-loader",
+    "volk",
     "xenia-base",
     "xenia-ui",
     "xenia-ui-spirv",
diff --git a/src/xenia/ui/vulkan/vulkan.h b/src/xenia/ui/vulkan/vulkan.h
index 38a4400f7..b091cb63f 100644
--- a/src/xenia/ui/vulkan/vulkan.h
+++ b/src/xenia/ui/vulkan/vulkan.h
@@ -22,8 +22,8 @@
 #error Platform not yet supported.
 #endif  // XE_PLATFORM_WIN32
 
-// We are statically linked with the loader, so use function prototypes.
-#define VK_PROTOTYPES
+// We use a loader with its own function prototypes.
+#include "third_party/volk/volk.h"
 #include "third_party/vulkan/vulkan.h"
 
 // NOTE: header order matters here, unfortunately:
diff --git a/src/xenia/ui/vulkan/vulkan_instance.cc b/src/xenia/ui/vulkan/vulkan_instance.cc
index efadcfa39..1eb967b9b 100644
--- a/src/xenia/ui/vulkan/vulkan_instance.cc
+++ b/src/xenia/ui/vulkan/vulkan_instance.cc
@@ -16,6 +16,7 @@
 #include <string>
 
 #include "third_party/renderdoc/renderdoc_app.h"
+#include "third_party/volk/volk.h"
 
 #include "xenia/base/assert.h"
 #include "xenia/base/logging.h"
@@ -72,6 +73,10 @@ VulkanInstance::~VulkanInstance() { DestroyInstance(); }
 bool VulkanInstance::Initialize() {
   auto version = Version::Parse(VK_API_VERSION);
   XELOGVK("Initializing Vulkan %s...", version.pretty_string.c_str());
+  if (volkInitialize() != VK_SUCCESS) {
+    XELOGE("volkInitialize() failed!");
+    return false;
+  }
 
   // Get all of the global layers and extensions provided by the system.
   if (!QueryGlobals()) {
@@ -271,6 +276,9 @@ bool VulkanInstance::CreateInstance() {
       return false;
   }
 
+  // Load Vulkan entrypoints and extensions.
+  volkLoadInstance(handle);
+
   // Enable debug validation, if needed.
   EnableDebugValidation();
 
diff --git a/src/xenia/ui/vulkan/vulkan_mem_alloc.h b/src/xenia/ui/vulkan/vulkan_mem_alloc.h
new file mode 100644
index 000000000..caf89aae6
--- /dev/null
+++ b/src/xenia/ui/vulkan/vulkan_mem_alloc.h
@@ -0,0 +1,44 @@
+/**
+ ******************************************************************************
+ * Xenia : Xbox 360 Emulator Research Project                                 *
+ ******************************************************************************
+ * Copyright 2018 Ben Vanik. All rights reserved.                             *
+ * Released under the BSD license - see LICENSE in the root for more details. *
+ ******************************************************************************
+ */
+
+#ifndef XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_
+#define XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_
+
+#include "third_party/volk/volk.h"
+
+#define VMA_STATIC_VULKAN_FUNCTIONS 0
+#include "third_party/vulkan/vk_mem_alloc.h"
+
+namespace xe {
+namespace ui {
+namespace vulkan {
+
+inline void FillVMAVulkanFunctions(VmaVulkanFunctions* vma_funcs) {
+  vma_funcs->vkGetPhysicalDeviceProperties = vkGetPhysicalDeviceProperties;
+  vma_funcs->vkGetPhysicalDeviceMemoryProperties =
+      vkGetPhysicalDeviceMemoryProperties;
+  vma_funcs->vkAllocateMemory = vkAllocateMemory;
+  vma_funcs->vkFreeMemory = vkFreeMemory;
+  vma_funcs->vkMapMemory = vkMapMemory;
+  vma_funcs->vkUnmapMemory = vkUnmapMemory;
+  vma_funcs->vkBindBufferMemory = vkBindBufferMemory;
+  vma_funcs->vkBindImageMemory = vkBindImageMemory;
+  vma_funcs->vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirements;
+  vma_funcs->vkGetImageMemoryRequirements = vkGetImageMemoryRequirements;
+  vma_funcs->vkCreateBuffer = vkCreateBuffer;
+  vma_funcs->vkDestroyBuffer = vkDestroyBuffer;
+  vma_funcs->vkCreateImage = vkCreateImage;
+  vma_funcs->vkDestroyImage = vkDestroyImage;
+}
+
+}  // namespace vulkan
+}  // namespace ui
+}  // namespace xe
+
+#endif  // XENIA_UI_VULKAN_VULKAN_MEM_ALLOC_H_
\ No newline at end of file
diff --git a/src/xenia/ui/vulkan/vulkan_util.cc b/src/xenia/ui/vulkan/vulkan_util.cc
index 9c0a4238a..2e2034f65 100644
--- a/src/xenia/ui/vulkan/vulkan_util.cc
+++ b/src/xenia/ui/vulkan/vulkan_util.cc
@@ -14,7 +14,7 @@
 
 // Implement AMD's VMA here.
 #define VMA_IMPLEMENTATION
-#include "third_party/vulkan/vk_mem_alloc.h"
+#include "xenia/ui/vulkan/vulkan_mem_alloc.h"
 
 namespace xe {
 namespace ui {
diff --git a/third_party/volk b/third_party/volk
new file mode 160000
index 000000000..30a851b67
--- /dev/null
+++ b/third_party/volk
@@ -0,0 +1 @@
+Subproject commit 30a851b67e129a3d91f191b2e9dcdad65ba98438
diff --git a/third_party/volk.lua b/third_party/volk.lua
new file mode 100644
index 000000000..7ba0dd618
--- /dev/null
+++ b/third_party/volk.lua
@@ -0,0 +1,30 @@
+group("third_party")
+project("volk")
+  uuid("C9781C93-2DF5-47A2-94EE-2C5EBED61239")
+  kind("StaticLib")
+  language("C")
+
+  defines({
+    "_LIB",
+    "API_NAME=\"vulkan\"",
+  })
+  removedefines({
+    "_UNICODE",
+    "UNICODE",
+  })
+  includedirs({
+      "volk",
+  })
+  files({
+      "volk/volk.c",
+      "volk/volk.h",
+  })
+
+  filter("platforms:Windows")
+    defines({
+      "VK_USE_PLATFORM_WIN32_KHR",
+    })
+  filter("platforms:Linux")
+    defines({
+      "VK_USE_PLATFORM_XCB_KHR",
+    })
diff --git a/third_party/vulkan/loader/cJSON.c b/third_party/vulkan/loader/cJSON.c
deleted file mode 100644
index a7671c4a0..000000000
--- a/third_party/vulkan/loader/cJSON.c
+++ /dev/null
@@ -1,1212 +0,0 @@
-/*
-  Copyright (c) 2009 Dave Gamble
-  Copyright (c) 2015-2016 The Khronos Group Inc.
-  Copyright (c) 2015-2016 Valve Corporation
-  Copyright (c) 2015-2016 LunarG, Inc.
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-/* cJSON */
-/* JSON parser in C. */
-
-#include <string.h>
-#include <stdio.h>
-#include <math.h>
-#include <stdlib.h>
-#include <float.h>
-#include <limits.h>
-#include <ctype.h>
-#include "cJSON.h"
-
-static const char *ep;
-
-const char *cJSON_GetErrorPtr(void) { return ep; }
-
-static void *(*cJSON_malloc)(size_t sz) = malloc;
-static void (*cJSON_free)(void *ptr) = free;
-
-static char *cJSON_strdup(const char *str) {
-    size_t len;
-    char *copy;
-
-    len = strlen(str) + 1;
-    if (!(copy = (char *)cJSON_malloc(len))) return 0;
-    memcpy(copy, str, len);
-    return copy;
-}
-
-void cJSON_InitHooks(cJSON_Hooks *hooks) {
-    if (!hooks) { /* Reset hooks */
-        cJSON_malloc = malloc;
-        cJSON_free = free;
-        return;
-    }
-
-    cJSON_malloc = (hooks->malloc_fn) ? hooks->malloc_fn : malloc;
-    cJSON_free = (hooks->free_fn) ? hooks->free_fn : free;
-}
-
-/* Internal constructor. */
-static cJSON *cJSON_New_Item(void) {
-    cJSON *node = (cJSON *)cJSON_malloc(sizeof(cJSON));
-    if (node) memset(node, 0, sizeof(cJSON));
-    return node;
-}
-
-/* Delete a cJSON structure. */
-void cJSON_Delete(cJSON *c) {
-    cJSON *next;
-    while (c) {
-        next = c->next;
-        if (!(c->type & cJSON_IsReference) && c->child) cJSON_Delete(c->child);
-        if (!(c->type & cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);
-        if (!(c->type & cJSON_StringIsConst) && c->string) cJSON_free(c->string);
-        cJSON_free(c);
-        c = next;
-    }
-}
-
-void cJSON_Free(void *p) { cJSON_free(p); }
-
-/* Parse the input text to generate a number, and populate the result into item.
- */
-static const char *parse_number(cJSON *item, const char *num) {
-    double n = 0, sign = 1, scale = 0;
-    int subscale = 0, signsubscale = 1;
-
-    if (*num == '-') sign = -1, num++; /* Has sign? */
-    if (*num == '0') num++;            /* is zero */
-    if (*num >= '1' && *num <= '9') do
-            n = (n * 10.0) + (*num++ - '0');
-        while (*num >= '0' && *num <= '9'); /* Number? */
-    if (*num == '.' && num[1] >= '0' && num[1] <= '9') {
-        num++;
-        do
-            n = (n * 10.0) + (*num++ - '0'), scale--;
-        while (*num >= '0' && *num <= '9');
-    }                               /* Fractional part? */
-    if (*num == 'e' || *num == 'E') /* Exponent? */
-    {
-        num++;
-        if (*num == '+')
-            num++;
-        else if (*num == '-')
-            signsubscale = -1, num++;                                                   /* With sign? */
-        while (*num >= '0' && *num <= '9') subscale = (subscale * 10) + (*num++ - '0'); /* Number? */
-    }
-
-    n = sign * n * pow(10.0, (scale + subscale * signsubscale)); /* number = +/-
-                                                                    number.fraction *
-                                                                    10^+/- exponent */
-
-    item->valuedouble = n;
-    item->valueint = (int)n;
-    item->type = cJSON_Number;
-    return num;
-}
-
-static size_t pow2gt(size_t x) {
-    --x;
-    x |= x >> 1;
-    x |= x >> 2;
-    x |= x >> 4;
-    x |= x >> 8;
-    x |= x >> 16;
-    return x + 1;
-}
-
-typedef struct {
-    char *buffer;
-    size_t length;
-    size_t offset;
-} printbuffer;
-
-static char *ensure(printbuffer *p, size_t needed) {
-    char *newbuffer;
-    size_t newsize;
-    if (!p || !p->buffer) return 0;
-    needed += p->offset;
-    if (needed <= p->length) return p->buffer + p->offset;
-
-    newsize = pow2gt(needed);
-    newbuffer = (char *)cJSON_malloc(newsize);
-    if (!newbuffer) {
-        cJSON_free(p->buffer);
-        p->length = 0, p->buffer = 0;
-        return 0;
-    }
-    if (newbuffer) memcpy(newbuffer, p->buffer, p->length);
-    cJSON_free(p->buffer);
-    p->length = newsize;
-    p->buffer = newbuffer;
-    return newbuffer + p->offset;
-}
-
-static size_t update(printbuffer *p) {
-    char *str;
-    if (!p || !p->buffer) return 0;
-    str = p->buffer + p->offset;
-    return p->offset + strlen(str);
-}
-
-/* Render the number nicely from the given item into a string. */
-static char *print_number(cJSON *item, printbuffer *p) {
-    char *str = 0;
-    double d = item->valuedouble;
-    if (d == 0) {
-        if (p)
-            str = ensure(p, 2);
-        else
-            str = (char *)cJSON_malloc(2); /* special case for 0. */
-        if (str) strcpy(str, "0");
-    } else if (fabs(((double)item->valueint) - d) <= DBL_EPSILON && d <= INT_MAX && d >= INT_MIN) {
-        if (p)
-            str = ensure(p, 21);
-        else
-            str = (char *)cJSON_malloc(21); /* 2^64+1 can be represented in 21 chars. */
-        if (str) sprintf(str, "%d", item->valueint);
-    } else {
-        if (p)
-            str = ensure(p, 64);
-        else
-            str = (char *)cJSON_malloc(64); /* This is a nice tradeoff. */
-        if (str) {
-            if (fabs(floor(d) - d) <= DBL_EPSILON && fabs(d) < 1.0e60)
-                sprintf(str, "%.0f", d);
-            else if (fabs(d) < 1.0e-6 || fabs(d) > 1.0e9)
-                sprintf(str, "%e", d);
-            else
-                sprintf(str, "%f", d);
-        }
-    }
-    return str;
-}
-
-static unsigned parse_hex4(const char *str) {
-    unsigned h = 0;
-    if (*str >= '0' && *str <= '9')
-        h += (*str) - '0';
-    else if (*str >= 'A' && *str <= 'F')
-        h += 10 + (*str) - 'A';
-    else if (*str >= 'a' && *str <= 'f')
-        h += 10 + (*str) - 'a';
-    else
-        return 0;
-    h = h << 4;
-    str++;
-    if (*str >= '0' && *str <= '9')
-        h += (*str) - '0';
-    else if (*str >= 'A' && *str <= 'F')
-        h += 10 + (*str) - 'A';
-    else if (*str >= 'a' && *str <= 'f')
-        h += 10 + (*str) - 'a';
-    else
-        return 0;
-    h = h << 4;
-    str++;
-    if (*str >= '0' && *str <= '9')
-        h += (*str) - '0';
-    else if (*str >= 'A' && *str <= 'F')
-        h += 10 + (*str) - 'A';
-    else if (*str >= 'a' && *str <= 'f')
-        h += 10 + (*str) - 'a';
-    else
-        return 0;
-    h = h << 4;
-    str++;
-    if (*str >= '0' && *str <= '9')
-        h += (*str) - '0';
-    else if (*str >= 'A' && *str <= 'F')
-        h += 10 + (*str) - 'A';
-    else if (*str >= 'a' && *str <= 'f')
-        h += 10 + (*str) - 'a';
-    else
-        return 0;
-    return h;
-}
-
-/* Parse the input text into an unescaped cstring, and populate item. */
-static const unsigned char firstByteMark[7] = {0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
-static const char *parse_string(cJSON *item, const char *str) {
-    const char *ptr = str + 1;
-    char *ptr2;
-    char *out;
-    int len = 0;
-    unsigned uc, uc2;
-    if (*str != '\"') {
-        ep = str;
-        return 0;
-    } /* not a string! */
-
-    while (*ptr != '\"' && *ptr && ++len)
-        if (*ptr++ == '\\') ptr++; /* Skip escaped quotes. */
-
-    out = (char *)cJSON_malloc(len + 1); /* This is how long we need for the string, roughly. */
-    if (!out) return 0;
-
-    ptr = str + 1;
-    ptr2 = out;
-    while (*ptr != '\"' && *ptr) {
-        if (*ptr != '\\')
-            *ptr2++ = *ptr++;
-        else {
-            ptr++;
-            switch (*ptr) {
-                case 'b':
-                    *ptr2++ = '\b';
-                    break;
-                case 'f':
-                    *ptr2++ = '\f';
-                    break;
-                case 'n':
-                    *ptr2++ = '\n';
-                    break;
-                case 'r':
-                    *ptr2++ = '\r';
-                    break;
-                case 't':
-                    *ptr2++ = '\t';
-                    break;
-                case 'u': /* transcode utf16 to utf8. */
-                    uc = parse_hex4(ptr + 1);
-                    ptr += 4; /* get the unicode char. */
-
-                    if ((uc >= 0xDC00 && uc <= 0xDFFF) || uc == 0) break; /* check for invalid.	*/
-
-                    if (uc >= 0xD800 && uc <= 0xDBFF) /* UTF16 surrogate pairs.	*/
-                    {
-                        if (ptr[1] != '\\' || ptr[2] != 'u') break; /* missing second-half of surrogate.	*/
-                        uc2 = parse_hex4(ptr + 3);
-                        ptr += 6;
-                        if (uc2 < 0xDC00 || uc2 > 0xDFFF) break; /* invalid second-half of surrogate.	*/
-                        uc = 0x10000 + (((uc & 0x3FF) << 10) | (uc2 & 0x3FF));
-                    }
-
-                    len = 4;
-                    if (uc < 0x80)
-                        len = 1;
-                    else if (uc < 0x800)
-                        len = 2;
-                    else if (uc < 0x10000)
-                        len = 3;
-                    ptr2 += len;
-
-                    switch (len) {
-                        case 4:
-                            *--ptr2 = ((uc | 0x80) & 0xBF);
-                            uc >>= 6;
-                        case 3:
-                            *--ptr2 = ((uc | 0x80) & 0xBF);
-                            uc >>= 6;
-                        case 2:
-                            *--ptr2 = ((uc | 0x80) & 0xBF);
-                            uc >>= 6;
-                        case 1:
-                            *--ptr2 = ((unsigned char)uc | firstByteMark[len]);
-                    }
-                    ptr2 += len;
-                    break;
-                default:
-                    *ptr2++ = *ptr;
-                    break;
-            }
-            ptr++;
-        }
-    }
-    *ptr2 = 0;
-    if (*ptr == '\"') ptr++;
-    item->valuestring = out;
-    item->type = cJSON_String;
-    return ptr;
-}
-
-/* Render the cstring provided to an escaped version that can be printed. */
-static char *print_string_ptr(const char *str, printbuffer *p) {
-    const char *ptr;
-    char *ptr2;
-    char *out;
-    size_t len = 0, flag = 0;
-    unsigned char token;
-
-    for (ptr = str; *ptr; ptr++) flag |= ((*ptr > 0 && *ptr < 32) || (*ptr == '\"') || (*ptr == '\\')) ? 1 : 0;
-    if (!flag) {
-        len = ptr - str;
-        if (p)
-            out = ensure(p, len + 3);
-        else
-            out = (char *)cJSON_malloc(len + 3);
-        if (!out) return 0;
-        ptr2 = out;
-        *ptr2++ = '\"';
-        strcpy(ptr2, str);
-        ptr2[len] = '\"';
-        ptr2[len + 1] = 0;
-        return out;
-    }
-
-    if (!str) {
-        if (p)
-            out = ensure(p, 3);
-        else
-            out = (char *)cJSON_malloc(3);
-        if (!out) return 0;
-        strcpy(out, "\"\"");
-        return out;
-    }
-    ptr = str;
-    while ((token = *ptr) && ++len) {
-        if (strchr("\"\\\b\f\n\r\t", token))
-            len++;
-        else if (token < 32)
-            len += 5;
-        ptr++;
-    }
-
-    if (p)
-        out = ensure(p, len + 3);
-    else
-        out = (char *)cJSON_malloc(len + 3);
-    if (!out) return 0;
-
-    ptr2 = out;
-    ptr = str;
-    *ptr2++ = '\"';
-    while (*ptr) {
-        if ((unsigned char)*ptr > 31 && *ptr != '\"' && *ptr != '\\')
-            *ptr2++ = *ptr++;
-        else {
-            switch (token = *ptr++) {
-                case '\\':
-                    *ptr2++ = '\\';
-                    break;
-                case '\"':
-                    *ptr2++ = '\"';
-                    break;
-                case '\b':
-                    *ptr2++ = '\b';
-                    break;
-                case '\f':
-                    *ptr2++ = '\f';
-                    break;
-                case '\n':
-                    *ptr2++ = '\n';
-                    break;
-                case '\r':
-                    *ptr2++ = '\r';
-                    break;
-                case '\t':
-                    *ptr2++ = '\t';
-                    break;
-                default:
-                    sprintf(ptr2, "u%04x", token);
-                    ptr2 += 5;
-                    break; /* escape and print */
-            }
-        }
-    }
-    *ptr2++ = '\"';
-    *ptr2++ = 0;
-    return out;
-}
-/* Invote print_string_ptr (which is useful) on an item. */
-static char *print_string(cJSON *item, printbuffer *p) { return print_string_ptr(item->valuestring, p); }
-
-/* Predeclare these prototypes. */
-static const char *parse_value(cJSON *item, const char *value);
-static char *print_value(cJSON *item, int depth, int fmt, printbuffer *p);
-static const char *parse_array(cJSON *item, const char *value);
-static char *print_array(cJSON *item, int depth, int fmt, printbuffer *p);
-static const char *parse_object(cJSON *item, const char *value);
-static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p);
-
-/* Utility to jump whitespace and cr/lf */
-static const char *skip(const char *in) {
-    while (in && *in && (unsigned char)*in <= 32) in++;
-    return in;
-}
-
-/* Parse an object - create a new root, and populate. */
-cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated) {
-    const char *end = 0;
-    cJSON *c = cJSON_New_Item();
-    ep = 0;
-    if (!c) return 0; /* memory fail */
-
-    end = parse_value(c, skip(value));
-    if (!end) {
-        cJSON_Delete(c);
-        return 0;
-    } /* parse failure. ep is set. */
-
-    /* if we require null-terminated JSON without appended garbage, skip and
-     * then check for a null terminator */
-    if (require_null_terminated) {
-        end = skip(end);
-        if (*end) {
-            cJSON_Delete(c);
-            ep = end;
-            return 0;
-        }
-    }
-    if (return_parse_end) *return_parse_end = end;
-    return c;
-}
-/* Default options for cJSON_Parse */
-cJSON *cJSON_Parse(const char *value) { return cJSON_ParseWithOpts(value, 0, 0); }
-
-/* Render a cJSON item/entity/structure to text. */
-char *cJSON_Print(cJSON *item) { return print_value(item, 0, 1, 0); }
-char *cJSON_PrintUnformatted(cJSON *item) { return print_value(item, 0, 0, 0); }
-
-char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt) {
-    printbuffer p;
-    p.buffer = (char *)cJSON_malloc(prebuffer);
-    p.length = prebuffer;
-    p.offset = 0;
-    return print_value(item, 0, fmt, &p);
-}
-
-/* Parser core - when encountering text, process appropriately. */
-static const char *parse_value(cJSON *item, const char *value) {
-    if (!value) return 0; /* Fail on null. */
-    if (!strncmp(value, "null", 4)) {
-        item->type = cJSON_NULL;
-        return value + 4;
-    }
-    if (!strncmp(value, "false", 5)) {
-        item->type = cJSON_False;
-        return value + 5;
-    }
-    if (!strncmp(value, "true", 4)) {
-        item->type = cJSON_True;
-        item->valueint = 1;
-        return value + 4;
-    }
-    if (*value == '\"') {
-        return parse_string(item, value);
-    }
-    if (*value == '-' || (*value >= '0' && *value <= '9')) {
-        return parse_number(item, value);
-    }
-    if (*value == '[') {
-        return parse_array(item, value);
-    }
-    if (*value == '{') {
-        return parse_object(item, value);
-    }
-
-    ep = value;
-    return 0; /* failure. */
-}
-
-/* Render a value to text. */
-static char *print_value(cJSON *item, int depth, int fmt, printbuffer *p) {
-    char *out = 0;
-    if (!item) return 0;
-    if (p) {
-        switch ((item->type) & 255) {
-            case cJSON_NULL: {
-                out = ensure(p, 5);
-                if (out) strcpy(out, "null");
-                break;
-            }
-            case cJSON_False: {
-                out = ensure(p, 6);
-                if (out) strcpy(out, "false");
-                break;
-            }
-            case cJSON_True: {
-                out = ensure(p, 5);
-                if (out) strcpy(out, "true");
-                break;
-            }
-            case cJSON_Number:
-                out = print_number(item, p);
-                break;
-            case cJSON_String:
-                out = print_string(item, p);
-                break;
-            case cJSON_Array:
-                out = print_array(item, depth, fmt, p);
-                break;
-            case cJSON_Object:
-                out = print_object(item, depth, fmt, p);
-                break;
-        }
-    } else {
-        switch ((item->type) & 255) {
-            case cJSON_NULL:
-                out = cJSON_strdup("null");
-                break;
-            case cJSON_False:
-                out = cJSON_strdup("false");
-                break;
-            case cJSON_True:
-                out = cJSON_strdup("true");
-                break;
-            case cJSON_Number:
-                out = print_number(item, 0);
-                break;
-            case cJSON_String:
-                out = print_string(item, 0);
-                break;
-            case cJSON_Array:
-                out = print_array(item, depth, fmt, 0);
-                break;
-            case cJSON_Object:
-                out = print_object(item, depth, fmt, 0);
-                break;
-        }
-    }
-    return out;
-}
-
-/* Build an array from input text. */
-static const char *parse_array(cJSON *item, const char *value) {
-    cJSON *child;
-    if (*value != '[') {
-        ep = value;
-        return 0;
-    } /* not an array! */
-
-    item->type = cJSON_Array;
-    value = skip(value + 1);
-    if (*value == ']') return value + 1; /* empty array. */
-
-    item->child = child = cJSON_New_Item();
-    if (!item->child) return 0;                    /* memory fail */
-    value = skip(parse_value(child, skip(value))); /* skip any spacing, get the value. */
-    if (!value) return 0;
-
-    while (*value == ',') {
-        cJSON *new_item;
-        if (!(new_item = cJSON_New_Item())) return 0; /* memory fail */
-        child->next = new_item;
-        new_item->prev = child;
-        child = new_item;
-        value = skip(parse_value(child, skip(value + 1)));
-        if (!value) return 0; /* memory fail */
-    }
-
-    if (*value == ']') return value + 1; /* end of array */
-    ep = value;
-    return 0; /* malformed. */
-}
-
-/* Render an array to text */
-static char *print_array(cJSON *item, int depth, int fmt, printbuffer *p) {
-    char **entries;
-    char *out = 0, *ptr, *ret;
-    size_t len = 5;
-    cJSON *child = item->child;
-    int numentries = 0, fail = 0, j = 0;
-    size_t tmplen = 0, i = 0;
-
-    /* How many entries in the array? */
-    while (child) numentries++, child = child->next;
-    /* Explicitly handle numentries==0 */
-    if (!numentries) {
-        if (p)
-            out = ensure(p, 3);
-        else
-            out = (char *)cJSON_malloc(3);
-        if (out) strcpy(out, "[]");
-        return out;
-    }
-
-    if (p) {
-        /* Compose the output array. */
-        i = p->offset;
-        ptr = ensure(p, 1);
-        if (!ptr) return 0;
-        *ptr = '[';
-        p->offset++;
-        child = item->child;
-        while (child && !fail) {
-            print_value(child, depth + 1, fmt, p);
-            p->offset = update(p);
-            if (child->next) {
-                len = fmt ? 2 : 1;
-                ptr = ensure(p, len + 1);
-                if (!ptr) return 0;
-                *ptr++ = ',';
-                if (fmt) *ptr++ = ' ';
-                *ptr = 0;
-                p->offset += len;
-            }
-            child = child->next;
-        }
-        ptr = ensure(p, 2);
-        if (!ptr) return 0;
-        *ptr++ = ']';
-        *ptr = 0;
-        out = (p->buffer) + i;
-    } else {
-        /* Allocate an array to hold the values for each */
-        entries = (char **)cJSON_malloc(numentries * sizeof(char *));
-        if (!entries) return 0;
-        memset(entries, 0, numentries * sizeof(char *));
-        /* Retrieve all the results: */
-        child = item->child;
-        while (child && !fail) {
-            ret = print_value(child, depth + 1, fmt, 0);
-            entries[i++] = ret;
-            if (ret)
-                len += strlen(ret) + 2 + (fmt ? 1 : 0);
-            else
-                fail = 1;
-            child = child->next;
-        }
-
-        /* If we didn't fail, try to malloc the output string */
-        if (!fail) out = (char *)cJSON_malloc(len);
-        /* If that fails, we fail. */
-        if (!out) fail = 1;
-
-        /* Handle failure. */
-        if (fail) {
-            for (j = 0; j < numentries; j++)
-                if (entries[j]) cJSON_free(entries[j]);
-            cJSON_free(entries);
-            return 0;
-        }
-
-        /* Compose the output array. */
-        *out = '[';
-        ptr = out + 1;
-        *ptr = 0;
-        for (j = 0; j < numentries; j++) {
-            tmplen = strlen(entries[j]);
-            memcpy(ptr, entries[j], tmplen);
-            ptr += tmplen;
-            if (j != numentries - 1) {
-                *ptr++ = ',';
-                if (fmt) *ptr++ = ' ';
-                *ptr = 0;
-            }
-            cJSON_free(entries[j]);
-        }
-        cJSON_free(entries);
-        *ptr++ = ']';
-        *ptr++ = 0;
-    }
-    return out;
-}
-
-/* Build an object from the text. */
-static const char *parse_object(cJSON *item, const char *value) {
-    cJSON *child;
-    if (*value != '{') {
-        ep = value;
-        return 0;
-    } /* not an object! */
-
-    item->type = cJSON_Object;
-    value = skip(value + 1);
-    if (*value == '}') return value + 1; /* empty array. */
-
-    item->child = child = cJSON_New_Item();
-    if (!item->child) return 0;
-    value = skip(parse_string(child, skip(value)));
-    if (!value) return 0;
-    child->string = child->valuestring;
-    child->valuestring = 0;
-    if (*value != ':') {
-        ep = value;
-        return 0;
-    }                                                  /* fail! */
-    value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
-    if (!value) return 0;
-
-    while (*value == ',') {
-        cJSON *new_item;
-        if (!(new_item = cJSON_New_Item())) return 0; /* memory fail */
-        child->next = new_item;
-        new_item->prev = child;
-        child = new_item;
-        value = skip(parse_string(child, skip(value + 1)));
-        if (!value) return 0;
-        child->string = child->valuestring;
-        child->valuestring = 0;
-        if (*value != ':') {
-            ep = value;
-            return 0;
-        }                                                  /* fail! */
-        value = skip(parse_value(child, skip(value + 1))); /* skip any spacing, get the value. */
-        if (!value) return 0;
-    }
-
-    if (*value == '}') return value + 1; /* end of array */
-    ep = value;
-    return 0; /* malformed. */
-}
-
-/* Render an object to text. */
-static char *print_object(cJSON *item, int depth, int fmt, printbuffer *p) {
-    char **entries = 0, **names = 0;
-    char *out = 0, *ptr, *ret, *str;
-    int j;
-    cJSON *child = item->child;
-    int numentries = 0, fail = 0, k;
-    size_t tmplen = 0, i = 0, len = 7;
-    /* Count the number of entries. */
-    while (child) numentries++, child = child->next;
-    /* Explicitly handle empty object case */
-    if (!numentries) {
-        if (p)
-            out = ensure(p, fmt ? depth + 4 : 3);
-        else
-            out = (char *)cJSON_malloc(fmt ? depth + 4 : 3);
-        if (!out) return 0;
-        ptr = out;
-        *ptr++ = '{';
-        if (fmt) {
-            *ptr++ = '\n';
-            for (j = 0; j < depth - 1; j++) *ptr++ = '\t';
-        }
-        *ptr++ = '}';
-        *ptr++ = 0;
-        return out;
-    }
-    if (p) {
-        /* Compose the output: */
-        i = p->offset;
-        len = fmt ? 2 : 1;
-        ptr = ensure(p, len + 1);
-        if (!ptr) return 0;
-        *ptr++ = '{';
-        if (fmt) *ptr++ = '\n';
-        *ptr = 0;
-        p->offset += len;
-        child = item->child;
-        depth++;
-        while (child) {
-            if (fmt) {
-                ptr = ensure(p, depth);
-                if (!ptr) return 0;
-                for (j = 0; j < depth; j++) *ptr++ = '\t';
-                p->offset += depth;
-            }
-            print_string_ptr(child->string, p);
-            p->offset = update(p);
-
-            len = fmt ? 2 : 1;
-            ptr = ensure(p, len);
-            if (!ptr) return 0;
-            *ptr++ = ':';
-            if (fmt) *ptr++ = '\t';
-            p->offset += len;
-
-            print_value(child, depth, fmt, p);
-            p->offset = update(p);
-
-            len = (fmt ? 1 : 0) + (child->next ? 1 : 0);
-            ptr = ensure(p, len + 1);
-            if (!ptr) return 0;
-            if (child->next) *ptr++ = ',';
-            if (fmt) *ptr++ = '\n';
-            *ptr = 0;
-            p->offset += len;
-            child = child->next;
-        }
-        ptr = ensure(p, fmt ? (depth + 1) : 2);
-        if (!ptr) return 0;
-        if (fmt)
-            for (j = 0; j < depth - 1; j++) *ptr++ = '\t';
-        *ptr++ = '}';
-        *ptr = 0;
-        out = (p->buffer) + i;
-    } else {
-        /* Allocate space for the names and the objects */
-        entries = (char **)cJSON_malloc(numentries * sizeof(char *));
-        if (!entries) return 0;
-        names = (char **)cJSON_malloc(numentries * sizeof(char *));
-        if (!names) {
-            cJSON_free(entries);
-            return 0;
-        }
-        memset(entries, 0, sizeof(char *) * numentries);
-        memset(names, 0, sizeof(char *) * numentries);
-
-        /* Collect all the results into our arrays: */
-        child = item->child;
-        depth++;
-        if (fmt) len += depth;
-        while (child) {
-            names[i] = str = print_string_ptr(child->string, 0);
-            entries[i++] = ret = print_value(child, depth, fmt, 0);
-            if (str && ret)
-                len += strlen(ret) + strlen(str) + 2 + (fmt ? 2 + depth : 0);
-            else
-                fail = 1;
-            child = child->next;
-        }
-
-        /* Try to allocate the output string */
-        if (!fail) out = (char *)cJSON_malloc(len);
-        if (!out) fail = 1;
-
-        /* Handle failure */
-        if (fail) {
-            for (j = 0; j < numentries; j++) {
-                if (names[i]) cJSON_free(names[j]);
-                if (entries[j]) cJSON_free(entries[j]);
-            }
-            cJSON_free(names);
-            cJSON_free(entries);
-            return 0;
-        }
-
-        /* Compose the output: */
-        *out = '{';
-        ptr = out + 1;
-        if (fmt) *ptr++ = '\n';
-        *ptr = 0;
-        for (j = 0; j < numentries; j++) {
-            if (fmt)
-                for (k = 0; k < depth; k++) *ptr++ = '\t';
-            tmplen = strlen(names[j]);
-            memcpy(ptr, names[j], tmplen);
-            ptr += tmplen;
-            *ptr++ = ':';
-            if (fmt) *ptr++ = '\t';
-            strcpy(ptr, entries[j]);
-            ptr += strlen(entries[j]);
-            if (j != numentries - 1) *ptr++ = ',';
-            if (fmt) *ptr++ = '\n';
-            *ptr = 0;
-            cJSON_free(names[j]);
-            cJSON_free(entries[j]);
-        }
-
-        cJSON_free(names);
-        cJSON_free(entries);
-        if (fmt)
-            for (j = 0; j < depth - 1; j++) *ptr++ = '\t';
-        *ptr++ = '}';
-        *ptr++ = 0;
-    }
-    return out;
-}
-
-/* Get Array size/item / object item. */
-int cJSON_GetArraySize(cJSON *array) {
-    cJSON *c = array->child;
-    int i = 0;
-    while (c) i++, c = c->next;
-    return i;
-}
-cJSON *cJSON_GetArrayItem(cJSON *array, int item) {
-    cJSON *c = array->child;
-    while (c && item > 0) item--, c = c->next;
-    return c;
-}
-cJSON *cJSON_GetObjectItem(cJSON *object, const char *string) {
-    cJSON *c = object->child;
-    while (c && strcmp(c->string, string)) c = c->next;
-    return c;
-}
-
-/* Utility for array list handling. */
-static void suffix_object(cJSON *prev, cJSON *item) {
-    prev->next = item;
-    item->prev = prev;
-}
-/* Utility for handling references. */
-static cJSON *create_reference(cJSON *item) {
-    cJSON *ref = cJSON_New_Item();
-    if (!ref) return 0;
-    memcpy(ref, item, sizeof(cJSON));
-    ref->string = 0;
-    ref->type |= cJSON_IsReference;
-    ref->next = ref->prev = 0;
-    return ref;
-}
-
-/* Add item to array/object. */
-void cJSON_AddItemToArray(cJSON *array, cJSON *item) {
-    cJSON *c = array->child;
-    if (!item) return;
-    if (!c) {
-        array->child = item;
-    } else {
-        while (c && c->next) c = c->next;
-        suffix_object(c, item);
-    }
-}
-void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) {
-    if (!item) return;
-    if (item->string) cJSON_free(item->string);
-    item->string = cJSON_strdup(string);
-    cJSON_AddItemToArray(object, item);
-}
-void cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) {
-    if (!item) return;
-    if (!(item->type & cJSON_StringIsConst) && item->string) cJSON_free(item->string);
-    item->string = (char *)string;
-    item->type |= cJSON_StringIsConst;
-    cJSON_AddItemToArray(object, item);
-}
-void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) { cJSON_AddItemToArray(array, create_reference(item)); }
-void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) {
-    cJSON_AddItemToObject(object, string, create_reference(item));
-}
-
-cJSON *cJSON_DetachItemFromArray(cJSON *array, int which) {
-    cJSON *c = array->child;
-    while (c && which > 0) c = c->next, which--;
-    if (!c) return 0;
-    if (c->prev) c->prev->next = c->next;
-    if (c->next) c->next->prev = c->prev;
-    if (c == array->child) array->child = c->next;
-    c->prev = c->next = 0;
-    return c;
-}
-void cJSON_DeleteItemFromArray(cJSON *array, int which) { cJSON_Delete(cJSON_DetachItemFromArray(array, which)); }
-cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string) {
-    int i = 0;
-    cJSON *c = object->child;
-    while (c && strcmp(c->string, string)) i++, c = c->next;
-    if (c) return cJSON_DetachItemFromArray(object, i);
-    return 0;
-}
-void cJSON_DeleteItemFromObject(cJSON *object, const char *string) { cJSON_Delete(cJSON_DetachItemFromObject(object, string)); }
-
-/* Replace array/object items with new ones. */
-void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) {
-    cJSON *c = array->child;
-    while (c && which > 0) c = c->next, which--;
-    if (!c) {
-        cJSON_AddItemToArray(array, newitem);
-        return;
-    }
-    newitem->next = c;
-    newitem->prev = c->prev;
-    c->prev = newitem;
-    if (c == array->child)
-        array->child = newitem;
-    else
-        newitem->prev->next = newitem;
-}
-void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) {
-    cJSON *c = array->child;
-    while (c && which > 0) c = c->next, which--;
-    if (!c) return;
-    newitem->next = c->next;
-    newitem->prev = c->prev;
-    if (newitem->next) newitem->next->prev = newitem;
-    if (c == array->child)
-        array->child = newitem;
-    else
-        newitem->prev->next = newitem;
-    c->next = c->prev = 0;
-    cJSON_Delete(c);
-}
-void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) {
-    int i = 0;
-    cJSON *c = object->child;
-    while (c && strcmp(c->string, string)) i++, c = c->next;
-    if (c) {
-        newitem->string = cJSON_strdup(string);
-        cJSON_ReplaceItemInArray(object, i, newitem);
-    }
-}
-
-/* Create basic types: */
-cJSON *cJSON_CreateNull(void) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = cJSON_NULL;
-    return item;
-}
-cJSON *cJSON_CreateTrue(void) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = cJSON_True;
-    return item;
-}
-cJSON *cJSON_CreateFalse(void) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = cJSON_False;
-    return item;
-}
-cJSON *cJSON_CreateBool(int b) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = b ? cJSON_True : cJSON_False;
-    return item;
-}
-cJSON *cJSON_CreateNumber(double num) {
-    cJSON *item = cJSON_New_Item();
-    if (item) {
-        item->type = cJSON_Number;
-        item->valuedouble = num;
-        item->valueint = (int)num;
-    }
-    return item;
-}
-cJSON *cJSON_CreateString(const char *string) {
-    cJSON *item = cJSON_New_Item();
-    if (item) {
-        item->type = cJSON_String;
-        item->valuestring = cJSON_strdup(string);
-    }
-    return item;
-}
-cJSON *cJSON_CreateArray(void) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = cJSON_Array;
-    return item;
-}
-cJSON *cJSON_CreateObject(void) {
-    cJSON *item = cJSON_New_Item();
-    if (item) item->type = cJSON_Object;
-    return item;
-}
-
-/* Create Arrays: */
-cJSON *cJSON_CreateIntArray(const int *numbers, int count) {
-    int i;
-    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
-    for (i = 0; a && i < count; i++) {
-        n = cJSON_CreateNumber(numbers[i]);
-        if (!i)
-            a->child = n;
-        else
-            suffix_object(p, n);
-        p = n;
-    }
-    return a;
-}
-cJSON *cJSON_CreateFloatArray(const float *numbers, int count) {
-    int i;
-    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
-    for (i = 0; a && i < count; i++) {
-        n = cJSON_CreateNumber(numbers[i]);
-        if (!i)
-            a->child = n;
-        else
-            suffix_object(p, n);
-        p = n;
-    }
-    return a;
-}
-cJSON *cJSON_CreateDoubleArray(const double *numbers, int count) {
-    int i;
-    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
-    for (i = 0; a && i < count; i++) {
-        n = cJSON_CreateNumber(numbers[i]);
-        if (!i)
-            a->child = n;
-        else
-            suffix_object(p, n);
-        p = n;
-    }
-    return a;
-}
-cJSON *cJSON_CreateStringArray(const char **strings, int count) {
-    int i;
-    cJSON *n = 0, *p = 0, *a = cJSON_CreateArray();
-    for (i = 0; a && i < count; i++) {
-        n = cJSON_CreateString(strings[i]);
-        if (!i)
-            a->child = n;
-        else
-            suffix_object(p, n);
-        p = n;
-    }
-    return a;
-}
-
-/* Duplication */
-cJSON *cJSON_Duplicate(cJSON *item, int recurse) {
-    cJSON *newitem, *cptr, *nptr = 0, *newchild;
-    /* Bail on bad ptr */
-    if (!item) return 0;
-    /* Create new item */
-    newitem = cJSON_New_Item();
-    if (!newitem) return 0;
-    /* Copy over all vars */
-    newitem->type = item->type & (~cJSON_IsReference), newitem->valueint = item->valueint, newitem->valuedouble = item->valuedouble;
-    if (item->valuestring) {
-        newitem->valuestring = cJSON_strdup(item->valuestring);
-        if (!newitem->valuestring) {
-            cJSON_Delete(newitem);
-            return 0;
-        }
-    }
-    if (item->string) {
-        newitem->string = cJSON_strdup(item->string);
-        if (!newitem->string) {
-            cJSON_Delete(newitem);
-            return 0;
-        }
-    }
-    /* If non-recursive, then we're done! */
-    if (!recurse) return newitem;
-    /* Walk the ->next chain for the child. */
-    cptr = item->child;
-    while (cptr) {
-        newchild = cJSON_Duplicate(cptr, 1); /* Duplicate (with recurse) each item in the ->next chain */
-        if (!newchild) {
-            cJSON_Delete(newitem);
-            return 0;
-        }
-        if (nptr) {
-            nptr->next = newchild, newchild->prev = nptr;
-            nptr = newchild;
-        } /* If newitem->child already set, then crosswire ->prev and ->next and
-             move on */
-        else {
-            newitem->child = newchild;
-            nptr = newchild;
-        } /* Set newitem->child and move to it */
-        cptr = cptr->next;
-    }
-    return newitem;
-}
-
-void cJSON_Minify(char *json) {
-    char *into = json;
-    while (*json) {
-        if (*json == ' ')
-            json++;
-        else if (*json == '\t')
-            json++; /* Whitespace characters. */
-        else if (*json == '\r')
-            json++;
-        else if (*json == '\n')
-            json++;
-        else if (*json == '/' && json[1] == '/')
-            while (*json && *json != '\n') json++; /* double-slash comments, to end of line. */
-        else if (*json == '/' && json[1] == '*') {
-            while (*json && !(*json == '*' && json[1] == '/')) json++;
-            json += 2;
-        } /* multiline comments. */
-        else if (*json == '\"') {
-            *into++ = *json++;
-            while (*json && *json != '\"') {
-                if (*json == '\\') *into++ = *json++;
-                *into++ = *json++;
-            }
-            *into++ = *json++;
-        } /* string literals, which are \" sensitive. */
-        else
-            *into++ = *json++; /* All other characters. */
-    }
-    *into = 0; /* and null-terminate. */
-}
diff --git a/third_party/vulkan/loader/cJSON.h b/third_party/vulkan/loader/cJSON.h
deleted file mode 100644
index f0059abdc..000000000
--- a/third_party/vulkan/loader/cJSON.h
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
-  Copyright (c) 2009 Dave Gamble
-  Copyright (c) 2015-2016 The Khronos Group Inc.
-  Copyright (c) 2015-2016 Valve Corporation
-  Copyright (c) 2015-2016 LunarG, Inc.
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-#ifndef cJSON__h
-#define cJSON__h
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* cJSON Types: */
-#define cJSON_False 0
-#define cJSON_True 1
-#define cJSON_NULL 2
-#define cJSON_Number 3
-#define cJSON_String 4
-#define cJSON_Array 5
-#define cJSON_Object 6
-
-#define cJSON_IsReference 256
-#define cJSON_StringIsConst 512
-
-/* The cJSON structure: */
-typedef struct cJSON {
-    struct cJSON *next, *prev; /* next/prev allow you to walk array/object
-                                  chains. Alternatively, use
-                                  GetArraySize/GetArrayItem/GetObjectItem */
-    struct cJSON *child;       /* An array or object item will have a child pointer
-                                  pointing to a chain of the items in the
-                                  array/object. */
-
-    int type; /* The type of the item, as above. */
-
-    char *valuestring;  /* The item's string, if type==cJSON_String */
-    int valueint;       /* The item's number, if type==cJSON_Number */
-    double valuedouble; /* The item's number, if type==cJSON_Number */
-
-    char *string; /* The item's name string, if this item is the child of, or is
-                     in the list of subitems of an object. */
-} cJSON;
-
-typedef struct cJSON_Hooks {
-    void *(*malloc_fn)(size_t sz);
-    void (*free_fn)(void *ptr);
-} cJSON_Hooks;
-
-/* Supply malloc, realloc and free functions to cJSON */
-extern void cJSON_InitHooks(cJSON_Hooks *hooks);
-
-/* Supply a block of JSON, and this returns a cJSON object you can interrogate.
- * Call cJSON_Delete when finished. */
-extern cJSON *cJSON_Parse(const char *value);
-/* Render a cJSON entity to text for transfer/storage. Free the char* when
- * finished. */
-extern char *cJSON_Print(cJSON *item);
-/* Render a cJSON entity to text for transfer/storage without any formatting.
- * Free the char* when finished. */
-extern char *cJSON_PrintUnformatted(cJSON *item);
-/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess
- * at the final size. guessing well reduces reallocation. fmt=0 gives
- * unformatted, =1 gives formatted */
-extern char *cJSON_PrintBuffered(cJSON *item, int prebuffer, int fmt);
-/* Delete a cJSON entity and all subentities. */
-extern void cJSON_Delete(cJSON *c);
-/* Delete an item allocated inside the JSON parser*/
-extern void cJSON_Free(void *p);
-
-/* Returns the number of items in an array (or object). */
-extern int cJSON_GetArraySize(cJSON *array);
-/* Retrieve item number "item" from array "array". Returns NULL if unsuccessful.
- */
-extern cJSON *cJSON_GetArrayItem(cJSON *array, int item);
-/* Get item "string" from object. Case insensitive. */
-extern cJSON *cJSON_GetObjectItem(cJSON *object, const char *string);
-
-/* For analysing failed parses. This returns a pointer to the parse error.
- * You'll probably need to look a few chars back to make sense of it. Defined
- * when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
-extern const char *cJSON_GetErrorPtr(void);
-
-/* These calls create a cJSON item of the appropriate type. */
-extern cJSON *cJSON_CreateNull(void);
-extern cJSON *cJSON_CreateTrue(void);
-extern cJSON *cJSON_CreateFalse(void);
-extern cJSON *cJSON_CreateBool(int b);
-extern cJSON *cJSON_CreateNumber(double num);
-extern cJSON *cJSON_CreateString(const char *string);
-extern cJSON *cJSON_CreateArray(void);
-extern cJSON *cJSON_CreateObject(void);
-
-/* These utilities create an Array of count items. */
-extern cJSON *cJSON_CreateIntArray(const int *numbers, int count);
-extern cJSON *cJSON_CreateFloatArray(const float *numbers, int count);
-extern cJSON *cJSON_CreateDoubleArray(const double *numbers, int count);
-extern cJSON *cJSON_CreateStringArray(const char **strings, int count);
-
-/* Append item to the specified array/object. */
-extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);
-extern void cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
-extern void cJSON_AddItemToObjectCS(cJSON *object, const char *string,
-                                    cJSON *item); /* Use this when string is definitely const (i.e. a literal,
-                                                     or as good as), and will definitely survive the cJSON
-                                                     object */
-/* Append reference to item to the specified array/object. Use this when you
- * want to add an existing cJSON to a new cJSON, but don't want to corrupt your
- * existing cJSON. */
-extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
-extern void cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
-
-/* Remove/Detatch items from Arrays/Objects. */
-extern cJSON *cJSON_DetachItemFromArray(cJSON *array, int which);
-extern void cJSON_DeleteItemFromArray(cJSON *array, int which);
-extern cJSON *cJSON_DetachItemFromObject(cJSON *object, const char *string);
-extern void cJSON_DeleteItemFromObject(cJSON *object, const char *string);
-
-/* Update array items. */
-extern void cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
-extern void cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
-extern void cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem);
-
-/* Duplicate a cJSON item */
-extern cJSON *cJSON_Duplicate(cJSON *item, int recurse);
-/* Duplicate will create a new, identical cJSON item to the one you pass, in new
-memory that will
-need to be released. With recurse!=0, it will duplicate any children connected
-to the item.
-The item->next and ->prev pointers are always zero on return from Duplicate. */
-
-/* ParseWithOpts allows you to require (and check) that the JSON is null
- * terminated, and to retrieve the pointer to the final byte parsed. */
-extern cJSON *cJSON_ParseWithOpts(const char *value, const char **return_parse_end, int require_null_terminated);
-
-extern void cJSON_Minify(char *json);
-
-/* Macros for creating things quickly. */
-#define cJSON_AddNullToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateNull())
-#define cJSON_AddTrueToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
-#define cJSON_AddFalseToObject(object, name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
-#define cJSON_AddBoolToObject(object, name, b) cJSON_AddItemToObject(object, name, cJSON_CreateBool(b))
-#define cJSON_AddNumberToObject(object, name, n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
-#define cJSON_AddStringToObject(object, name, s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
-
-/* When assigning an integer value, it needs to be propagated to valuedouble
- * too. */
-#define cJSON_SetIntValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
-#define cJSON_SetNumberValue(object, val) ((object) ? (object)->valueint = (object)->valuedouble = (val) : (val))
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/third_party/vulkan/loader/debug_report.c b/third_party/vulkan/loader/debug_report.c
deleted file mode 100644
index 04e55ccfc..000000000
--- a/third_party/vulkan/loader/debug_report.c
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- * Copyright (C) 2015-2016 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
- * Author: Jon Ashburn <jon@LunarG.com>
- *
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <inttypes.h>
-#ifndef WIN32
-#include <signal.h>
-#else
-#endif
-#include "vk_loader_platform.h"
-#include "debug_report.h"
-#include "vulkan/vk_layer.h"
-
-typedef void(VKAPI_PTR *PFN_stringCallback)(char *message);
-
-static const VkExtensionProperties debug_report_extension_info = {
-    .extensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME, .specVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION,
-};
-
-void debug_report_add_instance_extensions(const struct loader_instance *inst, struct loader_extension_list *ext_list) {
-    loader_add_to_ext_list(inst, ext_list, 1, &debug_report_extension_info);
-}
-
-void debug_report_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
-    ptr_instance->enabled_known_extensions.ext_debug_report = 0;
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DEBUG_REPORT_EXTENSION_NAME) == 0) {
-            ptr_instance->enabled_known_extensions.ext_debug_report = 1;
-            return;
-        }
-    }
-}
-
-VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                                        const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback) {
-    VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL;
-
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
-                                                                              sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    } else {
-#endif
-        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode),
-                                                                               VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    }
-    if (!pNewDbgFuncNode) {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode));
-
-    pNewDbgFuncNode->msgCallback = callback;
-    pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
-    pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
-    pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
-    pNewDbgFuncNode->pNext = inst->DbgFunctionHead;
-    inst->DbgFunctionHead = pNewDbgFuncNode;
-
-    return VK_SUCCESS;
-}
-
-static VKAPI_ATTR VkResult VKAPI_CALL
-debug_report_CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                                          const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) {
-    struct loader_instance *inst = loader_get_instance(instance);
-    loader_platform_thread_lock_mutex(&loader_lock);
-    VkResult result = inst->disp->layer_inst_disp.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return result;
-}
-
-// Utility function to handle reporting
-VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType,
-                                 uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
-    VkBool32 bail = false;
-    VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
-    while (pTrav) {
-        if (pTrav->msgFlags & msgFlags) {
-            if (pTrav->pfnMsgCallback(msgFlags, objectType, srcObject, location, msgCode, pLayerPrefix, pMsg, pTrav->pUserData)) {
-                bail = true;
-            }
-        }
-        pTrav = pTrav->pNext;
-    }
-
-    return bail;
-}
-
-void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback,
-                                     const VkAllocationCallbacks *pAllocator) {
-    VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
-    VkLayerDbgFunctionNode *pPrev = pTrav;
-
-    while (pTrav) {
-        if (pTrav->msgCallback == callback) {
-            pPrev->pNext = pTrav->pNext;
-            if (inst->DbgFunctionHead == pTrav) inst->DbgFunctionHead = pTrav->pNext;
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-            {
-#else
-            if (pAllocator != NULL) {
-                pAllocator->pfnFree(pAllocator->pUserData, pTrav);
-            } else {
-#endif
-                loader_instance_heap_free(inst, pTrav);
-            }
-            break;
-        }
-        pPrev = pTrav;
-        pTrav = pTrav->pNext;
-    }
-}
-
-// This utility (used by vkInstanceCreateInfo(), looks at a pNext chain.  It
-// counts any VkDebugReportCallbackCreateInfoEXT structs that it finds.  It
-// then allocates array that can hold that many structs, as well as that many
-// VkDebugReportCallbackEXT handles.  It then copies each
-// VkDebugReportCallbackCreateInfoEXT, and initializes each handle.
-VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks,
-                                         VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks) {
-    uint32_t n = *num_callbacks = 0;
-    VkDebugReportCallbackCreateInfoEXT *pInfos = NULL;
-    VkDebugReportCallbackEXT *pCallbacks = NULL;
-
-    // NOTE: The loader is not using pAllocator, and so this function doesn't
-    // either.
-
-    const void *pNext = pChain;
-    while (pNext) {
-        // 1st, count the number VkDebugReportCallbackCreateInfoEXT:
-        if (((VkDebugReportCallbackCreateInfoEXT *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
-            n++;
-        }
-        pNext = (void *)((VkDebugReportCallbackCreateInfoEXT *)pNext)->pNext;
-    }
-    if (n == 0) {
-        return VK_SUCCESS;
-    }
-
-// 2nd, allocate memory for each VkDebugReportCallbackCreateInfoEXT:
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)pAllocator->pfnAllocation(
-            pAllocator->pUserData, n * sizeof(VkDebugReportCallbackCreateInfoEXT), sizeof(void *),
-            VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
-    } else {
-#endif
-        pInfos = *infos = ((VkDebugReportCallbackCreateInfoEXT *)malloc(n * sizeof(VkDebugReportCallbackCreateInfoEXT)));
-    }
-    if (!pInfos) {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-// 3rd, allocate memory for a unique handle for each callback:
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(
-            pAllocator->pUserData, n * sizeof(VkDebugReportCallbackEXT), sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
-        if (!pCallbacks) {
-            pAllocator->pfnFree(pAllocator->pUserData, pInfos);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-    } else {
-#endif
-        pCallbacks = *callbacks = ((VkDebugReportCallbackEXT *)malloc(n * sizeof(VkDebugReportCallbackEXT)));
-        if (!pCallbacks) {
-            free(pInfos);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-    }
-    // 4th, copy each VkDebugReportCallbackCreateInfoEXT for use by
-    // vkDestroyInstance, and assign a unique handle to each callback (just
-    // use the address of the copied VkDebugReportCallbackCreateInfoEXT):
-    pNext = pChain;
-    while (pNext) {
-        if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
-            memcpy(pInfos, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT));
-            *pCallbacks++ = (VkDebugReportCallbackEXT)(uintptr_t)pInfos++;
-        }
-        pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext;
-    }
-
-    *num_callbacks = n;
-    return VK_SUCCESS;
-}
-
-void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos,
-                                     VkDebugReportCallbackEXT *callbacks) {
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        pAllocator->pfnFree(pAllocator->pUserData, infos);
-        pAllocator->pfnFree(pAllocator->pUserData, callbacks);
-    } else {
-#endif
-        free(infos);
-        free(callbacks);
-    }
-}
-
-VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
-                                         uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
-                                         VkDebugReportCallbackEXT *callbacks) {
-    VkResult rtn = VK_SUCCESS;
-    for (uint32_t i = 0; i < num_callbacks; i++) {
-        rtn = util_CreateDebugReportCallback(inst, &infos[i], pAllocator, callbacks[i]);
-        if (rtn != VK_SUCCESS) {
-            for (uint32_t j = 0; j < i; j++) {
-                util_DestroyDebugReportCallback(inst, callbacks[j], pAllocator);
-            }
-            return rtn;
-        }
-    }
-    return rtn;
-}
-
-void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks,
-                                      VkDebugReportCallbackEXT *callbacks) {
-    for (uint32_t i = 0; i < num_callbacks; i++) {
-        util_DestroyDebugReportCallback(inst, callbacks[i], pAllocator);
-    }
-}
-
-static VKAPI_ATTR void VKAPI_CALL debug_report_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
-                                                                             const VkAllocationCallbacks *pAllocator) {
-    struct loader_instance *inst = loader_get_instance(instance);
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    inst->disp->layer_inst_disp.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
-
-    util_DestroyDebugReportCallback(inst, callback, pAllocator);
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-}
-
-static VKAPI_ATTR void VKAPI_CALL debug_report_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
-                                                                     VkDebugReportObjectTypeEXT objType, uint64_t object,
-                                                                     size_t location, int32_t msgCode, const char *pLayerPrefix,
-                                                                     const char *pMsg) {
-    struct loader_instance *inst = loader_get_instance(instance);
-
-    inst->disp->layer_inst_disp.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
-}
-
-// This is the instance chain terminator function
-// for CreateDebugReportCallback
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallbackEXT(VkInstance instance,
-                                                                       const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkDebugReportCallbackEXT *pCallback) {
-    VkDebugReportCallbackEXT *icd_info = NULL;
-    const struct loader_icd_term *icd_term;
-    struct loader_instance *inst = (struct loader_instance *)instance;
-    VkResult res = VK_SUCCESS;
-    uint32_t storage_idx;
-    VkLayerDbgFunctionNode *pNewDbgFuncNode = NULL;
-
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        icd_info = ((VkDebugReportCallbackEXT *)pAllocator->pfnAllocation(pAllocator->pUserData,
-                                                                          inst->total_icd_count * sizeof(VkDebugReportCallbackEXT),
-                                                                          sizeof(void *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
-        if (icd_info) {
-            memset(icd_info, 0, inst->total_icd_count * sizeof(VkDebugReportCallbackEXT));
-        }
-    } else {
-#endif
-        icd_info = calloc(sizeof(VkDebugReportCallbackEXT), inst->total_icd_count);
-    }
-    if (!icd_info) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    storage_idx = 0;
-    for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
-        if (!icd_term->dispatch.CreateDebugReportCallbackEXT) {
-            continue;
-        }
-
-        res = icd_term->dispatch.CreateDebugReportCallbackEXT(icd_term->instance, pCreateInfo, pAllocator, &icd_info[storage_idx]);
-
-        if (res != VK_SUCCESS) {
-            goto out;
-        }
-        storage_idx++;
-    }
-
-// Setup the debug report callback in the terminator since a layer may want
-// to grab the information itself (RenderDoc) and then return back to the
-// user callback a sub-set of the messages.
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 0)
-    if (pAllocator != NULL) {
-        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(VkLayerDbgFunctionNode),
-                                                                              sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    } else {
-#else
-    {
-#endif
-        pNewDbgFuncNode = (VkLayerDbgFunctionNode *)loader_instance_heap_alloc(inst, sizeof(VkLayerDbgFunctionNode),
-                                                                               VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    }
-    if (!pNewDbgFuncNode) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(pNewDbgFuncNode, 0, sizeof(VkLayerDbgFunctionNode));
-
-    pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
-    pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
-    pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
-    pNewDbgFuncNode->pNext = inst->DbgFunctionHead;
-    inst->DbgFunctionHead = pNewDbgFuncNode;
-
-    *(VkDebugReportCallbackEXT **)pCallback = icd_info;
-    pNewDbgFuncNode->msgCallback = *pCallback;
-
-out:
-
-    // Roll back on errors
-    if (VK_SUCCESS != res) {
-        storage_idx = 0;
-        for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
-            if (NULL == icd_term->dispatch.DestroyDebugReportCallbackEXT) {
-                continue;
-            }
-
-            if (icd_info && icd_info[storage_idx]) {
-                icd_term->dispatch.DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator);
-            }
-            storage_idx++;
-        }
-
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-        {
-#else
-        if (pAllocator != NULL) {
-            if (NULL != pNewDbgFuncNode) {
-                pAllocator->pfnFree(pAllocator->pUserData, pNewDbgFuncNode);
-            }
-            if (NULL != icd_info) {
-                pAllocator->pfnFree(pAllocator->pUserData, icd_info);
-            }
-        } else {
-#endif
-            if (NULL != pNewDbgFuncNode) {
-                free(pNewDbgFuncNode);
-            }
-            if (NULL != icd_info) {
-                free(icd_info);
-            }
-        }
-    }
-
-    return res;
-}
-
-// This is the instance chain terminator function for DestroyDebugReportCallback
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
-                                                                    const VkAllocationCallbacks *pAllocator) {
-    uint32_t storage_idx;
-    VkDebugReportCallbackEXT *icd_info;
-    const struct loader_icd_term *icd_term;
-
-    struct loader_instance *inst = (struct loader_instance *)instance;
-    icd_info = *(VkDebugReportCallbackEXT **)&callback;
-    storage_idx = 0;
-    for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
-        if (NULL == icd_term->dispatch.DestroyDebugReportCallbackEXT) {
-            continue;
-        }
-
-        if (icd_info[storage_idx]) {
-            icd_term->dispatch.DestroyDebugReportCallbackEXT(icd_term->instance, icd_info[storage_idx], pAllocator);
-        }
-        storage_idx++;
-    }
-
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator != NULL) {
-        pAllocator->pfnFree(pAllocator->pUserData, icd_info);
-    } else {
-#endif
-        free(icd_info);
-    }
-}
-
-// This is the instance chain terminator function for DebugReportMessage
-VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
-                                                            VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
-                                                            int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
-    const struct loader_icd_term *icd_term;
-
-    struct loader_instance *inst = (struct loader_instance *)instance;
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-    for (icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
-        if (icd_term->dispatch.DebugReportMessageEXT != NULL) {
-            icd_term->dispatch.DebugReportMessageEXT(icd_term->instance, flags, objType, object, location, msgCode, pLayerPrefix,
-                                                     pMsg);
-        }
-    }
-
-    // Now that all ICDs have seen the message, call the necessary callbacks.  Ignoring "bail" return value
-    // as there is nothing to bail from at this point.
-
-    util_DebugReportMessage(inst, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-}
-
-bool debug_report_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
-    // debug_report is currently advertised to be supported by the loader,
-    // so always return the entry points if name matches and it's enabled
-    *addr = NULL;
-
-    if (!strcmp("vkCreateDebugReportCallbackEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_CreateDebugReportCallbackEXT
-                                                                               : NULL;
-        return true;
-    }
-    if (!strcmp("vkDestroyDebugReportCallbackEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_DestroyDebugReportCallbackEXT
-                                                                               : NULL;
-        return true;
-    }
-    if (!strcmp("vkDebugReportMessageEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_debug_report == 1) ? (void *)debug_report_DebugReportMessageEXT : NULL;
-        return true;
-    }
-    return false;
-}
diff --git a/third_party/vulkan/loader/debug_report.h b/third_party/vulkan/loader/debug_report.h
deleted file mode 100644
index 89074d7f7..000000000
--- a/third_party/vulkan/loader/debug_report.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- * Copyright (C) 2015-2016 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
- * Author: Jon Ashburn <jon@lunarg.com>
- *
- */
-
-#include "vk_loader_platform.h"
-#include "loader.h"
-
-// CreateMsgCallback is global and needs to be
-// applied to all layers and ICDs.
-// What happens if a layer is enabled on both the instance chain
-// as well as the device chain and a call to CreateMsgCallback is made?
-// Do we need to make sure that each layer / driver only gets called once?
-// Should a layer implementing support for CreateMsgCallback only be allowed (?)
-// to live on one chain? Or maybe make it the application's responsibility.
-// If the app enables DRAW_STATE on at both CreateInstance time and CreateDevice
-// time, CreateMsgCallback will call the DRAW_STATE layer twice. Once via
-// the instance chain and once via the device chain.
-// The loader should only return the DEBUG_REPORT extension as supported
-// for the GetGlobalExtensionSupport call. That should help eliminate one
-// duplication.
-// Since the instance chain requires us iterating over the available ICDs
-// and each ICD will have it's own unique MsgCallback object we need to
-// track those objects to give back the right one.
-// This also implies that the loader has to intercept vkDestroyObject and
-// if the extension is enabled and the object type is a MsgCallback then
-// we must translate the object into the proper ICD specific ones.
-// DestroyObject works on a device chain. Should not be what's destroying
-// the MsgCallback object. That needs to be an instance thing. So, since
-// we used an instance to create it, we need a custom Destroy that also
-// takes an instance. That way we can iterate over the ICDs properly.
-// Example use:
-// CreateInstance: DEBUG_REPORT
-//   Loader will create instance chain with enabled extensions.
-//   TODO: Should validation layers be enabled here? If not, they will not be in
-// the instance chain.
-// fn = GetProcAddr(INSTANCE, "vkCreateMsgCallback") -> point to loader's
-// vkCreateMsgCallback
-// App creates a callback object: fn(..., &MsgCallbackObject1)
-// Have only established the instance chain so far. Loader will call the
-// instance chain.
-// Each layer in the instance chain will call down to the next layer,
-// terminating with
-// the CreateMsgCallback loader terminator function that creates the actual
-// MsgCallbackObject1 object.
-// The loader CreateMsgCallback terminator will iterate over the ICDs.
-// Calling each ICD that supports vkCreateMsgCallback and collect answers in
-// icd_msg_callback_map here.
-// As result is sent back up the chain each layer has opportunity to record the
-// callback operation and
-// appropriate MsgCallback object.
-// ...
-// Any reports matching the flags set in MsgCallbackObject1 will generate the
-// defined callback behavior
-// in the layer / ICD that initiated that report.
-// ...
-// CreateDevice: MemTracker:...
-// App does not include DEBUG_REPORT as that is a global extension.
-// TODO: GetExtensionSupport must not report DEBUG_REPORT when using instance.
-// App MUST include any desired validation layers or they will not participate
-// in the device call chain.
-// App creates a callback object: fn(..., &MsgCallbackObject2)
-// Loader's vkCreateMsgCallback is called.
-// Loader sends call down instance chain - this is a global extension - any
-// validation layer that was
-// enabled at CreateInstance will be able to register the callback. Loader will
-// iterate over the ICDs and
-// will record the ICD's version of the MsgCallback2 object here.
-// ...
-// Any report will go to the layer's report function and it will check the flags
-// for MsgCallbackObject1
-// and MsgCallbackObject2 and take the appropriate action as indicated by the
-// app.
-// ...
-// App calls vkDestroyMsgCallback( MsgCallbackObject1 )
-// Loader's DestroyMsgCallback is where call starts. DestroyMsgCallback will be
-// sent down instance chain
-// ending in the loader's DestroyMsgCallback terminator which will iterate over
-// the ICD's destroying each
-// ICD version of that MsgCallback object and then destroy the loader's version
-// of the object.
-// Any reports generated after this will only have MsgCallbackObject2 available.
-
-void debug_report_add_instance_extensions(const struct loader_instance *inst, struct loader_extension_list *ext_list);
-
-void debug_report_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
-
-bool debug_report_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDebugReportCallbackEXT(VkInstance instance,
-                                                                       const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkDebugReportCallbackEXT *pCallback);
-
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
-                                                                    const VkAllocationCallbacks *pAllocator);
-
-VKAPI_ATTR void VKAPI_CALL terminator_DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
-                                                            VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
-                                                            int32_t msgCode, const char *pLayerPrefix, const char *pMsg);
-
-VkResult util_CreateDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
-                                        const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT callback);
-
-void util_DestroyDebugReportCallback(struct loader_instance *inst, VkDebugReportCallbackEXT callback,
-                                     const VkAllocationCallbacks *pAllocator);
-
-VkResult util_CopyDebugReportCreateInfos(const void *pChain, const VkAllocationCallbacks *pAllocator, uint32_t *num_callbacks,
-                                         VkDebugReportCallbackCreateInfoEXT **infos, VkDebugReportCallbackEXT **callbacks);
-void util_FreeDebugReportCreateInfos(const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackCreateInfoEXT *infos,
-                                     VkDebugReportCallbackEXT *callbacks);
-VkResult util_CreateDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator,
-                                         uint32_t num_callbacks, VkDebugReportCallbackCreateInfoEXT *infos,
-                                         VkDebugReportCallbackEXT *callbacks);
-
-void util_DestroyDebugReportCallbacks(struct loader_instance *inst, const VkAllocationCallbacks *pAllocator, uint32_t num_callbacks,
-                                      VkDebugReportCallbackEXT *callbacks);
-
-VkBool32 util_DebugReportMessage(const struct loader_instance *inst, VkFlags msgFlags, VkDebugReportObjectTypeEXT objectType,
-                                 uint64_t srcObject, size_t location, int32_t msgCode, const char *pLayerPrefix, const char *pMsg);
diff --git a/third_party/vulkan/loader/dev_ext_trampoline.c b/third_party/vulkan/loader/dev_ext_trampoline.c
deleted file mode 100644
index 55eee0c25..000000000
--- a/third_party/vulkan/loader/dev_ext_trampoline.c
+++ /dev/null
@@ -1,538 +0,0 @@
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- */
-
-#include "vk_loader_platform.h"
-#include "loader.h"
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC optimize(3)  // force gcc to use tail-calls
-#endif
-
-// Clang-format does not understand macros.
-// clang-format off
-
-VKAPI_ATTR void VKAPI_CALL vkdev_ext0(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext1(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext2(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext3(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext4(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext5(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext6(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext7(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext8(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext9(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext10(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext11(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext12(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext13(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext14(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext15(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext16(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext17(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext18(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext19(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext20(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext21(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext22(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext23(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext24(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext25(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext26(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext27(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext28(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext29(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext30(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext31(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext32(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext33(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext34(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext35(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext36(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext37(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext38(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext39(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext40(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext41(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext42(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext43(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext44(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext45(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext46(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext47(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext48(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext49(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext50(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext51(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext52(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext53(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext54(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext55(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext56(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext57(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext58(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext59(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext60(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext61(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext62(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext63(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext64(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext65(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext66(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext67(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext68(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext69(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext70(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext71(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext72(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext73(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext74(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext75(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext76(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext77(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext78(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext79(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext80(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext81(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext82(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext83(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext84(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext85(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext86(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext87(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext88(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext89(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext90(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext91(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext92(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext93(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext94(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext95(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext96(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext97(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext98(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext99(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext100(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext101(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext102(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext103(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext104(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext105(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext106(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext107(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext108(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext109(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext110(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext111(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext112(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext113(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext114(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext115(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext116(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext117(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext118(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext119(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext120(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext121(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext122(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext123(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext124(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext125(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext126(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext127(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext128(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext129(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext130(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext131(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext132(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext133(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext134(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext135(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext136(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext137(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext138(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext139(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext140(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext141(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext142(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext143(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext144(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext145(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext146(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext147(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext148(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext149(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext150(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext151(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext152(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext153(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext154(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext155(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext156(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext157(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext158(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext159(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext160(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext161(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext162(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext163(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext164(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext165(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext166(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext167(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext168(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext169(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext170(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext171(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext172(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext173(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext174(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext175(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext176(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext177(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext178(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext179(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext180(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext181(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext182(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext183(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext184(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext185(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext186(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext187(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext188(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext189(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext190(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext191(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext192(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext193(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext194(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext195(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext196(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext197(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext198(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext199(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext200(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext201(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext202(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext203(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext204(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext205(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext206(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext207(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext208(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext209(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext210(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext211(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext212(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext213(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext214(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext215(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext216(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext217(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext218(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext219(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext220(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext221(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext222(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext223(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext224(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext225(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext226(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext227(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext228(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext229(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext230(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext231(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext232(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext233(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext234(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext235(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext236(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext237(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext238(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext239(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext240(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext241(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext242(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext243(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext244(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext245(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext246(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext247(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext248(VkDevice device);
-VKAPI_ATTR void VKAPI_CALL vkdev_ext249(VkDevice device);
-
-void *loader_get_dev_ext_trampoline(uint32_t index) {
-    switch (index) {
-#define CASE_HANDLE(num) case num: return vkdev_ext##num
-        CASE_HANDLE(0);
-        CASE_HANDLE(1);
-        CASE_HANDLE(2);
-        CASE_HANDLE(3);
-        CASE_HANDLE(4);
-        CASE_HANDLE(5);
-        CASE_HANDLE(6);
-        CASE_HANDLE(7);
-        CASE_HANDLE(8);
-        CASE_HANDLE(9);
-        CASE_HANDLE(10);
-        CASE_HANDLE(11);
-        CASE_HANDLE(12);
-        CASE_HANDLE(13);
-        CASE_HANDLE(14);
-        CASE_HANDLE(15);
-        CASE_HANDLE(16);
-        CASE_HANDLE(17);
-        CASE_HANDLE(18);
-        CASE_HANDLE(19);
-        CASE_HANDLE(20);
-        CASE_HANDLE(21);
-        CASE_HANDLE(22);
-        CASE_HANDLE(23);
-        CASE_HANDLE(24);
-        CASE_HANDLE(25);
-        CASE_HANDLE(26);
-        CASE_HANDLE(27);
-        CASE_HANDLE(28);
-        CASE_HANDLE(29);
-        CASE_HANDLE(30);
-        CASE_HANDLE(31);
-        CASE_HANDLE(32);
-        CASE_HANDLE(33);
-        CASE_HANDLE(34);
-        CASE_HANDLE(35);
-        CASE_HANDLE(36);
-        CASE_HANDLE(37);
-        CASE_HANDLE(38);
-        CASE_HANDLE(39);
-        CASE_HANDLE(40);
-        CASE_HANDLE(41);
-        CASE_HANDLE(42);
-        CASE_HANDLE(43);
-        CASE_HANDLE(44);
-        CASE_HANDLE(45);
-        CASE_HANDLE(46);
-        CASE_HANDLE(47);
-        CASE_HANDLE(48);
-        CASE_HANDLE(49);
-        CASE_HANDLE(50);
-        CASE_HANDLE(51);
-        CASE_HANDLE(52);
-        CASE_HANDLE(53);
-        CASE_HANDLE(54);
-        CASE_HANDLE(55);
-        CASE_HANDLE(56);
-        CASE_HANDLE(57);
-        CASE_HANDLE(58);
-        CASE_HANDLE(59);
-        CASE_HANDLE(60);
-        CASE_HANDLE(61);
-        CASE_HANDLE(62);
-        CASE_HANDLE(63);
-        CASE_HANDLE(64);
-        CASE_HANDLE(65);
-        CASE_HANDLE(66);
-        CASE_HANDLE(67);
-        CASE_HANDLE(68);
-        CASE_HANDLE(69);
-        CASE_HANDLE(70);
-        CASE_HANDLE(71);
-        CASE_HANDLE(72);
-        CASE_HANDLE(73);
-        CASE_HANDLE(74);
-        CASE_HANDLE(75);
-        CASE_HANDLE(76);
-        CASE_HANDLE(77);
-        CASE_HANDLE(78);
-        CASE_HANDLE(79);
-        CASE_HANDLE(80);
-        CASE_HANDLE(81);
-        CASE_HANDLE(82);
-        CASE_HANDLE(83);
-        CASE_HANDLE(84);
-        CASE_HANDLE(85);
-        CASE_HANDLE(86);
-        CASE_HANDLE(87);
-        CASE_HANDLE(88);
-        CASE_HANDLE(89);
-        CASE_HANDLE(90);
-        CASE_HANDLE(91);
-        CASE_HANDLE(92);
-        CASE_HANDLE(93);
-        CASE_HANDLE(94);
-        CASE_HANDLE(95);
-        CASE_HANDLE(96);
-        CASE_HANDLE(97);
-        CASE_HANDLE(98);
-        CASE_HANDLE(99);
-        CASE_HANDLE(100);
-        CASE_HANDLE(101);
-        CASE_HANDLE(102);
-        CASE_HANDLE(103);
-        CASE_HANDLE(104);
-        CASE_HANDLE(105);
-        CASE_HANDLE(106);
-        CASE_HANDLE(107);
-        CASE_HANDLE(108);
-        CASE_HANDLE(109);
-        CASE_HANDLE(110);
-        CASE_HANDLE(111);
-        CASE_HANDLE(112);
-        CASE_HANDLE(113);
-        CASE_HANDLE(114);
-        CASE_HANDLE(115);
-        CASE_HANDLE(116);
-        CASE_HANDLE(117);
-        CASE_HANDLE(118);
-        CASE_HANDLE(119);
-        CASE_HANDLE(120);
-        CASE_HANDLE(121);
-        CASE_HANDLE(122);
-        CASE_HANDLE(123);
-        CASE_HANDLE(124);
-        CASE_HANDLE(125);
-        CASE_HANDLE(126);
-        CASE_HANDLE(127);
-        CASE_HANDLE(128);
-        CASE_HANDLE(129);
-        CASE_HANDLE(130);
-        CASE_HANDLE(131);
-        CASE_HANDLE(132);
-        CASE_HANDLE(133);
-        CASE_HANDLE(134);
-        CASE_HANDLE(135);
-        CASE_HANDLE(136);
-        CASE_HANDLE(137);
-        CASE_HANDLE(138);
-        CASE_HANDLE(139);
-        CASE_HANDLE(140);
-        CASE_HANDLE(141);
-        CASE_HANDLE(142);
-        CASE_HANDLE(143);
-        CASE_HANDLE(144);
-        CASE_HANDLE(145);
-        CASE_HANDLE(146);
-        CASE_HANDLE(147);
-        CASE_HANDLE(148);
-        CASE_HANDLE(149);
-        CASE_HANDLE(150);
-        CASE_HANDLE(151);
-        CASE_HANDLE(152);
-        CASE_HANDLE(153);
-        CASE_HANDLE(154);
-        CASE_HANDLE(155);
-        CASE_HANDLE(156);
-        CASE_HANDLE(157);
-        CASE_HANDLE(158);
-        CASE_HANDLE(159);
-        CASE_HANDLE(160);
-        CASE_HANDLE(161);
-        CASE_HANDLE(162);
-        CASE_HANDLE(163);
-        CASE_HANDLE(164);
-        CASE_HANDLE(165);
-        CASE_HANDLE(166);
-        CASE_HANDLE(167);
-        CASE_HANDLE(168);
-        CASE_HANDLE(169);
-        CASE_HANDLE(170);
-        CASE_HANDLE(171);
-        CASE_HANDLE(172);
-        CASE_HANDLE(173);
-        CASE_HANDLE(174);
-        CASE_HANDLE(175);
-        CASE_HANDLE(176);
-        CASE_HANDLE(177);
-        CASE_HANDLE(178);
-        CASE_HANDLE(179);
-        CASE_HANDLE(180);
-        CASE_HANDLE(181);
-        CASE_HANDLE(182);
-        CASE_HANDLE(183);
-        CASE_HANDLE(184);
-        CASE_HANDLE(185);
-        CASE_HANDLE(186);
-        CASE_HANDLE(187);
-        CASE_HANDLE(188);
-        CASE_HANDLE(189);
-        CASE_HANDLE(190);
-        CASE_HANDLE(191);
-        CASE_HANDLE(192);
-        CASE_HANDLE(193);
-        CASE_HANDLE(194);
-        CASE_HANDLE(195);
-        CASE_HANDLE(196);
-        CASE_HANDLE(197);
-        CASE_HANDLE(198);
-        CASE_HANDLE(199);
-        CASE_HANDLE(200);
-        CASE_HANDLE(201);
-        CASE_HANDLE(202);
-        CASE_HANDLE(203);
-        CASE_HANDLE(204);
-        CASE_HANDLE(205);
-        CASE_HANDLE(206);
-        CASE_HANDLE(207);
-        CASE_HANDLE(208);
-        CASE_HANDLE(209);
-        CASE_HANDLE(210);
-        CASE_HANDLE(211);
-        CASE_HANDLE(212);
-        CASE_HANDLE(213);
-        CASE_HANDLE(214);
-        CASE_HANDLE(215);
-        CASE_HANDLE(216);
-        CASE_HANDLE(217);
-        CASE_HANDLE(218);
-        CASE_HANDLE(219);
-        CASE_HANDLE(220);
-        CASE_HANDLE(221);
-        CASE_HANDLE(222);
-        CASE_HANDLE(223);
-        CASE_HANDLE(224);
-        CASE_HANDLE(225);
-        CASE_HANDLE(226);
-        CASE_HANDLE(227);
-        CASE_HANDLE(228);
-        CASE_HANDLE(229);
-        CASE_HANDLE(230);
-        CASE_HANDLE(231);
-        CASE_HANDLE(232);
-        CASE_HANDLE(233);
-        CASE_HANDLE(234);
-        CASE_HANDLE(235);
-        CASE_HANDLE(236);
-        CASE_HANDLE(237);
-        CASE_HANDLE(238);
-        CASE_HANDLE(239);
-        CASE_HANDLE(240);
-        CASE_HANDLE(241);
-        CASE_HANDLE(242);
-        CASE_HANDLE(243);
-        CASE_HANDLE(244);
-        CASE_HANDLE(245);
-        CASE_HANDLE(246);
-        CASE_HANDLE(247);
-        CASE_HANDLE(248);
-        CASE_HANDLE(249);
-    }
-
-    return NULL;
-}
diff --git a/third_party/vulkan/loader/dirent_on_windows.c b/third_party/vulkan/loader/dirent_on_windows.c
deleted file mode 100644
index 16318cc70..000000000
--- a/third_party/vulkan/loader/dirent_on_windows.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
-
-    Implementation of POSIX directory browsing functions and types for Win32.
-
-    Author:  Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
-    History: Created March 1997. Updated June 2003 and July 2012.
-    Rights:  See end of file.
-
-*/
-#include "dirent_on_windows.h"
-#include <errno.h>
-#include <io.h> /* _findfirst and _findnext set errno iff they return -1 */
-#include <stdlib.h>
-#include <string.h>
-#include "vk_loader_platform.h"
-#include "loader.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef ptrdiff_t handle_type; /* C99's intptr_t not sufficiently portable */
-
-struct DIR {
-    handle_type handle; /* -1 for failed rewind */
-    struct _finddata_t info;
-    struct dirent result; /* d_name null iff first time */
-    char *name;           /* null-terminated char string */
-};
-
-DIR *opendir(const char *name) {
-    DIR *dir = 0;
-
-    if (name && name[0]) {
-        size_t base_length = strlen(name);
-        const char *all = /* search pattern must end with suitable wildcard */
-            strchr("/\\", name[base_length - 1]) ? "*" : "/*";
-
-        if ((dir = (DIR *)loader_instance_tls_heap_alloc(sizeof *dir)) != 0 &&
-            (dir->name = (char *)loader_instance_tls_heap_alloc(base_length + strlen(all) + 1)) != 0) {
-            strcat(strcpy(dir->name, name), all);
-
-            if ((dir->handle = (handle_type)_findfirst(dir->name, &dir->info)) != -1) {
-                dir->result.d_name = 0;
-            } else /* rollback */
-            {
-                loader_instance_tls_heap_free(dir->name);
-                loader_instance_tls_heap_free(dir);
-                dir = 0;
-            }
-        } else /* rollback */
-        {
-            loader_instance_tls_heap_free(dir);
-            dir = 0;
-            errno = ENOMEM;
-        }
-    } else {
-        errno = EINVAL;
-    }
-
-    return dir;
-}
-
-int closedir(DIR *dir) {
-    int result = -1;
-
-    if (dir) {
-        if (dir->handle != -1) {
-            result = _findclose(dir->handle);
-        }
-
-        loader_instance_tls_heap_free(dir->name);
-        loader_instance_tls_heap_free(dir);
-    }
-
-    if (result == -1) /* map all errors to EBADF */
-    {
-        errno = EBADF;
-    }
-
-    return result;
-}
-
-struct dirent *readdir(DIR *dir) {
-    struct dirent *result = 0;
-
-    if (dir && dir->handle != -1) {
-        if (!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) {
-            result = &dir->result;
-            result->d_name = dir->info.name;
-        }
-    } else {
-        errno = EBADF;
-    }
-
-    return result;
-}
-
-void rewinddir(DIR *dir) {
-    if (dir && dir->handle != -1) {
-        _findclose(dir->handle);
-        dir->handle = (handle_type)_findfirst(dir->name, &dir->info);
-        dir->result.d_name = 0;
-    } else {
-        errno = EBADF;
-    }
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-/*
-
-    Copyright Kevlin Henney, 1997, 2003, 2012. All rights reserved.
-    Copyright (c) 2015 The Khronos Group Inc.
-    Copyright (c) 2015 Valve Corporation
-    Copyright (c) 2015 LunarG, Inc.
-    Permission to use, copy, modify, and distribute this software and its
-    documentation for any purpose is hereby granted without fee, provided
-    that this copyright and permissions notice appear in all copies and
-    derivatives.
-
-    This software is supplied "as is" without express or implied warranty.
-
-    But that said, if there are any problems please get in touch.
-
-*/
diff --git a/third_party/vulkan/loader/dirent_on_windows.h b/third_party/vulkan/loader/dirent_on_windows.h
deleted file mode 100644
index 8600f8ef0..000000000
--- a/third_party/vulkan/loader/dirent_on_windows.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef DIRENT_INCLUDED
-#define DIRENT_INCLUDED
-
-/*
-
-    Declaration of POSIX directory browsing functions and types for Win32.
-
-    Author:  Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com)
-    History: Created March 1997. Updated June 2003.
-    Rights:  See end of file.
-
-*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct DIR DIR;
-
-struct dirent {
-    char *d_name;
-};
-
-DIR *opendir(const char *);
-int closedir(DIR *);
-struct dirent *readdir(DIR *);
-void rewinddir(DIR *);
-
-/*
-
-    Copyright Kevlin Henney, 1997, 2003. All rights reserved.
-    Copyright (c) 2015 The Khronos Group Inc.
-    Copyright (c) 2015 Valve Corporation
-    Copyright (c) 2015 LunarG, Inc.
-
-    Permission to use, copy, modify, and distribute this software and its
-    documentation for any purpose is hereby granted without fee, provided
-    that this copyright and permissions notice appear in all copies and
-    derivatives.
-
-    This software is supplied "as is" without express or implied warranty.
-
-    But that said, if there are any problems please get in touch.
-
-*/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/third_party/vulkan/loader/extension_manual.c b/third_party/vulkan/loader/extension_manual.c
deleted file mode 100644
index ef62b52b1..000000000
--- a/third_party/vulkan/loader/extension_manual.c
+++ /dev/null
@@ -1,1345 +0,0 @@
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Young <marky@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "vk_loader_platform.h"
-#include "loader.h"
-#include "vk_loader_extensions.h"
-#include <vulkan/vk_icd.h>
-#include "wsi.h"
-#include "debug_report.h"
-
-// ---- Manually added trampoline/terminator functions
-
-// These functions, for whatever reason, require more complex changes than
-// can easily be automatically generated.
-VkResult setupLoaderTrampPhysDevGroups(VkInstance instance);
-VkResult setupLoaderTermPhysDevGroups(struct loader_instance *inst);
-
-// ---- VK_KHX_device_group extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX(
-    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) {
-    VkResult res = VK_SUCCESS;
-    uint32_t count;
-    uint32_t i;
-    struct loader_instance *inst = NULL;
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    inst = loader_get_instance(instance);
-    if (NULL == inst) {
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    if (NULL == pPhysicalDeviceGroupCount) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkEnumeratePhysicalDeviceGroupsKHX: Received NULL pointer for physical "
-                   "device group count return value.");
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    VkResult setup_res = setupLoaderTrampPhysDevGroups(instance);
-    if (VK_SUCCESS != setup_res) {
-        res = setup_res;
-        goto out;
-    }
-
-    count = inst->phys_dev_group_count_tramp;
-
-    // Wrap the PhysDev object for loader usage, return wrapped objects
-    if (NULL != pPhysicalDeviceGroupProperties) {
-        if (inst->phys_dev_group_count_tramp > *pPhysicalDeviceGroupCount) {
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                       "vkEnumeratePhysicalDeviceGroupsKHX: Trimming device group count down"
-                       " by application request from %d to %d physical device groups",
-                       inst->phys_dev_group_count_tramp, *pPhysicalDeviceGroupCount);
-            count = *pPhysicalDeviceGroupCount;
-            res = VK_INCOMPLETE;
-        }
-        for (i = 0; i < count; i++) {
-            memcpy(&pPhysicalDeviceGroupProperties[i], inst->phys_dev_groups_tramp[i],
-                   sizeof(VkPhysicalDeviceGroupPropertiesKHX));
-        }
-    }
-
-    *pPhysicalDeviceGroupCount = count;
-
-out:
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDeviceGroupsKHX(
-    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties) {
-    struct loader_instance *inst = (struct loader_instance *)instance;
-    VkResult res = VK_SUCCESS;
-
-    // Always call the setup loader terminator physical device groups because they may
-    // have changed at any point.
-    res = setupLoaderTermPhysDevGroups(inst);
-    if (VK_SUCCESS != res) {
-        goto out;
-    }
-
-    uint32_t copy_count = inst->phys_dev_group_count_term;
-    if (NULL != pPhysicalDeviceGroupProperties) {
-        if (copy_count > *pPhysicalDeviceGroupCount) {
-            copy_count = *pPhysicalDeviceGroupCount;
-            res = VK_INCOMPLETE;
-        }
-
-        for (uint32_t i = 0; i < copy_count; i++) {
-            memcpy(&pPhysicalDeviceGroupProperties[i], inst->phys_dev_groups_term[i],
-                   sizeof(VkPhysicalDeviceGroupPropertiesKHX));
-        }
-    }
-
-    *pPhysicalDeviceGroupCount = copy_count;
-
-out:
-
-    return res;
-}
-
-// ---- VK_NV_external_memory_capabilities extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL
-GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
-    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-
-    return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(
-        unwrapped_phys_dev, format, type, tiling, usage, flags,
-        externalHandleType, pExternalImageFormatProperties);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
-    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term =
-        (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (!icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV) {
-        if (externalHandleType) {
-            return VK_ERROR_FORMAT_NOT_SUPPORTED;
-        }
-
-        if (!icd_term->dispatch.GetPhysicalDeviceImageFormatProperties) {
-            return VK_ERROR_INITIALIZATION_FAILED;
-        }
-
-        pExternalImageFormatProperties->externalMemoryFeatures = 0;
-        pExternalImageFormatProperties->exportFromImportedHandleTypes = 0;
-        pExternalImageFormatProperties->compatibleHandleTypes = 0;
-
-        return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties(
-            phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-            &pExternalImageFormatProperties->imageFormatProperties);
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceExternalImageFormatPropertiesNV(
-        phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-        externalHandleType, pExternalImageFormatProperties);
-}
-
-// ---- VK_KHR_get_physical_device_properties2 extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
-                                                                    VkPhysicalDeviceFeatures2KHR *pFeatures) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceFeatures2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceFeatures2KHR(phys_dev_term->phys_dev, pFeatures);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceFeatures2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFeatures",
-                   icd_term->scanned_icd->lib_name);
-
-        // Write to the VkPhysicalDeviceFeatures2KHR struct
-        icd_term->dispatch.GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, &pFeatures->features);
-
-        void *pNext = pFeatures->pNext;
-        while (pNext != NULL) {
-            switch (*(VkStructureType *)pNext) {
-                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX: {
-                    // Skip the check if VK_KHX_multiview is enabled because it's a device extension
-                    // Write to the VkPhysicalDeviceMultiviewFeaturesKHX struct
-                    VkPhysicalDeviceMultiviewFeaturesKHX *multiview_features = pNext;
-                    multiview_features->multiview = VK_FALSE;
-                    multiview_features->multiviewGeometryShader = VK_FALSE;
-                    multiview_features->multiviewTessellationShader = VK_FALSE;
-
-                    pNext = multiview_features->pNext;
-                    break;
-                }
-                default: {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "vkGetPhysicalDeviceFeatures2KHR: Emulation found unrecognized structure type in pFeatures->pNext - "
-                               "this struct will be ignored");
-
-                    struct VkStructureHeader *header = pNext;
-                    pNext = (void *)header->pNext;
-                    break;
-                }
-            }
-        }
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                           VkPhysicalDeviceProperties2KHR *pProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                      VkPhysicalDeviceProperties2KHR *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceProperties2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev, pProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceProperties",
-                   icd_term->scanned_icd->lib_name);
-
-        // Write to the VkPhysicalDeviceProperties2KHR struct
-        icd_term->dispatch.GetPhysicalDeviceProperties(phys_dev_term->phys_dev, &pProperties->properties);
-
-        void *pNext = pProperties->pNext;
-        while (pNext != NULL) {
-            switch (*(VkStructureType *)pNext) {
-                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: {
-                    VkPhysicalDeviceIDPropertiesKHR *id_properties = pNext;
-
-                    // Verify that "VK_KHR_external_memory_capabilities" is enabled
-                    if (icd_term->this_instance->enabled_known_extensions.khr_external_memory_capabilities) {
-                        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                                   "vkGetPhysicalDeviceProperties2KHR: Emulation cannot generate unique IDs for struct "
-                                   "VkPhysicalDeviceIDPropertiesKHR - setting IDs to zero instead");
-
-                        // Write to the VkPhysicalDeviceIDPropertiesKHR struct
-                        memset(id_properties->deviceUUID, 0, VK_UUID_SIZE);
-                        memset(id_properties->driverUUID, 0, VK_UUID_SIZE);
-                        id_properties->deviceLUIDValid = VK_FALSE;
-                    }
-
-                    pNext = id_properties->pNext;
-                    break;
-                }
-                default: {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "vkGetPhysicalDeviceProperties2KHR: Emulation found unrecognized structure type in "
-                               "pProperties->pNext - this struct will be ignored");
-
-                    struct VkStructureHeader *header = pNext;
-                    pNext = (void *)header->pNext;
-                    break;
-                }
-            }
-        }
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                 VkFormatProperties2KHR *pFormatProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                            VkFormatProperties2KHR *pFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev, format, pFormatProperties);
-    } else {
-        // Emulate the call
-        loader_log(
-            icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-            "vkGetPhysicalDeviceFormatProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceFormatProperties",
-            icd_term->scanned_icd->lib_name);
-
-        // Write to the VkFormatProperties2KHR struct
-        icd_term->dispatch.GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, &pFormatProperties->formatProperties);
-
-        if (pFormatProperties->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceFormatProperties2KHR: Emulation found unrecognized structure type in "
-                       "pFormatProperties->pNext - this struct will be ignored");
-        }
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
-    VkImageFormatProperties2KHR *pImageFormatProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
-    VkImageFormatProperties2KHR *pImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR != NULL) {
-        // Pass the call to the driver
-        return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_term->phys_dev, pImageFormatInfo,
-                                                                             pImageFormatProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceImageFormatProperties2KHR: Emulating call in ICD \"%s\" using "
-                   "vkGetPhysicalDeviceImageFormatProperties",
-                   icd_term->scanned_icd->lib_name);
-
-        // If there is more info in  either pNext, then this is unsupported
-        if (pImageFormatInfo->pNext != NULL || pImageFormatProperties->pNext != NULL) {
-            return VK_ERROR_FORMAT_NOT_SUPPORTED;
-        }
-
-        // Write to the VkImageFormatProperties2KHR struct
-        return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties(
-            phys_dev_term->phys_dev, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling,
-            pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                      uint32_t *pQueueFamilyPropertyCount,
-                                                                      VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties2KHR(phys_dev_term->phys_dev, pQueueFamilyPropertyCount,
-                                                                      pQueueFamilyProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Emulating call in ICD \"%s\" using "
-                   "vkGetPhysicalDeviceQueueFamilyProperties",
-                   icd_term->scanned_icd->lib_name);
-
-        if (pQueueFamilyProperties == NULL || *pQueueFamilyPropertyCount == 0) {
-            // Write to pQueueFamilyPropertyCount
-            icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, NULL);
-        } else {
-            // Allocate a temporary array for the output of the old function
-            VkQueueFamilyProperties *properties = loader_stack_alloc(*pQueueFamilyPropertyCount * sizeof(VkQueueFamilyProperties));
-            if (properties == NULL) {
-                *pQueueFamilyPropertyCount = 0;
-                loader_log(
-                    icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                    "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Out of memory - Failed to allocate array for loader emulation.");
-                return;
-            }
-
-            icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount,
-                                                                      properties);
-            for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; ++i) {
-                // Write to the VkQueueFamilyProperties2KHR struct
-                memcpy(&pQueueFamilyProperties[i].queueFamilyProperties, &properties[i], sizeof(VkQueueFamilyProperties));
-
-                if (pQueueFamilyProperties[i].pNext != NULL) {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "vkGetPhysicalDeviceQueueFamilyProperties2KHR: Emulation found unrecognized structure type in "
-                               "pQueueFamilyProperties[%d].pNext - this struct will be ignored",
-                               i);
-                }
-            }
-        }
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                 VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev, pMemoryProperties);
-    } else {
-        // Emulate the call
-        loader_log(
-            icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-            "vkGetPhysicalDeviceMemoryProperties2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceMemoryProperties",
-            icd_term->scanned_icd->lib_name);
-
-        // Write to the VkPhysicalDeviceMemoryProperties2KHR struct
-        icd_term->dispatch.GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, &pMemoryProperties->memoryProperties);
-
-        if (pMemoryProperties->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceMemoryProperties2KHR: Emulation found unrecognized structure type in "
-                       "pMemoryProperties->pNext - this struct will be ignored");
-        }
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
-    VkSparseImageFormatProperties2KHR *pProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
-    VkSparseImageFormatProperties2KHR *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties2KHR(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount,
-                                                                            pProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulating call in ICD \"%s\" using "
-                   "vkGetPhysicalDeviceSparseImageFormatProperties",
-                   icd_term->scanned_icd->lib_name);
-
-        if (pFormatInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulation found unrecognized structure type in "
-                       "pFormatInfo->pNext - this struct will be ignored");
-        }
-
-        if (pProperties == NULL || *pPropertyCount == 0) {
-            // Write to pPropertyCount
-            icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties(
-                phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage,
-                pFormatInfo->tiling, pPropertyCount, NULL);
-        } else {
-            // Allocate a temporary array for the output of the old function
-            VkSparseImageFormatProperties *properties =
-                loader_stack_alloc(*pPropertyCount * sizeof(VkSparseImageMemoryRequirements));
-            if (properties == NULL) {
-                *pPropertyCount = 0;
-                loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Out of memory - Failed to allocate array for "
-                           "loader emulation.");
-                return;
-            }
-
-            icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties(
-                phys_dev_term->phys_dev, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage,
-                pFormatInfo->tiling, pPropertyCount, properties);
-            for (uint32_t i = 0; i < *pPropertyCount; ++i) {
-                // Write to the VkSparseImageFormatProperties2KHR struct
-                memcpy(&pProperties[i].properties, &properties[i], sizeof(VkSparseImageFormatProperties));
-
-                if (pProperties[i].pNext != NULL) {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "vkGetPhysicalDeviceSparseImageFormatProperties2KHR: Emulation found unrecognized structure type in "
-                               "pProperties[%d].pNext - this struct will be ignored",
-                               i);
-                }
-            }
-        }
-    }
-}
-
-// ---- VK_KHR_get_surface_capabilities2 extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                                                        const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-                                                                        VkSurfaceCapabilities2KHR *pSurfaceCapabilities) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceSurfaceCapabilities2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceCapabilities);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-    VkSurfaceCapabilities2KHR *pSurfaceCapabilities) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface);
-    uint8_t icd_index = phys_dev_term->icd_index;
-
-    if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR != NULL) {
-        // Pass the call to the driver, possibly unwrapping the ICD surface
-        if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) {
-            VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo;
-            info_copy.surface = icd_surface->real_icd_surfaces[icd_index];
-            return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, &info_copy,
-                                                                               pSurfaceCapabilities);
-        } else {
-            return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2KHR(phys_dev_term->phys_dev, pSurfaceInfo,
-                                                                               pSurfaceCapabilities);
-        }
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulating call in ICD \"%s\" using "
-                   "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
-                   icd_term->scanned_icd->lib_name);
-
-        if (pSurfaceInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in "
-                       "pSurfaceInfo->pNext - this struct will be ignored");
-        }
-
-        // Write to the VkSurfaceCapabilities2KHR struct
-        VkSurfaceKHR surface = pSurfaceInfo->surface;
-        if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) {
-            surface = icd_surface->real_icd_surfaces[icd_index];
-        }
-        VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface,
-                                                                                  &pSurfaceCapabilities->surfaceCapabilities);
-
-        if (pSurfaceCapabilities->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceSurfaceCapabilities2KHR: Emulation found unrecognized structure type in "
-                       "pSurfaceCapabilities->pNext - this struct will be ignored");
-        }
-        return res;
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                                   const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-                                                                   uint32_t *pSurfaceFormatCount,
-                                                                   VkSurfaceFormat2KHR *pSurfaceFormats) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceSurfaceFormats2KHR(unwrapped_phys_dev, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                                              const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-                                                                              uint32_t *pSurfaceFormatCount,
-                                                                              VkSurfaceFormat2KHR *pSurfaceFormats) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(pSurfaceInfo->surface);
-    uint8_t icd_index = phys_dev_term->icd_index;
-
-    if (icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR != NULL) {
-        // Pass the call to the driver, possibly unwrapping the ICD surface
-        if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) {
-            VkPhysicalDeviceSurfaceInfo2KHR info_copy = *pSurfaceInfo;
-            info_copy.surface = icd_surface->real_icd_surfaces[icd_index];
-            return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, &info_copy, pSurfaceFormatCount,
-                                                                          pSurfaceFormats);
-        } else {
-            return icd_term->dispatch.GetPhysicalDeviceSurfaceFormats2KHR(phys_dev_term->phys_dev, pSurfaceInfo,
-                                                                          pSurfaceFormatCount, pSurfaceFormats);
-        }
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulating call in ICD \"%s\" using vkGetPhysicalDeviceSurfaceFormatsKHR",
-                   icd_term->scanned_icd->lib_name);
-
-        if (pSurfaceInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in pSurfaceInfo->pNext "
-                       "- this struct will be ignored");
-        }
-
-        VkSurfaceKHR surface = pSurfaceInfo->surface;
-        if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) {
-            surface = icd_surface->real_icd_surfaces[icd_index];
-        }
-
-        if (*pSurfaceFormatCount == 0 || pSurfaceFormats == NULL) {
-            // Write to pSurfaceFormatCount
-            return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount,
-                                                                         NULL);
-        } else {
-            // Allocate a temporary array for the output of the old function
-            VkSurfaceFormatKHR *formats = loader_stack_alloc(*pSurfaceFormatCount * sizeof(VkSurfaceFormatKHR));
-            if (formats == NULL) {
-                return VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-
-            VkResult res = icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface,
-                                                                                 pSurfaceFormatCount, formats);
-            for (uint32_t i = 0; i < *pSurfaceFormatCount; ++i) {
-                pSurfaceFormats[i].surfaceFormat = formats[i];
-                if (pSurfaceFormats[i].pNext != NULL) {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "vkGetPhysicalDeviceSurfaceFormats2KHR: Emulation found unrecognized structure type in "
-                               "pSurfaceFormats[%d].pNext - this struct will be ignored",
-                               i);
-                }
-            }
-            return res;
-        }
-    }
-}
-
-// ---- VK_EXT_display_surface_counter extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                        VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
-    uint8_t icd_index = phys_dev_term->icd_index;
-
-    // Unwrap the surface if needed
-    VkSurfaceKHR unwrapped_surface = surface;
-    if (icd_surface->real_icd_surfaces != NULL && (void *)icd_surface->real_icd_surfaces[icd_index] != NULL) {
-        unwrapped_surface = icd_surface->real_icd_surfaces[icd_index];
-    }
-
-    if (icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT != NULL) {
-        // Pass the call to the driver
-        return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, unwrapped_surface,
-                                                                           pSurfaceCapabilities);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulating call in ICD \"%s\" using "
-                   "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
-                   icd_term->scanned_icd->lib_name);
-
-        VkSurfaceCapabilitiesKHR surface_caps;
-        VkResult res =
-            icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, unwrapped_surface, &surface_caps);
-        pSurfaceCapabilities->minImageCount = surface_caps.minImageCount;
-        pSurfaceCapabilities->maxImageCount = surface_caps.maxImageCount;
-        pSurfaceCapabilities->currentExtent = surface_caps.currentExtent;
-        pSurfaceCapabilities->minImageExtent = surface_caps.minImageExtent;
-        pSurfaceCapabilities->maxImageExtent = surface_caps.maxImageExtent;
-        pSurfaceCapabilities->maxImageArrayLayers = surface_caps.maxImageArrayLayers;
-        pSurfaceCapabilities->supportedTransforms = surface_caps.supportedTransforms;
-        pSurfaceCapabilities->currentTransform = surface_caps.currentTransform;
-        pSurfaceCapabilities->supportedCompositeAlpha = surface_caps.supportedCompositeAlpha;
-        pSurfaceCapabilities->supportedUsageFlags = surface_caps.supportedUsageFlags;
-        pSurfaceCapabilities->supportedSurfaceCounters = 0;
-
-        if (pSurfaceCapabilities->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceSurfaceCapabilities2EXT: Emulation found unrecognized structure type in "
-                       "pSurfaceCapabilities->pNext - this struct will be ignored");
-        }
-
-        return res;
-    }
-}
-
-// ---- VK_EXT_direct_mode_display extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.ReleaseDisplayEXT == NULL) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD \"%s\" associated with VkPhysicalDevice does not support vkReleaseDisplayEXT - Consequently, the call is "
-                   "invalid because it should not be possible to acquire a display on this device",
-                   icd_term->scanned_icd->lib_name);
-    }
-    return icd_term->dispatch.ReleaseDisplayEXT(phys_dev_term->phys_dev, display);
-}
-
-// ---- VK_EXT_acquire_xlib_display extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy,
-                                                                VkDisplayKHR display) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.AcquireXlibDisplayEXT != NULL) {
-        // Pass the call to the driver
-        return icd_term->dispatch.AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkAcquireXLibDisplayEXT: Emulating call in ICD \"%s\" by returning error", icd_term->scanned_icd->lib_name);
-
-        // Fail for the unsupported command
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
-                                                        VkDisplayKHR *pDisplay) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
-                                                                   VkDisplayKHR *pDisplay) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetRandROutputDisplayEXT != NULL) {
-        // Pass the call to the driver
-        return icd_term->dispatch.GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetRandROutputDisplayEXT: Emulating call in ICD \"%s\" by returning null display",
-                   icd_term->scanned_icd->lib_name);
-
-        // Return a null handle to indicate this can't be done
-        *pDisplay = VK_NULL_HANDLE;
-        return VK_SUCCESS;
-    }
-}
-
-#endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-// ---- VK_KHR_external_memory_capabilities extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo,
-    VkExternalBufferPropertiesKHR *pExternalBufferProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceExternalBufferPropertiesKHR(unwrapped_phys_dev, pExternalBufferInfo, pExternalBufferProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR *pExternalBufferInfo,
-    VkExternalBufferPropertiesKHR *pExternalBufferProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceExternalBufferPropertiesKHR(phys_dev_term->phys_dev, pExternalBufferInfo,
-                                                                        pExternalBufferProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name);
-
-        if (pExternalBufferInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalBufferInfo->pNext - this struct will be ignored");
-        }
-
-        // Fill in everything being unsupported
-        memset(&pExternalBufferProperties->externalMemoryProperties, 0, sizeof(VkExternalMemoryPropertiesKHR));
-
-        if (pExternalBufferProperties->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalBufferPropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalBufferProperties->pNext - this struct will be ignored");
-        }
-    }
-}
-
-// ---- VK_KHR_external_semaphore_capabilities extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo,
-    VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceExternalSemaphorePropertiesKHR(unwrapped_phys_dev, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR *pExternalSemaphoreInfo,
-    VkExternalSemaphorePropertiesKHR *pExternalSemaphoreProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceExternalSemaphorePropertiesKHR(phys_dev_term->phys_dev, pExternalSemaphoreInfo,
-                                                                           pExternalSemaphoreProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulating call in ICD \"%s\"",
-                   icd_term->scanned_icd->lib_name);
-
-        if (pExternalSemaphoreInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalSemaphoreInfo->pNext - this struct will be ignored");
-        }
-
-        // Fill in everything being unsupported
-        pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
-        pExternalSemaphoreProperties->compatibleHandleTypes = 0;
-        pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
-
-        if (pExternalSemaphoreProperties->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalSemaphoreProperties->pNext - this struct will be ignored");
-        }
-    }
-}
-
-// ---- VK_KHR_external_fence_capabilities extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo,
-    VkExternalFencePropertiesKHR *pExternalFenceProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceExternalFencePropertiesKHR(unwrapped_phys_dev, pExternalFenceInfo, pExternalFenceProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR *pExternalFenceInfo,
-    VkExternalFencePropertiesKHR *pExternalFenceProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    if (icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR != NULL) {
-        // Pass the call to the driver
-        icd_term->dispatch.GetPhysicalDeviceExternalFencePropertiesKHR(phys_dev_term->phys_dev, pExternalFenceInfo,
-                                                                       pExternalFenceProperties);
-    } else {
-        // Emulate the call
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                   "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulating call in ICD \"%s\"", icd_term->scanned_icd->lib_name);
-
-        if (pExternalFenceInfo->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalFenceInfo->pNext - this struct will be ignored");
-        }
-
-        // Fill in everything being unsupported
-        pExternalFenceProperties->exportFromImportedHandleTypes = 0;
-        pExternalFenceProperties->compatibleHandleTypes = 0;
-        pExternalFenceProperties->externalFenceFeatures = 0;
-
-        if (pExternalFenceProperties->pNext != NULL) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "vkGetPhysicalDeviceExternalFencePropertiesKHR: Emulation found unrecognized structure type in "
-                       "pExternalFenceProperties->pNext - this struct will be ignored");
-        }
-    }
-}
-
-// ---- Helper functions
-
-VkResult setupLoaderTrampPhysDevGroups(VkInstance instance) {
-    VkResult res = VK_SUCCESS;
-    struct loader_instance *inst;
-    uint32_t total_count = 0;
-    VkPhysicalDeviceGroupPropertiesKHX **new_phys_dev_groups = NULL;
-    VkPhysicalDeviceGroupPropertiesKHX *local_phys_dev_groups = NULL;
-
-    inst = loader_get_instance(instance);
-    if (NULL == inst) {
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    // Setup the trampoline loader physical devices.  This will actually
-    // call down and setup the terminator loader physical devices during the
-    // process.
-    VkResult setup_res = setupLoaderTrampPhysDevs(instance);
-    if (setup_res != VK_SUCCESS && setup_res != VK_INCOMPLETE) {
-        res = setup_res;
-        goto out;
-    }
-
-    // Query how many physical device groups there
-    res = inst->disp->layer_inst_disp.EnumeratePhysicalDeviceGroupsKHX(instance, &total_count, NULL);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevGroups:  Failed during dispatch call of "
-                   "\'EnumeratePhysicalDeviceGroupsKHX\' to lower layers or "
-                   "loader to get count.");
-        goto out;
-    }
-
-    // Create an array for the new physical device groups, which will be stored
-    // in the instance for the trampoline code.
-    new_phys_dev_groups = (VkPhysicalDeviceGroupPropertiesKHX **)loader_instance_heap_alloc(
-        inst, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHX *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == new_phys_dev_groups) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevGroups:  Failed to allocate new physical device"
-                   " group array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(new_phys_dev_groups, 0, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHX *));
-
-    // Create a temporary array (on the stack) to keep track of the
-    // returned VkPhysicalDevice values.
-    local_phys_dev_groups = loader_stack_alloc(sizeof(VkPhysicalDeviceGroupPropertiesKHX) * total_count);
-    if (NULL == local_phys_dev_groups) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevGroups:  Failed to allocate local "
-                   "physical device group array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    // Initialize the memory to something valid
-    memset(local_phys_dev_groups, 0, sizeof(VkPhysicalDeviceGroupPropertiesKHX) * total_count);
-    for (uint32_t group = 0; group < total_count; group++) {
-        local_phys_dev_groups[group].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX;
-        local_phys_dev_groups[group].pNext = NULL;
-        local_phys_dev_groups[group].subsetAllocation = false;
-    }
-
-    // Call down and get the content
-    res = inst->disp->layer_inst_disp.EnumeratePhysicalDeviceGroupsKHX(instance, &total_count, local_phys_dev_groups);
-    if (VK_SUCCESS != res) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevGroups:  Failed during dispatch call of "
-                   "\'EnumeratePhysicalDeviceGroupsKHX\' to lower layers or "
-                   "loader to get content.");
-        goto out;
-    }
-
-    // Replace all the physical device IDs with the proper loader values
-    for (uint32_t group = 0; group < total_count; group++) {
-        for (uint32_t group_gpu = 0; group_gpu < local_phys_dev_groups[group].physicalDeviceCount; group_gpu++) {
-            bool found = false;
-            for (uint32_t tramp_gpu = 0; tramp_gpu < inst->phys_dev_count_tramp; tramp_gpu++) {
-                if (local_phys_dev_groups[group].physicalDevices[group_gpu] == inst->phys_devs_tramp[tramp_gpu]->phys_dev) {
-                    local_phys_dev_groups[group].physicalDevices[group_gpu] = (VkPhysicalDevice)inst->phys_devs_tramp[tramp_gpu];
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTrampPhysDevGroups:  Failed to find GPU %d in group %d"
-                           " returned by \'EnumeratePhysicalDeviceGroupsKHX\' in list returned"
-                           " by \'EnumeratePhysicalDevices\'", group_gpu, group);
-                res = VK_ERROR_INITIALIZATION_FAILED;
-                goto out;
-            }
-        }
-    }
-
-    // Copy or create everything to fill the new array of physical device groups
-    for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) {
-        // Check if this physical device group with the same contents is already in the old buffer
-        for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_tramp; old_idx++) {
-            if (local_phys_dev_groups[new_idx].physicalDeviceCount == inst->phys_dev_groups_tramp[old_idx]->physicalDeviceCount) {
-                bool found_all_gpus = true;
-                for (uint32_t old_gpu = 0; old_gpu < inst->phys_dev_groups_tramp[old_idx]->physicalDeviceCount; old_gpu++) {
-                    bool found_gpu = false;
-                    for (uint32_t new_gpu = 0; new_gpu < local_phys_dev_groups[new_idx].physicalDeviceCount; new_gpu++) {
-                        if (local_phys_dev_groups[new_idx].physicalDevices[new_gpu] == inst->phys_dev_groups_tramp[old_idx]->physicalDevices[old_gpu]) {
-                            found_gpu = true;
-                            break;
-                        }
-                    }
-
-                    if (!found_gpu) {
-                        found_all_gpus = false;
-                        break;
-                    }
-                }
-                if (!found_all_gpus) {
-                    continue;
-                } else {
-                    new_phys_dev_groups[new_idx] = inst->phys_dev_groups_tramp[old_idx];
-                    break;
-                }
-            }
-        }
-
-        // If this physical device group isn't in the old buffer, create it
-        if (NULL == new_phys_dev_groups[new_idx]) {
-            new_phys_dev_groups[new_idx] = (VkPhysicalDeviceGroupPropertiesKHX *)loader_instance_heap_alloc(
-                inst, sizeof(VkPhysicalDeviceGroupPropertiesKHX), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (NULL == new_phys_dev_groups[new_idx]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTrampPhysDevGroups:  Failed to allocate "
-                           "physical device group trampoline object %d",
-                           new_idx);
-                total_count = new_idx;
-                res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                goto out;
-            }
-            memcpy(new_phys_dev_groups[new_idx], &local_phys_dev_groups[new_idx],
-                   sizeof(VkPhysicalDeviceGroupPropertiesKHX));
-        }
-    }
-
-out:
-
-    if (VK_SUCCESS != res) {
-        if (NULL != new_phys_dev_groups) {
-            for (uint32_t i = 0; i < total_count; i++) {
-                loader_instance_heap_free(inst, new_phys_dev_groups[i]);
-            }
-            loader_instance_heap_free(inst, new_phys_dev_groups);
-        }
-        total_count = 0;
-    } else {
-        // Free everything that didn't carry over to the new array of
-        // physical device groups
-        if (NULL != inst->phys_dev_groups_tramp) {
-            for (uint32_t i = 0; i < inst->phys_dev_group_count_tramp; i++) {
-                bool found = false;
-                for (uint32_t j = 0; j < total_count; j++) {
-                    if (inst->phys_dev_groups_tramp[i] == new_phys_dev_groups[j]) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    loader_instance_heap_free(inst, inst->phys_dev_groups_tramp[i]);
-                }
-            }
-            loader_instance_heap_free(inst, inst->phys_dev_groups_tramp);
-        }
-
-        // Swap in the new physical device group list
-        inst->phys_dev_group_count_tramp = total_count;
-        inst->phys_dev_groups_tramp = new_phys_dev_groups;
-    }
-
-    return res;
-}
-
-VkResult setupLoaderTermPhysDevGroups(struct loader_instance *inst) {
-    VkResult res = VK_SUCCESS;
-    struct loader_icd_term *icd_term;
-    uint32_t total_count = 0;
-    uint32_t cur_icd_group_count = 0;
-    VkPhysicalDeviceGroupPropertiesKHX **new_phys_dev_groups = NULL;
-    VkPhysicalDeviceGroupPropertiesKHX *local_phys_dev_groups = NULL;
-
-    if (0 == inst->phys_dev_count_term) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevGroups:  Loader failed to setup physical "
-                   "device terminator info before calling \'EnumeratePhysicalDeviceGroupsKHX\'.");
-        assert(false);
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    // For each ICD, query the number of physical device groups, and then get an
-    // internal value for those physical devices.
-    icd_term = inst->icd_terms;
-    for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) {
-        cur_icd_group_count = 0;
-        if (NULL == icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX) {
-            // Treat each ICD's GPU as it's own group if the extension isn't supported
-            res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &cur_icd_group_count, NULL);
-            if (res != VK_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed during dispatch call of "
-                           "\'EnumeratePhysicalDevices\' to ICD %d to get plain phys dev count.",
-                           icd_idx);
-                goto out;
-            }
-        } else {
-            // Query the actual group info
-            res = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX(icd_term->instance, &cur_icd_group_count, NULL);
-            if (res != VK_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed during dispatch call of "
-                           "\'EnumeratePhysicalDeviceGroupsKHX\' to ICD %d to get count.",
-                           icd_idx);
-                goto out;
-            }
-        }
-        total_count += cur_icd_group_count;
-    }
-
-    // Create an array for the new physical device groups, which will be stored
-    // in the instance for the Terminator code.
-    new_phys_dev_groups = (VkPhysicalDeviceGroupPropertiesKHX **)loader_instance_heap_alloc(
-        inst, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHX *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == new_phys_dev_groups) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevGroups:  Failed to allocate new physical device"
-                   " group array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(new_phys_dev_groups, 0, total_count * sizeof(VkPhysicalDeviceGroupPropertiesKHX *));
-
-    // Create a temporary array (on the stack) to keep track of the
-    // returned VkPhysicalDevice values.
-    local_phys_dev_groups = loader_stack_alloc(sizeof(VkPhysicalDeviceGroupPropertiesKHX) * total_count);
-    if (NULL == local_phys_dev_groups) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevGroups:  Failed to allocate local "
-                   "physical device group array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    // Initialize the memory to something valid
-    memset(local_phys_dev_groups, 0, sizeof(VkPhysicalDeviceGroupPropertiesKHX) * total_count);
-    for (uint32_t group = 0; group < total_count; group++) {
-        local_phys_dev_groups[group].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX;
-        local_phys_dev_groups[group].pNext = NULL;
-        local_phys_dev_groups[group].subsetAllocation = false;
-    }
-
-    cur_icd_group_count = 0;
-    icd_term = inst->icd_terms;
-    for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) {
-        uint32_t count_this_time = total_count - cur_icd_group_count;
-
-        if (NULL == icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX) {
-            VkPhysicalDevice* phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * count_this_time);
-            if (NULL == phys_dev_array) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed to allocate local "
-                           "physical device array of size %d",
-                           count_this_time);
-                res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                goto out;
-            }
-
-            res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &count_this_time, phys_dev_array);
-            if (res != VK_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed during dispatch call of "
-                           "\'EnumeratePhysicalDevices\' to ICD %d to get plain phys dev count.",
-                           icd_idx);
-                goto out;
-            }
-
-            // Add each GPU as it's own group
-            for (uint32_t indiv_gpu = 0; indiv_gpu < count_this_time; indiv_gpu++) {
-                local_phys_dev_groups[indiv_gpu + cur_icd_group_count].physicalDeviceCount = 1;
-                local_phys_dev_groups[indiv_gpu + cur_icd_group_count].physicalDevices[0] = phys_dev_array[indiv_gpu];
-            }
-
-        } else {
-            res = icd_term->dispatch.EnumeratePhysicalDeviceGroupsKHX(icd_term->instance, &count_this_time, &local_phys_dev_groups[cur_icd_group_count]);
-            if (VK_SUCCESS != res) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed during dispatch call of "
-                           "\'EnumeratePhysicalDeviceGroupsKHX\' to ICD %d to get content.",
-                           icd_idx);
-                goto out;
-            }
-        }
-
-        cur_icd_group_count += count_this_time;
-    }
-
-    // Replace all the physical device IDs with the proper loader values
-    for (uint32_t group = 0; group < total_count; group++) {
-        for (uint32_t group_gpu = 0; group_gpu < local_phys_dev_groups[group].physicalDeviceCount; group_gpu++) {
-            bool found = false;
-            for (uint32_t term_gpu = 0; term_gpu < inst->phys_dev_count_term; term_gpu++) {
-                if (local_phys_dev_groups[group].physicalDevices[group_gpu] == inst->phys_devs_term[term_gpu]->phys_dev) {
-                    local_phys_dev_groups[group].physicalDevices[group_gpu] = (VkPhysicalDevice)inst->phys_devs_term[term_gpu];
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed to find GPU %d in group %d"
-                           " returned by \'EnumeratePhysicalDeviceGroupsKHX\' in list returned"
-                           " by \'EnumeratePhysicalDevices\'", group_gpu, group);
-                res = VK_ERROR_INITIALIZATION_FAILED;
-                goto out;
-            }
-        }
-    }
-
-    // Copy or create everything to fill the new array of physical device groups
-    for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) {
-        // Check if this physical device group with the same contents is already in the old buffer
-        for (uint32_t old_idx = 0; old_idx < inst->phys_dev_group_count_term; old_idx++) {
-            if (local_phys_dev_groups[new_idx].physicalDeviceCount == inst->phys_dev_groups_term[old_idx]->physicalDeviceCount) {
-                bool found_all_gpus = true;
-                for (uint32_t old_gpu = 0; old_gpu < inst->phys_dev_groups_term[old_idx]->physicalDeviceCount; old_gpu++) {
-                    bool found_gpu = false;
-                    for (uint32_t new_gpu = 0; new_gpu < local_phys_dev_groups[new_idx].physicalDeviceCount; new_gpu++) {
-                        if (local_phys_dev_groups[new_idx].physicalDevices[new_gpu] == inst->phys_dev_groups_term[old_idx]->physicalDevices[old_gpu]) {
-                            found_gpu = true;
-                            break;
-                        }
-                    }
-
-                    if (!found_gpu) {
-                        found_all_gpus = false;
-                        break;
-                    }
-                }
-                if (!found_all_gpus) {
-                    continue;
-                } else {
-                    new_phys_dev_groups[new_idx] = inst->phys_dev_groups_term[old_idx];
-                    break;
-                }
-            }
-        }
-
-        // If this physical device group isn't in the old buffer, create it
-        if (NULL == new_phys_dev_groups[new_idx]) {
-            new_phys_dev_groups[new_idx] = (VkPhysicalDeviceGroupPropertiesKHX *)loader_instance_heap_alloc(
-                inst, sizeof(VkPhysicalDeviceGroupPropertiesKHX), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (NULL == new_phys_dev_groups[new_idx]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTermPhysDevGroups:  Failed to allocate "
-                           "physical device group Terminator object %d",
-                           new_idx);
-                total_count = new_idx;
-                res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                goto out;
-            }
-            memcpy(new_phys_dev_groups[new_idx], &local_phys_dev_groups[new_idx],
-                   sizeof(VkPhysicalDeviceGroupPropertiesKHX));
-        }
-    }
-
-out:
-
-    if (VK_SUCCESS != res) {
-        if (NULL != new_phys_dev_groups) {
-            for (uint32_t i = 0; i < total_count; i++) {
-                loader_instance_heap_free(inst, new_phys_dev_groups[i]);
-            }
-            loader_instance_heap_free(inst, new_phys_dev_groups);
-        }
-        total_count = 0;
-    } else {
-        // Free everything that didn't carry over to the new array of
-        // physical device groups
-        if (NULL != inst->phys_dev_groups_term) {
-            for (uint32_t i = 0; i < inst->phys_dev_group_count_term; i++) {
-                bool found = false;
-                for (uint32_t j = 0; j < total_count; j++) {
-                    if (inst->phys_dev_groups_term[i] == new_phys_dev_groups[j]) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    loader_instance_heap_free(inst, inst->phys_dev_groups_term[i]);
-                }
-            }
-            loader_instance_heap_free(inst, inst->phys_dev_groups_term);
-        }
-
-        // Swap in the new physical device group list
-        inst->phys_dev_group_count_term = total_count;
-        inst->phys_dev_groups_term = new_phys_dev_groups;
-    }
-
-    return res;
-}
diff --git a/third_party/vulkan/loader/extension_manual.h b/third_party/vulkan/loader/extension_manual.h
deleted file mode 100644
index 3b299d553..000000000
--- a/third_party/vulkan/loader/extension_manual.h
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Young <marky@lunarg.com>
- */
-
-#pragma once
-
-// ---- Manually added trampoline/terminator functions
-
-// These functions, for whatever reason, require more complex changes than
-// can easily be automatically generated.
-
-VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX(
-    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDeviceGroupsKHX(
-    VkInstance instance, uint32_t *pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupPropertiesKHX *pPhysicalDeviceGroupProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL
-GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
-    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
-    VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
-    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
-    VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
-                                                                    VkPhysicalDeviceFeatures2KHR* pFeatures);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                           VkPhysicalDeviceProperties2KHR* pProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                      VkPhysicalDeviceProperties2KHR* pProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                 VkFormatProperties2KHR* pFormatProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                            VkFormatProperties2KHR* pFormatProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
-    VkImageFormatProperties2KHR* pImageFormatProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo,
-    VkImageFormatProperties2KHR* pImageFormatProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                      uint32_t* pQueueFamilyPropertyCount,
-                                                                      VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                 VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount,
-    VkSparseImageFormatProperties2KHR* pProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount,
-    VkSparseImageFormatProperties2KHR* pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                                                        const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-                                                                        VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2KHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-    VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                                   const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-                                                                   uint32_t* pSurfaceFormatCount,
-                                                                   VkSurfaceFormat2KHR* pSurfaceFormats);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                                              const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-                                                                              uint32_t* pSurfaceFormatCount,
-                                                                              VkSurfaceFormat2KHR* pSurfaceFormats);
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                        VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
-                                                                                   VkSurfaceKHR surface,
-                                                                                   VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy,
-                                                                VkDisplayKHR display);
-
-VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput,
-                                                        VkDisplayKHR* pDisplay);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput,
-                                                                   VkDisplayKHR* pDisplay);
-#endif  // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
-    VkExternalBufferPropertiesKHR* pExternalBufferProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalBufferPropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
-    VkExternalBufferPropertiesKHR* pExternalBufferProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
-    VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
-    VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
-    VkExternalFencePropertiesKHR* pExternalFenceProperties);
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceExternalFencePropertiesKHR(
-    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
-    VkExternalFencePropertiesKHR* pExternalFenceProperties);
diff --git a/third_party/vulkan/loader/gpa_helper.h b/third_party/vulkan/loader/gpa_helper.h
deleted file mode 100644
index 0763938bb..000000000
--- a/third_party/vulkan/loader/gpa_helper.h
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- *
- * Copyright (c) 2015 The Khronos Group Inc.
- * Copyright (c) 2015 Valve Corporation
- * Copyright (c) 2015 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Jon Ashburn <jon@lunarg.com>
- */
-
-#include <string.h>
-#include "debug_report.h"
-#include "wsi.h"
-
-static inline void *trampolineGetProcAddr(struct loader_instance *inst, const char *funcName) {
-    // Don't include or check global functions
-    if (!strcmp(funcName, "vkGetInstanceProcAddr")) return (PFN_vkVoidFunction)vkGetInstanceProcAddr;
-    if (!strcmp(funcName, "vkDestroyInstance")) return (PFN_vkVoidFunction)vkDestroyInstance;
-    if (!strcmp(funcName, "vkEnumeratePhysicalDevices")) return (PFN_vkVoidFunction)vkEnumeratePhysicalDevices;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceFeatures")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFeatures;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceFormatProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceFormatProperties;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceImageFormatProperties"))
-        return (PFN_vkVoidFunction)vkGetPhysicalDeviceImageFormatProperties;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceSparseImageFormatProperties"))
-        return (PFN_vkVoidFunction)vkGetPhysicalDeviceSparseImageFormatProperties;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceQueueFamilyProperties"))
-        return (PFN_vkVoidFunction)vkGetPhysicalDeviceQueueFamilyProperties;
-    if (!strcmp(funcName, "vkGetPhysicalDeviceMemoryProperties")) return (PFN_vkVoidFunction)vkGetPhysicalDeviceMemoryProperties;
-    if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties")) return (PFN_vkVoidFunction)vkEnumerateDeviceLayerProperties;
-    if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties")) return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties;
-    if (!strcmp(funcName, "vkCreateDevice")) return (PFN_vkVoidFunction)vkCreateDevice;
-    if (!strcmp(funcName, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction)vkGetDeviceProcAddr;
-    if (!strcmp(funcName, "vkDestroyDevice")) return (PFN_vkVoidFunction)vkDestroyDevice;
-    if (!strcmp(funcName, "vkGetDeviceQueue")) return (PFN_vkVoidFunction)vkGetDeviceQueue;
-    if (!strcmp(funcName, "vkQueueSubmit")) return (PFN_vkVoidFunction)vkQueueSubmit;
-    if (!strcmp(funcName, "vkQueueWaitIdle")) return (PFN_vkVoidFunction)vkQueueWaitIdle;
-    if (!strcmp(funcName, "vkDeviceWaitIdle")) return (PFN_vkVoidFunction)vkDeviceWaitIdle;
-    if (!strcmp(funcName, "vkAllocateMemory")) return (PFN_vkVoidFunction)vkAllocateMemory;
-    if (!strcmp(funcName, "vkFreeMemory")) return (PFN_vkVoidFunction)vkFreeMemory;
-    if (!strcmp(funcName, "vkMapMemory")) return (PFN_vkVoidFunction)vkMapMemory;
-    if (!strcmp(funcName, "vkUnmapMemory")) return (PFN_vkVoidFunction)vkUnmapMemory;
-    if (!strcmp(funcName, "vkFlushMappedMemoryRanges")) return (PFN_vkVoidFunction)vkFlushMappedMemoryRanges;
-    if (!strcmp(funcName, "vkInvalidateMappedMemoryRanges")) return (PFN_vkVoidFunction)vkInvalidateMappedMemoryRanges;
-    if (!strcmp(funcName, "vkGetDeviceMemoryCommitment")) return (PFN_vkVoidFunction)vkGetDeviceMemoryCommitment;
-    if (!strcmp(funcName, "vkGetImageSparseMemoryRequirements")) return (PFN_vkVoidFunction)vkGetImageSparseMemoryRequirements;
-    if (!strcmp(funcName, "vkGetImageMemoryRequirements")) return (PFN_vkVoidFunction)vkGetImageMemoryRequirements;
-    if (!strcmp(funcName, "vkGetBufferMemoryRequirements")) return (PFN_vkVoidFunction)vkGetBufferMemoryRequirements;
-    if (!strcmp(funcName, "vkBindImageMemory")) return (PFN_vkVoidFunction)vkBindImageMemory;
-    if (!strcmp(funcName, "vkBindBufferMemory")) return (PFN_vkVoidFunction)vkBindBufferMemory;
-    if (!strcmp(funcName, "vkQueueBindSparse")) return (PFN_vkVoidFunction)vkQueueBindSparse;
-    if (!strcmp(funcName, "vkCreateFence")) return (PFN_vkVoidFunction)vkCreateFence;
-    if (!strcmp(funcName, "vkDestroyFence")) return (PFN_vkVoidFunction)vkDestroyFence;
-    if (!strcmp(funcName, "vkGetFenceStatus")) return (PFN_vkVoidFunction)vkGetFenceStatus;
-    if (!strcmp(funcName, "vkResetFences")) return (PFN_vkVoidFunction)vkResetFences;
-    if (!strcmp(funcName, "vkWaitForFences")) return (PFN_vkVoidFunction)vkWaitForFences;
-    if (!strcmp(funcName, "vkCreateSemaphore")) return (PFN_vkVoidFunction)vkCreateSemaphore;
-    if (!strcmp(funcName, "vkDestroySemaphore")) return (PFN_vkVoidFunction)vkDestroySemaphore;
-    if (!strcmp(funcName, "vkCreateEvent")) return (PFN_vkVoidFunction)vkCreateEvent;
-    if (!strcmp(funcName, "vkDestroyEvent")) return (PFN_vkVoidFunction)vkDestroyEvent;
-    if (!strcmp(funcName, "vkGetEventStatus")) return (PFN_vkVoidFunction)vkGetEventStatus;
-    if (!strcmp(funcName, "vkSetEvent")) return (PFN_vkVoidFunction)vkSetEvent;
-    if (!strcmp(funcName, "vkResetEvent")) return (PFN_vkVoidFunction)vkResetEvent;
-    if (!strcmp(funcName, "vkCreateQueryPool")) return (PFN_vkVoidFunction)vkCreateQueryPool;
-    if (!strcmp(funcName, "vkDestroyQueryPool")) return (PFN_vkVoidFunction)vkDestroyQueryPool;
-    if (!strcmp(funcName, "vkGetQueryPoolResults")) return (PFN_vkVoidFunction)vkGetQueryPoolResults;
-    if (!strcmp(funcName, "vkCreateBuffer")) return (PFN_vkVoidFunction)vkCreateBuffer;
-    if (!strcmp(funcName, "vkDestroyBuffer")) return (PFN_vkVoidFunction)vkDestroyBuffer;
-    if (!strcmp(funcName, "vkCreateBufferView")) return (PFN_vkVoidFunction)vkCreateBufferView;
-    if (!strcmp(funcName, "vkDestroyBufferView")) return (PFN_vkVoidFunction)vkDestroyBufferView;
-    if (!strcmp(funcName, "vkCreateImage")) return (PFN_vkVoidFunction)vkCreateImage;
-    if (!strcmp(funcName, "vkDestroyImage")) return (PFN_vkVoidFunction)vkDestroyImage;
-    if (!strcmp(funcName, "vkGetImageSubresourceLayout")) return (PFN_vkVoidFunction)vkGetImageSubresourceLayout;
-    if (!strcmp(funcName, "vkCreateImageView")) return (PFN_vkVoidFunction)vkCreateImageView;
-    if (!strcmp(funcName, "vkDestroyImageView")) return (PFN_vkVoidFunction)vkDestroyImageView;
-    if (!strcmp(funcName, "vkCreateShaderModule")) return (PFN_vkVoidFunction)vkCreateShaderModule;
-    if (!strcmp(funcName, "vkDestroyShaderModule")) return (PFN_vkVoidFunction)vkDestroyShaderModule;
-    if (!strcmp(funcName, "vkCreatePipelineCache")) return (PFN_vkVoidFunction)vkCreatePipelineCache;
-    if (!strcmp(funcName, "vkDestroyPipelineCache")) return (PFN_vkVoidFunction)vkDestroyPipelineCache;
-    if (!strcmp(funcName, "vkGetPipelineCacheData")) return (PFN_vkVoidFunction)vkGetPipelineCacheData;
-    if (!strcmp(funcName, "vkMergePipelineCaches")) return (PFN_vkVoidFunction)vkMergePipelineCaches;
-    if (!strcmp(funcName, "vkCreateGraphicsPipelines")) return (PFN_vkVoidFunction)vkCreateGraphicsPipelines;
-    if (!strcmp(funcName, "vkCreateComputePipelines")) return (PFN_vkVoidFunction)vkCreateComputePipelines;
-    if (!strcmp(funcName, "vkDestroyPipeline")) return (PFN_vkVoidFunction)vkDestroyPipeline;
-    if (!strcmp(funcName, "vkCreatePipelineLayout")) return (PFN_vkVoidFunction)vkCreatePipelineLayout;
-    if (!strcmp(funcName, "vkDestroyPipelineLayout")) return (PFN_vkVoidFunction)vkDestroyPipelineLayout;
-    if (!strcmp(funcName, "vkCreateSampler")) return (PFN_vkVoidFunction)vkCreateSampler;
-    if (!strcmp(funcName, "vkDestroySampler")) return (PFN_vkVoidFunction)vkDestroySampler;
-    if (!strcmp(funcName, "vkCreateDescriptorSetLayout")) return (PFN_vkVoidFunction)vkCreateDescriptorSetLayout;
-    if (!strcmp(funcName, "vkDestroyDescriptorSetLayout")) return (PFN_vkVoidFunction)vkDestroyDescriptorSetLayout;
-    if (!strcmp(funcName, "vkCreateDescriptorPool")) return (PFN_vkVoidFunction)vkCreateDescriptorPool;
-    if (!strcmp(funcName, "vkDestroyDescriptorPool")) return (PFN_vkVoidFunction)vkDestroyDescriptorPool;
-    if (!strcmp(funcName, "vkResetDescriptorPool")) return (PFN_vkVoidFunction)vkResetDescriptorPool;
-    if (!strcmp(funcName, "vkAllocateDescriptorSets")) return (PFN_vkVoidFunction)vkAllocateDescriptorSets;
-    if (!strcmp(funcName, "vkFreeDescriptorSets")) return (PFN_vkVoidFunction)vkFreeDescriptorSets;
-    if (!strcmp(funcName, "vkUpdateDescriptorSets")) return (PFN_vkVoidFunction)vkUpdateDescriptorSets;
-    if (!strcmp(funcName, "vkCreateFramebuffer")) return (PFN_vkVoidFunction)vkCreateFramebuffer;
-    if (!strcmp(funcName, "vkDestroyFramebuffer")) return (PFN_vkVoidFunction)vkDestroyFramebuffer;
-    if (!strcmp(funcName, "vkCreateRenderPass")) return (PFN_vkVoidFunction)vkCreateRenderPass;
-    if (!strcmp(funcName, "vkDestroyRenderPass")) return (PFN_vkVoidFunction)vkDestroyRenderPass;
-    if (!strcmp(funcName, "vkGetRenderAreaGranularity")) return (PFN_vkVoidFunction)vkGetRenderAreaGranularity;
-    if (!strcmp(funcName, "vkCreateCommandPool")) return (PFN_vkVoidFunction)vkCreateCommandPool;
-    if (!strcmp(funcName, "vkDestroyCommandPool")) return (PFN_vkVoidFunction)vkDestroyCommandPool;
-    if (!strcmp(funcName, "vkResetCommandPool")) return (PFN_vkVoidFunction)vkResetCommandPool;
-    if (!strcmp(funcName, "vkAllocateCommandBuffers")) return (PFN_vkVoidFunction)vkAllocateCommandBuffers;
-    if (!strcmp(funcName, "vkFreeCommandBuffers")) return (PFN_vkVoidFunction)vkFreeCommandBuffers;
-    if (!strcmp(funcName, "vkBeginCommandBuffer")) return (PFN_vkVoidFunction)vkBeginCommandBuffer;
-    if (!strcmp(funcName, "vkEndCommandBuffer")) return (PFN_vkVoidFunction)vkEndCommandBuffer;
-    if (!strcmp(funcName, "vkResetCommandBuffer")) return (PFN_vkVoidFunction)vkResetCommandBuffer;
-    if (!strcmp(funcName, "vkCmdBindPipeline")) return (PFN_vkVoidFunction)vkCmdBindPipeline;
-    if (!strcmp(funcName, "vkCmdBindDescriptorSets")) return (PFN_vkVoidFunction)vkCmdBindDescriptorSets;
-    if (!strcmp(funcName, "vkCmdBindVertexBuffers")) return (PFN_vkVoidFunction)vkCmdBindVertexBuffers;
-    if (!strcmp(funcName, "vkCmdBindIndexBuffer")) return (PFN_vkVoidFunction)vkCmdBindIndexBuffer;
-    if (!strcmp(funcName, "vkCmdSetViewport")) return (PFN_vkVoidFunction)vkCmdSetViewport;
-    if (!strcmp(funcName, "vkCmdSetScissor")) return (PFN_vkVoidFunction)vkCmdSetScissor;
-    if (!strcmp(funcName, "vkCmdSetLineWidth")) return (PFN_vkVoidFunction)vkCmdSetLineWidth;
-    if (!strcmp(funcName, "vkCmdSetDepthBias")) return (PFN_vkVoidFunction)vkCmdSetDepthBias;
-    if (!strcmp(funcName, "vkCmdSetBlendConstants")) return (PFN_vkVoidFunction)vkCmdSetBlendConstants;
-    if (!strcmp(funcName, "vkCmdSetDepthBounds")) return (PFN_vkVoidFunction)vkCmdSetDepthBounds;
-    if (!strcmp(funcName, "vkCmdSetStencilCompareMask")) return (PFN_vkVoidFunction)vkCmdSetStencilCompareMask;
-    if (!strcmp(funcName, "vkCmdSetStencilWriteMask")) return (PFN_vkVoidFunction)vkCmdSetStencilWriteMask;
-    if (!strcmp(funcName, "vkCmdSetStencilReference")) return (PFN_vkVoidFunction)vkCmdSetStencilReference;
-    if (!strcmp(funcName, "vkCmdDraw")) return (PFN_vkVoidFunction)vkCmdDraw;
-    if (!strcmp(funcName, "vkCmdDrawIndexed")) return (PFN_vkVoidFunction)vkCmdDrawIndexed;
-    if (!strcmp(funcName, "vkCmdDrawIndirect")) return (PFN_vkVoidFunction)vkCmdDrawIndirect;
-    if (!strcmp(funcName, "vkCmdDrawIndexedIndirect")) return (PFN_vkVoidFunction)vkCmdDrawIndexedIndirect;
-    if (!strcmp(funcName, "vkCmdDispatch")) return (PFN_vkVoidFunction)vkCmdDispatch;
-    if (!strcmp(funcName, "vkCmdDispatchIndirect")) return (PFN_vkVoidFunction)vkCmdDispatchIndirect;
-    if (!strcmp(funcName, "vkCmdCopyBuffer")) return (PFN_vkVoidFunction)vkCmdCopyBuffer;
-    if (!strcmp(funcName, "vkCmdCopyImage")) return (PFN_vkVoidFunction)vkCmdCopyImage;
-    if (!strcmp(funcName, "vkCmdBlitImage")) return (PFN_vkVoidFunction)vkCmdBlitImage;
-    if (!strcmp(funcName, "vkCmdCopyBufferToImage")) return (PFN_vkVoidFunction)vkCmdCopyBufferToImage;
-    if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) return (PFN_vkVoidFunction)vkCmdCopyImageToBuffer;
-    if (!strcmp(funcName, "vkCmdUpdateBuffer")) return (PFN_vkVoidFunction)vkCmdUpdateBuffer;
-    if (!strcmp(funcName, "vkCmdFillBuffer")) return (PFN_vkVoidFunction)vkCmdFillBuffer;
-    if (!strcmp(funcName, "vkCmdClearColorImage")) return (PFN_vkVoidFunction)vkCmdClearColorImage;
-    if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) return (PFN_vkVoidFunction)vkCmdClearDepthStencilImage;
-    if (!strcmp(funcName, "vkCmdClearAttachments")) return (PFN_vkVoidFunction)vkCmdClearAttachments;
-    if (!strcmp(funcName, "vkCmdResolveImage")) return (PFN_vkVoidFunction)vkCmdResolveImage;
-    if (!strcmp(funcName, "vkCmdSetEvent")) return (PFN_vkVoidFunction)vkCmdSetEvent;
-    if (!strcmp(funcName, "vkCmdResetEvent")) return (PFN_vkVoidFunction)vkCmdResetEvent;
-    if (!strcmp(funcName, "vkCmdWaitEvents")) return (PFN_vkVoidFunction)vkCmdWaitEvents;
-    if (!strcmp(funcName, "vkCmdPipelineBarrier")) return (PFN_vkVoidFunction)vkCmdPipelineBarrier;
-    if (!strcmp(funcName, "vkCmdBeginQuery")) return (PFN_vkVoidFunction)vkCmdBeginQuery;
-    if (!strcmp(funcName, "vkCmdEndQuery")) return (PFN_vkVoidFunction)vkCmdEndQuery;
-    if (!strcmp(funcName, "vkCmdResetQueryPool")) return (PFN_vkVoidFunction)vkCmdResetQueryPool;
-    if (!strcmp(funcName, "vkCmdWriteTimestamp")) return (PFN_vkVoidFunction)vkCmdWriteTimestamp;
-    if (!strcmp(funcName, "vkCmdCopyQueryPoolResults")) return (PFN_vkVoidFunction)vkCmdCopyQueryPoolResults;
-    if (!strcmp(funcName, "vkCmdPushConstants")) return (PFN_vkVoidFunction)vkCmdPushConstants;
-    if (!strcmp(funcName, "vkCmdBeginRenderPass")) return (PFN_vkVoidFunction)vkCmdBeginRenderPass;
-    if (!strcmp(funcName, "vkCmdNextSubpass")) return (PFN_vkVoidFunction)vkCmdNextSubpass;
-    if (!strcmp(funcName, "vkCmdEndRenderPass")) return (PFN_vkVoidFunction)vkCmdEndRenderPass;
-    if (!strcmp(funcName, "vkCmdExecuteCommands")) return (PFN_vkVoidFunction)vkCmdExecuteCommands;
-
-    // Instance extensions
-    void *addr;
-    if (debug_report_instance_gpa(inst, funcName, &addr)) return addr;
-
-    if (wsi_swapchain_instance_gpa(inst, funcName, &addr)) return addr;
-
-    if (extension_instance_gpa(inst, funcName, &addr)) return addr;
-
-    // Unknown physical device extensions
-    if (loader_phys_dev_ext_gpa(inst, funcName, true, &addr, NULL)) return addr;
-
-    // Unknown device extensions
-    addr = loader_dev_ext_gpa(inst, funcName);
-    return addr;
-}
-
-static inline void *globalGetProcAddr(const char *name) {
-    if (!name || name[0] != 'v' || name[1] != 'k') return NULL;
-
-    name += 2;
-    if (!strcmp(name, "CreateInstance")) return (void *)vkCreateInstance;
-    if (!strcmp(name, "EnumerateInstanceExtensionProperties")) return (void *)vkEnumerateInstanceExtensionProperties;
-    if (!strcmp(name, "EnumerateInstanceLayerProperties")) return (void *)vkEnumerateInstanceLayerProperties;
-
-    return NULL;
-}
-
-static inline void *loader_non_passthrough_gdpa(const char *name) {
-    if (!name || name[0] != 'v' || name[1] != 'k') return NULL;
-
-    name += 2;
-
-    if (!strcmp(name, "GetDeviceProcAddr")) return (void *)vkGetDeviceProcAddr;
-    if (!strcmp(name, "DestroyDevice")) return (void *)vkDestroyDevice;
-    if (!strcmp(name, "GetDeviceQueue")) return (void *)vkGetDeviceQueue;
-    if (!strcmp(name, "AllocateCommandBuffers")) return (void *)vkAllocateCommandBuffers;
-
-    return NULL;
-}
diff --git a/third_party/vulkan/loader/loader.c b/third_party/vulkan/loader/loader.c
deleted file mode 100644
index f1bc58976..000000000
--- a/third_party/vulkan/loader/loader.c
+++ /dev/null
@@ -1,6065 +0,0 @@
-/*
- *
- * Copyright (c) 2014-2018 The Khronos Group Inc.
- * Copyright (c) 2014-2018 Valve Corporation
- * Copyright (c) 2014-2018 LunarG, Inc.
- * Copyright (C) 2015 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-
- *
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
- * Author: Mark Young <marky@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- *
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stddef.h>
-
-#include <sys/types.h>
-#if defined(_WIN32)
-#include "dirent_on_windows.h"
-#else  // _WIN32
-#include <dirent.h>
-#endif  // _WIN32
-#include "vk_loader_platform.h"
-#include "loader.h"
-#include "gpa_helper.h"
-#include "debug_report.h"
-#include "wsi.h"
-#include "vulkan/vk_icd.h"
-#include "cJSON.h"
-#include "murmurhash.h"
-
-#if defined(_WIN32)
-#include <Cfgmgr32.h>
-#include <initguid.h>
-#include <Devpkey.h>
-#endif
-
-// This is a CMake generated file with #defines for any functions/includes
-// that it found present.  This is currently necessary to properly determine
-// if secure_getenv or __secure_getenv are present
-#if !defined(VULKAN_NON_CMAKE_BUILD)
-#include "loader_cmake_config.h"
-#endif  // !defined(VULKAN_NON_CMAKE_BUILD)
-
-// Generated file containing all the extension data
-#include "vk_loader_extensions.c"
-
-struct loader_struct loader = {0};
-// TLS for instance for alloc/free callbacks
-THREAD_LOCAL_DECL struct loader_instance *tls_instance;
-
-static size_t loader_platform_combine_path(char *dest, size_t len, ...);
-
-struct loader_phys_dev_per_icd {
-    uint32_t count;
-    VkPhysicalDevice *phys_devs;
-    struct loader_icd_term *this_icd_term;
-};
-
-enum loader_debug {
-    LOADER_INFO_BIT = 0x01,
-    LOADER_WARN_BIT = 0x02,
-    LOADER_PERF_BIT = 0x04,
-    LOADER_ERROR_BIT = 0x08,
-    LOADER_DEBUG_BIT = 0x10,
-};
-
-uint32_t g_loader_debug = 0;
-uint32_t g_loader_log_msgs = 0;
-
-// thread safety lock for accessing global data structures such as "loader"
-// all entrypoints on the instance chain need to be locked except GPA
-// additionally CreateDevice and DestroyDevice needs to be locked
-loader_platform_thread_mutex loader_lock;
-loader_platform_thread_mutex loader_json_lock;
-
-LOADER_PLATFORM_THREAD_ONCE_DECLARATION(once_init);
-
-void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope alloc_scope) {
-    void *pMemory = NULL;
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (instance && instance->alloc_callbacks.pfnAllocation) {
-        // These are internal structures, so it's best to align everything to
-        // the largest unit size which is the size of a uint64_t.
-        pMemory = instance->alloc_callbacks.pfnAllocation(instance->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope);
-    } else {
-#endif
-        pMemory = malloc(size);
-    }
-
-    return pMemory;
-}
-
-void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory) {
-    if (pMemory != NULL) {
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-        {
-#else
-        if (instance && instance->alloc_callbacks.pfnFree) {
-            instance->alloc_callbacks.pfnFree(instance->alloc_callbacks.pUserData, pMemory);
-        } else {
-#endif
-            free(pMemory);
-        }
-    }
-}
-
-void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size,
-                                   VkSystemAllocationScope alloc_scope) {
-    void *pNewMem = NULL;
-    if (pMemory == NULL || orig_size == 0) {
-        pNewMem = loader_instance_heap_alloc(instance, size, alloc_scope);
-    } else if (size == 0) {
-        loader_instance_heap_free(instance, pMemory);
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-#else
-    } else if (instance && instance->alloc_callbacks.pfnReallocation) {
-        // These are internal structures, so it's best to align everything to
-        // the largest unit size which is the size of a uint64_t.
-        pNewMem = instance->alloc_callbacks.pfnReallocation(instance->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t),
-                                                            alloc_scope);
-#endif
-    } else {
-        pNewMem = realloc(pMemory, size);
-    }
-    return pNewMem;
-}
-
-void *loader_instance_tls_heap_alloc(size_t size) {
-    return loader_instance_heap_alloc(tls_instance, size, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-}
-
-void loader_instance_tls_heap_free(void *pMemory) { loader_instance_heap_free(tls_instance, pMemory); }
-
-void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope alloc_scope) {
-    void *pMemory = NULL;
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (device && device->alloc_callbacks.pfnAllocation) {
-        // These are internal structures, so it's best to align everything to
-        // the largest unit size which is the size of a uint64_t.
-        pMemory = device->alloc_callbacks.pfnAllocation(device->alloc_callbacks.pUserData, size, sizeof(uint64_t), alloc_scope);
-    } else {
-#endif
-        pMemory = malloc(size);
-    }
-    return pMemory;
-}
-
-void loader_device_heap_free(const struct loader_device *device, void *pMemory) {
-    if (pMemory != NULL) {
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-        {
-#else
-        if (device && device->alloc_callbacks.pfnFree) {
-            device->alloc_callbacks.pfnFree(device->alloc_callbacks.pUserData, pMemory);
-        } else {
-#endif
-            free(pMemory);
-        }
-    }
-}
-
-void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size,
-                                 VkSystemAllocationScope alloc_scope) {
-    void *pNewMem = NULL;
-    if (pMemory == NULL || orig_size == 0) {
-        pNewMem = loader_device_heap_alloc(device, size, alloc_scope);
-    } else if (size == 0) {
-        loader_device_heap_free(device, pMemory);
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-#else
-    } else if (device && device->alloc_callbacks.pfnReallocation) {
-        // These are internal structures, so it's best to align everything to
-        // the largest unit size which is the size of a uint64_t.
-        pNewMem = device->alloc_callbacks.pfnReallocation(device->alloc_callbacks.pUserData, pMemory, size, sizeof(uint64_t),
-                                                          alloc_scope);
-#endif
-    } else {
-        pNewMem = realloc(pMemory, size);
-    }
-    return pNewMem;
-}
-
-// Environment variables
-#if defined(__linux__)
-
-static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
-    // No allocation of memory necessary for Linux, but we should at least touch
-    // the inst pointer to get rid of compiler warnings.
-    (void)inst;
-    return getenv(name);
-}
-
-static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) {
-    // No allocation of memory necessary for Linux, but we should at least touch
-    // the inst pointer to get rid of compiler warnings.
-    (void)inst;
-
-#ifdef HAVE_SECURE_GETENV
-    return secure_getenv(name);
-#elif defined(HAVE___SECURE_GETENV)
-    return __secure_getenv(name);
-#else
-#pragma message(                                                                       \
-    "Warning:  Falling back to non-secure getenv for environmental lookups!  Consider" \
-    " updating to a different libc.")
-    return loader_getenv(name, inst);
-#endif
-}
-
-static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
-    // No freeing of memory necessary for Linux, but we should at least touch
-    // the val and inst pointers to get rid of compiler warnings.
-    (void)val;
-    (void)inst;
-}
-
-#elif defined(WIN32)
-
-static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
-    char *retVal;
-    DWORD valSize;
-
-    valSize = GetEnvironmentVariableA(name, NULL, 0);
-
-    // valSize DOES include the null terminator, so for any set variable
-    // will always be at least 1. If it's 0, the variable wasn't set.
-    if (valSize == 0) return NULL;
-
-    // Allocate the space necessary for the registry entry
-    if (NULL != inst && NULL != inst->alloc_callbacks.pfnAllocation) {
-        retVal = (char *)inst->alloc_callbacks.pfnAllocation(inst->alloc_callbacks.pUserData, valSize, sizeof(char *),
-                                                             VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-    } else {
-        retVal = (char *)malloc(valSize);
-    }
-
-    if (NULL != retVal) {
-        GetEnvironmentVariableA(name, retVal, valSize);
-    }
-
-    return retVal;
-}
-
-static inline char *loader_secure_getenv(const char *name, const struct loader_instance *inst) {
-    // No secure version for Windows as far as I know
-    return loader_getenv(name, inst);
-}
-
-static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
-    if (NULL != inst && NULL != inst->alloc_callbacks.pfnFree) {
-        inst->alloc_callbacks.pfnFree(inst->alloc_callbacks.pUserData, val);
-    } else {
-        free((void *)val);
-    }
-}
-
-#else
-
-static inline char *loader_getenv(const char *name, const struct loader_instance *inst) {
-    // stub func
-    (void)inst;
-    (void)name;
-    return NULL;
-}
-static inline void loader_free_getenv(char *val, const struct loader_instance *inst) {
-    // stub func
-    (void)val;
-    (void)inst;
-}
-
-#endif
-
-void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...) {
-    char msg[512];
-    char cmd_line_msg[512];
-    size_t cmd_line_size = sizeof(cmd_line_msg);
-    va_list ap;
-    int ret;
-
-    va_start(ap, format);
-    ret = vsnprintf(msg, sizeof(msg), format, ap);
-    if ((ret >= (int)sizeof(msg)) || ret < 0) {
-        msg[sizeof(msg) - 1] = '\0';
-    }
-    va_end(ap);
-
-    if (inst) {
-        util_DebugReportMessage(inst, msg_type, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, (uint64_t)(uintptr_t)inst, 0, msg_code,
-                                "loader", msg);
-    }
-
-    if (!(msg_type & g_loader_log_msgs)) {
-        return;
-    }
-
-    cmd_line_msg[0] = '\0';
-    cmd_line_size -= 1;
-    size_t original_size = cmd_line_size;
-
-    va_start(ap, format);
-    if ((msg_type & LOADER_INFO_BIT) != 0) {
-        strncat(cmd_line_msg, "INFO", cmd_line_size);
-        cmd_line_size -= 4;
-    }
-    if ((msg_type & LOADER_WARN_BIT) != 0) {
-        if (cmd_line_size != original_size) {
-            strncat(cmd_line_msg, " | ", cmd_line_size);
-            cmd_line_size -= 3;
-        }
-        strncat(cmd_line_msg, "WARNING", cmd_line_size);
-        cmd_line_size -= 7;
-    }
-    if ((msg_type & LOADER_PERF_BIT) != 0) {
-        if (cmd_line_size != original_size) {
-            strncat(cmd_line_msg, " | ", cmd_line_size);
-            cmd_line_size -= 3;
-        }
-        strncat(cmd_line_msg, "PERF", cmd_line_size);
-        cmd_line_size -= 4;
-    }
-    if ((msg_type & LOADER_ERROR_BIT) != 0) {
-        if (cmd_line_size != original_size) {
-            strncat(cmd_line_msg, " | ", cmd_line_size);
-            cmd_line_size -= 3;
-        }
-        strncat(cmd_line_msg, "ERROR", cmd_line_size);
-        cmd_line_size -= 5;
-    }
-    if ((msg_type & LOADER_DEBUG_BIT) != 0) {
-        if (cmd_line_size != original_size) {
-            strncat(cmd_line_msg, " | ", cmd_line_size);
-            cmd_line_size -= 3;
-        }
-        strncat(cmd_line_msg, "DEBUG", cmd_line_size);
-        cmd_line_size -= 5;
-    }
-    if (cmd_line_size != original_size) {
-        strncat(cmd_line_msg, ": ", cmd_line_size);
-        cmd_line_size -= 2;
-    }
-
-    if (0 < cmd_line_size) {
-        // If the message is too long, trim it down
-        if (strlen(msg) > cmd_line_size) {
-            msg[cmd_line_size - 1] = '\0';
-        }
-        strncat(cmd_line_msg, msg, cmd_line_size);
-    } else {
-        // Shouldn't get here, but check to make sure if we've already overrun
-        // the string boundary
-        assert(false);
-    }
-
-#if defined(WIN32)
-    OutputDebugString(cmd_line_msg);
-    OutputDebugString("\n");
-#endif
-
-    fputs(cmd_line_msg, stderr);
-    fputc('\n', stderr);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL vkSetInstanceDispatch(VkInstance instance, void *object) {
-    struct loader_instance *inst = loader_get_instance(instance);
-    if (!inst) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkSetInstanceDispatch: Can not retrieve Instance "
-                   "dispatch table.");
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    loader_set_dispatch(object, inst->disp);
-    return VK_SUCCESS;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL vkSetDeviceDispatch(VkDevice device, void *object) {
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
-
-    if (NULL == icd_term) {
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    loader_set_dispatch(object, &dev->loader_dispatch);
-    return VK_SUCCESS;
-}
-
-#if defined(_WIN32)
-// Find the list of registry files (names VulkanDriverName/VulkanDriverNameWow) in hkr.
-//
-// This function looks for filename in given device handle, filename is then added to return list
-// function return true if filename was appended to reg_data list
-// If error occures result is updated with failure reason
-bool loaderGetDeviceRegistryEntry(const struct loader_instance *inst, char **reg_data, PDWORD total_size, DEVINST dev_id, LPCTSTR value_name, VkResult *result)
-{
-    HKEY hkrKey = INVALID_HANDLE_VALUE;
-    DWORD requiredSize, data_type;
-    char *manifest_path = NULL;
-    bool found = false;
-
-    if (NULL == total_size || NULL == reg_data) {
-        *result = VK_ERROR_INITIALIZATION_FAILED;
-        return false;
-    }
-
-    CONFIGRET status = CM_Open_DevNode_Key(dev_id, KEY_QUERY_VALUE, 0, RegDisposition_OpenExisting, &hkrKey, CM_REGISTRY_SOFTWARE);
-    if (status != CR_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-            "loaderGetDeviceRegistryEntry: Failed to open registry key for DeviceID(%d)", dev_id);
-        *result = VK_ERROR_INITIALIZATION_FAILED;
-        return false;
-    }
-
-    // query value
-    LSTATUS ret = RegQueryValueEx(
-        hkrKey,
-        value_name,
-        NULL,
-        NULL,
-        NULL,
-        &requiredSize);
-
-    if (ret != ERROR_SUCCESS) {
-        if (ret == ERROR_FILE_NOT_FOUND) {
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                "loaderGetDeviceRegistryEntry: Device ID(%d) Does not contain a value for \"%s\"", dev_id, value_name);
-        } else {
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                "loaderGetDeviceRegistryEntry: DeviceID(%d) Failed to obtain %s size", dev_id, value_name);
-        }
-        goto out;
-    }
-
-    manifest_path = loader_instance_heap_alloc(inst, requiredSize, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (manifest_path == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "loaderGetDeviceRegistryEntry: Failed to allocate space for DriverName.");
-        *result = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    ret = RegQueryValueEx(
-        hkrKey,
-        value_name,
-        NULL,
-        &data_type,
-        (BYTE *)manifest_path,
-        &requiredSize
-    );
-
-    if (ret != ERROR_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "loaderGetDeviceRegistryEntry: DeviceID(%d) Failed to obtain %s", value_name);
-
-        *result = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    if (data_type != REG_SZ && data_type != REG_MULTI_SZ) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "loaderGetDeviceRegistryEntry: Invalid %s data type. Expected REG_SZ or REG_MULTI_SZ.", value_name);
-        *result = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    if (NULL == *reg_data) {
-        *reg_data = loader_instance_heap_alloc(inst, *total_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == *reg_data) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loaderGetDeviceRegistryEntry: Failed to allocate space for registry data for key %s", manifest_path);
-            *result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        *reg_data[0] = '\0';
-    } else if (strlen(*reg_data) + requiredSize + 1 > *total_size) {
-        void *new_ptr = loader_instance_heap_realloc(inst, *reg_data, *total_size, *total_size * 2,
-            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == new_ptr) {
-            loader_log(
-                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loaderGetDeviceRegistryEntry: Failed to reallocate space for registry value of size %d for key %s",
-                *total_size * 2, manifest_path);
-            *result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        *reg_data = new_ptr;
-        *total_size *= 2;
-    }
-
-    for (char *curr_filename = manifest_path; curr_filename[0] != '\0'; curr_filename += strlen(curr_filename) + 1) {
-        if (strlen(*reg_data) == 0) {
-            (void)snprintf(*reg_data, requiredSize + 1, "%s", curr_filename);
-        } else {
-            (void)snprintf(*reg_data + strlen(*reg_data), requiredSize + 2, "%c%s", PATH_SEPARATOR, curr_filename);
-        }
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "%s: Located json file \"%s\" from PnP registry: %s", __FUNCTION__, curr_filename, value_name);
-
-        if (data_type == REG_SZ) {
-            break;
-        }
-    }
-    found = true;
-
-out:
-    if (manifest_path != NULL) {
-        loader_instance_heap_free(inst, manifest_path);
-    }
-    RegCloseKey(hkrKey);
-    return found;
-}
-
-// Find the list of registry files (names VulkanDriverName/VulkanDriverNameWow) in hkr .
-//
-// This function looks for display devices and childish software components
-// for a list of files which are added to a returned list (function return
-// value).
-// Function return is a string with a ';'  separated list of filenames.
-// Function return is NULL if no valid name/value pairs  are found in the key,
-// or the key is not found.
-//
-// *reg_data contains a string list of filenames as pointer.
-// When done using the returned string list, the caller should free the pointer.
-VkResult loaderGetDeviceRegistryFiles(const struct loader_instance *inst, char **reg_data, PDWORD reg_data_size, LPCTSTR value_name) {
-    static const char* softwareComponentGUID = "{5c4c3332-344d-483c-8739-259e934c9cc8}";
-    static const char* displayGUID = "{4d36e968-e325-11ce-bfc1-08002be10318}";
-    const ULONG flags = CM_GETIDLIST_FILTER_CLASS | CM_GETIDLIST_FILTER_PRESENT;
-   
-    char childGuid[MAX_GUID_STRING_LEN + 2]; // +2 for brackets {}
-    ULONG childGuidSize = sizeof(childGuid);
-
-    DEVINST devID = 0, childID = 0;
-    char *pDeviceNames = NULL;
-    ULONG deviceNamesSize = 0;
-    VkResult result = VK_SUCCESS;
-    bool found = false;
-
-    if (NULL == reg_data) {
-        result = VK_ERROR_INITIALIZATION_FAILED;
-        return result;
-    }
-
-    // if after obtaining the DeviceNameSize, new device is added start over
-    do {
-        CM_Get_Device_ID_List_Size(&deviceNamesSize, displayGUID, flags);
-
-        if (pDeviceNames != NULL) {
-            loader_instance_heap_free(inst, pDeviceNames);
-        }
-
-        pDeviceNames = loader_instance_heap_alloc(inst, deviceNamesSize, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (pDeviceNames == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                "loaderGetDeviceRegistryFiles: Failed to allocate space for display device names.");
-            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            return result;
-        }
-    } while (CM_Get_Device_ID_List(displayGUID, pDeviceNames, deviceNamesSize, flags) == CR_BUFFER_SMALL); 
-    
-    if (pDeviceNames) {
-
-        for (char *deviceName = pDeviceNames; *deviceName; deviceName += strlen(deviceName) + 1) {
-            CONFIGRET status = CM_Locate_DevNode(&devID, deviceName, CM_LOCATE_DEVNODE_NORMAL);
-            if (CR_SUCCESS != status) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                    "loaderGetRegistryFiles: failed to open DevNode %s", deviceName);
-                continue;
-            }
-            ULONG ulStatus, ulProblem;
-            status = CM_Get_DevNode_Status(&ulStatus, &ulProblem, devID, 0);
-
-            if (CR_SUCCESS != status)
-            {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                    "loaderGetRegistryFiles: failed to probe device status %s", deviceName);
-                continue;
-            }
-            if ((ulStatus & DN_HAS_PROBLEM) && (ulProblem == CM_PROB_NEED_RESTART || ulProblem == DN_NEED_RESTART))
-            {
-                loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                    "loaderGetRegistryFiles: device %s is pending reboot, skipping ...", deviceName);
-                continue;
-            }
-
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                "loaderGetRegistryFiles: opening device %s", deviceName);
-
-            if (loaderGetDeviceRegistryEntry(inst, reg_data, reg_data_size, devID, value_name, &result)) {
-                found = true;
-                continue;
-            }
-            else if (result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-                break;
-            }
-
-            status = CM_Get_Child(&childID, devID, 0);
-            if (status != CR_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                    "loaderGetRegistryFiles: unable to open child-device error:%d", status);
-                continue;
-            }
-
-            do {
-                char buffer[MAX_DEVICE_ID_LEN];
-                CM_Get_Device_ID(childID, buffer, MAX_DEVICE_ID_LEN, 0);
-
-                loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                    "loaderGetRegistryFiles: Opening child device %d - %s", childID, buffer);
-
-                status = CM_Get_DevNode_Registry_Property(childID, CM_DRP_CLASSGUID, NULL, &childGuid, &childGuidSize, 0);
-                if (status != CR_SUCCESS) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                        "loaderGetRegistryFiles: unable to obtain GUID for:%d error:%d", childID, status);
-
-                    result = VK_ERROR_INITIALIZATION_FAILED;
-                    continue;
-                }
-
-                if (strcmp(childGuid, softwareComponentGUID) != 0) {
-                    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                        "loaderGetRegistryFiles: GUID for %d is not SoftwareComponent skipping", childID);
-                    continue;
-                }
-
-                if (loaderGetDeviceRegistryEntry(inst, reg_data, reg_data_size, childID, value_name, &result)) {
-                    found = true;
-                    break; // check next-display-device
-                }
-
-            } while (CM_Get_Sibling(&childID, childID, 0) == CR_SUCCESS);
-        }
-
-        loader_instance_heap_free(inst, pDeviceNames);
-    }
-
-    if (!found && result != VK_ERROR_OUT_OF_HOST_MEMORY) {
-        result = VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    return result;
-}
-
-static char *loader_get_next_path(char *path);
-
-// Find the list of registry files (names within a key) in key "location".
-//
-// This function looks in the registry (hive = DEFAULT_VK_REGISTRY_HIVE) key as
-// given in "location"
-// for a list or name/values which are added to a returned list (function return
-// value).
-// The DWORD values within the key must be 0 or they are skipped.
-// Function return is a string with a ';'  separated list of filenames.
-// Function return is NULL if no valid name/value pairs  are found in the key,
-// or the key is not found.
-//
-// *reg_data contains a string list of filenames as pointer.
-// When done using the returned string list, the caller should free the pointer.
-VkResult loaderGetRegistryFiles(const struct loader_instance *inst, char *location, bool use_secondary_hive, char **reg_data, PDWORD reg_data_size) {
-    LONG rtn_value;
-    HKEY hive = DEFAULT_VK_REGISTRY_HIVE, key;
-    DWORD access_flags;
-    char name[2048];
-    char *loc = location;
-    char *next;
-    DWORD idx;
-    DWORD name_size = sizeof(name);
-    DWORD value;
-    DWORD value_size = sizeof(value);
-    VkResult result = VK_SUCCESS;
-    bool found = false;
-
-    if (NULL == reg_data) {
-        result = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    while (*loc) {
-        next = loader_get_next_path(loc);
-        access_flags = KEY_QUERY_VALUE;
-        rtn_value = RegOpenKeyEx(hive, loc, 0, access_flags, &key);
-        if (ERROR_SUCCESS == rtn_value) {
-            idx = 0;
-            while ((rtn_value = RegEnumValue(key, idx++, name, &name_size, NULL, NULL, (LPBYTE)&value, &value_size)) ==
-                   ERROR_SUCCESS) {
-                if (value_size == sizeof(value) && value == 0) {
-                    if (NULL == *reg_data) {
-                        *reg_data = loader_instance_heap_alloc(inst, *reg_data_size, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-                        if (NULL == *reg_data) {
-                            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                       "loaderGetRegistryFiles: Failed to allocate space for registry data for key %s", name);
-                            RegCloseKey(key);
-                            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-                            goto out;
-                        }
-                        *reg_data[0] = '\0';
-                    } else if (strlen(*reg_data) + name_size + 1 > *reg_data_size) {
-                        void *new_ptr = loader_instance_heap_realloc(inst, *reg_data, *reg_data_size, *reg_data_size * 2,
-                                                                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-                        if (NULL == new_ptr) {
-                            loader_log(
-                                inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                "loaderGetRegistryFiles: Failed to reallocate space for registry value of size %d for key %s",
-                                *reg_data_size * 2, name);
-                            RegCloseKey(key);
-                            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-                            goto out;
-                        }
-                        *reg_data = new_ptr;
-                        *reg_data_size *= 2;
-                    }
-                    loader_log(
-                        inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Located json file \"%s\" from registry \"%s\\%s\"", name,
-                        hive == DEFAULT_VK_REGISTRY_HIVE ? DEFAULT_VK_REGISTRY_HIVE_STR : SECONDARY_VK_REGISTRY_HIVE_STR, location);
-                    if (strlen(*reg_data) == 0) {
-                        (void)snprintf(*reg_data, name_size + 1, "%s", name);
-                    } else {
-                        (void)snprintf(*reg_data + strlen(*reg_data), name_size + 2, "%c%s", PATH_SEPARATOR, name);
-                    }
-                    found = true;
-                }
-                name_size = 2048;
-            }
-            RegCloseKey(key);
-        }
-
-        // Advance the location - if the next location is in the secondary hive, then reset the locations and advance the hive
-        if (use_secondary_hive && (hive == DEFAULT_VK_REGISTRY_HIVE) && (*next == '\0')) {
-            loc = location;
-            hive = SECONDARY_VK_REGISTRY_HIVE;
-        } else {
-            loc = next;
-        }
-    }
-
-    if (!found && result != VK_ERROR_OUT_OF_HOST_MEMORY) {
-        result = VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-out:
-
-    return result;
-}
-
-#endif  // WIN32
-
-// Combine path elements, separating each element with the platform-specific
-// directory separator, and save the combined string to a destination buffer,
-// not exceeding the given length. Path elements are given as variable args,
-// with a NULL element terminating the list.
-//
-// \returns the total length of the combined string, not including an ASCII
-// NUL termination character. This length may exceed the available storage:
-// in this case, the written string will be truncated to avoid a buffer
-// overrun, and the return value will greater than or equal to the storage
-// size. A NULL argument may be provided as the destination buffer in order
-// to determine the required string length without actually writing a string.
-static size_t loader_platform_combine_path(char *dest, size_t len, ...) {
-    size_t required_len = 0;
-    va_list ap;
-    const char *component;
-
-    va_start(ap, len);
-
-    while ((component = va_arg(ap, const char *))) {
-        if (required_len > 0) {
-            // This path element is not the first non-empty element; prepend
-            // a directory separator if space allows
-            if (dest && required_len + 1 < len) {
-                (void)snprintf(dest + required_len, len - required_len, "%c", DIRECTORY_SYMBOL);
-            }
-            required_len++;
-        }
-
-        if (dest && required_len < len) {
-            strncpy(dest + required_len, component, len - required_len);
-        }
-        required_len += strlen(component);
-    }
-
-    va_end(ap);
-
-    // strncpy(3) won't add a NUL terminating byte in the event of truncation.
-    if (dest && required_len >= len) {
-        dest[len - 1] = '\0';
-    }
-
-    return required_len;
-}
-
-// Given string of three part form "maj.min.pat" convert to a vulkan version number.
-static uint32_t loader_make_version(char *vers_str) {
-    uint32_t vers = 0, major = 0, minor = 0, patch = 0;
-    char *vers_tok;
-
-    if (!vers_str) {
-        return vers;
-    }
-
-    vers_tok = strtok(vers_str, ".\"\n\r");
-    if (NULL != vers_tok) {
-        major = (uint16_t)atoi(vers_tok);
-        vers_tok = strtok(NULL, ".\"\n\r");
-        if (NULL != vers_tok) {
-            minor = (uint16_t)atoi(vers_tok);
-            vers_tok = strtok(NULL, ".\"\n\r");
-            if (NULL != vers_tok) {
-                patch = (uint16_t)atoi(vers_tok);
-            }
-        }
-    }
-
-    return VK_MAKE_VERSION(major, minor, patch);
-}
-
-bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2) {
-    return strcmp(op1->extensionName, op2->extensionName) == 0 ? true : false;
-}
-
-// Search the given ext_array for an extension matching the given vk_ext_prop
-bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count,
-                                     const VkExtensionProperties *ext_array) {
-    for (uint32_t i = 0; i < count; i++) {
-        if (compare_vk_extension_properties(vk_ext_prop, &ext_array[i])) return true;
-    }
-    return false;
-}
-
-// Search the given ext_list for an extension matching the given vk_ext_prop
-bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list) {
-    for (uint32_t i = 0; i < ext_list->count; i++) {
-        if (compare_vk_extension_properties(&ext_list->list[i], vk_ext_prop)) return true;
-    }
-    return false;
-}
-
-// Search the given ext_list for a device extension matching the given ext_prop
-bool has_vk_dev_ext_property(const VkExtensionProperties *ext_prop, const struct loader_device_extension_list *ext_list) {
-    for (uint32_t i = 0; i < ext_list->count; i++) {
-        if (compare_vk_extension_properties(&ext_list->list[i].props, ext_prop)) return true;
-    }
-    return false;
-}
-
-// Search the given layer list for a layer matching the given layer name
-static struct loader_layer_properties *loader_get_layer_property(const char *name, const struct loader_layer_list *layer_list) {
-    for (uint32_t i = 0; i < layer_list->count; i++) {
-        const VkLayerProperties *item = &layer_list->list[i].info;
-        if (strcmp(name, item->layerName) == 0) return &layer_list->list[i];
-    }
-    return NULL;
-}
-
-// Get the next unused layer property in the list. Init the property to zero.
-static struct loader_layer_properties *loader_get_next_layer_property(const struct loader_instance *inst,
-                                                                      struct loader_layer_list *layer_list) {
-    if (layer_list->capacity == 0) {
-        layer_list->list =
-            loader_instance_heap_alloc(inst, sizeof(struct loader_layer_properties) * 64, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (layer_list->list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_next_layer_property: Out of memory can "
-                       "not add any layer properties to list");
-            return NULL;
-        }
-        memset(layer_list->list, 0, sizeof(struct loader_layer_properties) * 64);
-        layer_list->capacity = sizeof(struct loader_layer_properties) * 64;
-    }
-
-    // Ensure enough room to add an entry
-    if ((layer_list->count + 1) * sizeof(struct loader_layer_properties) > layer_list->capacity) {
-        void *new_ptr = loader_instance_heap_realloc(inst, layer_list->list, layer_list->capacity, layer_list->capacity * 2,
-                                                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == new_ptr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_next_layer_property: realloc failed for layer list");
-            return NULL;
-        }
-        layer_list->list = new_ptr;
-        layer_list->capacity *= 2;
-    }
-
-    layer_list->count++;
-    return &(layer_list->list[layer_list->count - 1]);
-}
-
-// Remove all layer properties entries from the list
-void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list) {
-    uint32_t i, j, k;
-    struct loader_device_extension_list *dev_ext_list;
-    struct loader_dev_ext_props *ext_props;
-    if (!layer_list) return;
-
-    for (i = 0; i < layer_list->count; i++) {
-        if (NULL != layer_list->list[i].component_layer_names) {
-            loader_instance_heap_free(inst, layer_list->list[i].component_layer_names);
-            layer_list->list[i].component_layer_names = NULL;
-        }
-        loader_destroy_generic_list(inst, (struct loader_generic_list *)&layer_list->list[i].instance_extension_list);
-        dev_ext_list = &layer_list->list[i].device_extension_list;
-        if (dev_ext_list->capacity > 0 && NULL != dev_ext_list->list) {
-            for (j = 0; j < dev_ext_list->count; j++) {
-                ext_props = &dev_ext_list->list[j];
-                if (ext_props->entrypoint_count > 0) {
-                    for (k = 0; k < ext_props->entrypoint_count; k++) {
-                        loader_instance_heap_free(inst, ext_props->entrypoints[k]);
-                    }
-                    loader_instance_heap_free(inst, ext_props->entrypoints);
-                }
-            }
-        }
-        loader_destroy_generic_list(inst, (struct loader_generic_list *)dev_ext_list);
-    }
-    layer_list->count = 0;
-
-    if (layer_list->capacity > 0) {
-        layer_list->capacity = 0;
-        loader_instance_heap_free(inst, layer_list->list);
-    }
-}
-
-static VkResult loader_add_instance_extensions(const struct loader_instance *inst,
-                                               const PFN_vkEnumerateInstanceExtensionProperties fp_get_props, const char *lib_name,
-                                               struct loader_extension_list *ext_list) {
-    uint32_t i, count = 0;
-    VkExtensionProperties *ext_props;
-    VkResult res = VK_SUCCESS;
-
-    if (!fp_get_props) {
-        // No EnumerateInstanceExtensionProperties defined
-        goto out;
-    }
-
-    res = fp_get_props(NULL, &count, NULL);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_instance_extensions: Error getting Instance "
-                   "extension count from %s",
-                   lib_name);
-        goto out;
-    }
-
-    if (count == 0) {
-        // No ExtensionProperties to report
-        goto out;
-    }
-
-    ext_props = loader_stack_alloc(count * sizeof(VkExtensionProperties));
-    if (NULL == ext_props) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    res = fp_get_props(NULL, &count, ext_props);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_instance_extensions: Error getting Instance "
-                   "extensions from %s",
-                   lib_name);
-        goto out;
-    }
-
-    for (i = 0; i < count; i++) {
-        char spec_version[64];
-
-        bool ext_unsupported = wsi_unsupported_instance_extension(&ext_props[i]);
-        if (!ext_unsupported) {
-            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion),
-                           VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion));
-            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Instance Extension: %s (%s) version %s", ext_props[i].extensionName,
-                       lib_name, spec_version);
-
-            res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
-            if (res != VK_SUCCESS) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_instance_extensions: Failed to add %s "
-                           "to Instance extension list",
-                           lib_name);
-                goto out;
-            }
-        }
-    }
-
-out:
-    return res;
-}
-
-// Initialize ext_list with the physical device extensions.
-// The extension properties are passed as inputs in count and ext_props.
-static VkResult loader_init_device_extensions(const struct loader_instance *inst, struct loader_physical_device_term *phys_dev_term,
-                                              uint32_t count, VkExtensionProperties *ext_props,
-                                              struct loader_extension_list *ext_list) {
-    VkResult res;
-    uint32_t i;
-
-    res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties));
-    if (VK_SUCCESS != res) {
-        return res;
-    }
-
-    for (i = 0; i < count; i++) {
-        char spec_version[64];
-        (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion),
-                       VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion));
-        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
-                   phys_dev_term->this_icd_term->scanned_icd->lib_name, spec_version);
-        res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
-        if (res != VK_SUCCESS) return res;
-    }
-
-    return VK_SUCCESS;
-}
-
-VkResult loader_add_device_extensions(const struct loader_instance *inst,
-                                      PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
-                                      VkPhysicalDevice physical_device, const char *lib_name,
-                                      struct loader_extension_list *ext_list) {
-    uint32_t i, count;
-    VkResult res;
-    VkExtensionProperties *ext_props;
-
-    res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, NULL);
-    if (res == VK_SUCCESS && count > 0) {
-        ext_props = loader_stack_alloc(count * sizeof(VkExtensionProperties));
-        if (!ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_device_extensions: Failed to allocate space"
-                       " for device extension properties.");
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        res = fpEnumerateDeviceExtensionProperties(physical_device, NULL, &count, ext_props);
-        if (res != VK_SUCCESS) {
-            return res;
-        }
-        for (i = 0; i < count; i++) {
-            char spec_version[64];
-            (void)snprintf(spec_version, sizeof(spec_version), "%d.%d.%d", VK_VERSION_MAJOR(ext_props[i].specVersion),
-                           VK_VERSION_MINOR(ext_props[i].specVersion), VK_VERSION_PATCH(ext_props[i].specVersion));
-            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Device Extension: %s (%s) version %s", ext_props[i].extensionName,
-                       lib_name, spec_version);
-            res = loader_add_to_ext_list(inst, ext_list, 1, &ext_props[i]);
-            if (res != VK_SUCCESS) {
-                return res;
-            }
-        }
-    } else {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_add_device_extensions: Error getting physical "
-                   "device extension info count from library %s",
-                   lib_name);
-        return res;
-    }
-
-    return VK_SUCCESS;
-}
-
-VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size) {
-    size_t capacity = 32 * element_size;
-    list_info->count = 0;
-    list_info->capacity = 0;
-    list_info->list = loader_instance_heap_alloc(inst, capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (list_info->list == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_init_generic_list: Failed to allocate space "
-                   "for generic list");
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    memset(list_info->list, 0, capacity);
-    list_info->capacity = capacity;
-    return VK_SUCCESS;
-}
-
-void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list) {
-    loader_instance_heap_free(inst, list->list);
-    list->count = 0;
-    list->capacity = 0;
-}
-
-// Append non-duplicate extension properties defined in props to the given ext_list.
-// Return - Vk_SUCCESS on success
-VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
-                                uint32_t prop_list_count, const VkExtensionProperties *props) {
-    uint32_t i;
-    const VkExtensionProperties *cur_ext;
-
-    if (ext_list->list == NULL || ext_list->capacity == 0) {
-        VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(VkExtensionProperties));
-        if (VK_SUCCESS != res) {
-            return res;
-        }
-    }
-
-    for (i = 0; i < prop_list_count; i++) {
-        cur_ext = &props[i];
-
-        // look for duplicates
-        if (has_vk_extension_property(cur_ext, ext_list)) {
-            continue;
-        }
-
-        // add to list at end
-        // check for enough capacity
-        if (ext_list->count * sizeof(VkExtensionProperties) >= ext_list->capacity) {
-            void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
-                                                         VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (new_ptr == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_to_ext_list: Failed to reallocate "
-                           "space for extension list");
-                return VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-            ext_list->list = new_ptr;
-
-            // double capacity
-            ext_list->capacity *= 2;
-        }
-
-        memcpy(&ext_list->list[ext_list->count], cur_ext, sizeof(VkExtensionProperties));
-        ext_list->count++;
-    }
-    return VK_SUCCESS;
-}
-
-// Append one extension property defined in props with entrypoints defined in entries to the given
-// ext_list. Do not append if a duplicate.
-// Return - Vk_SUCCESS on success
-VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
-                                    const VkExtensionProperties *props, uint32_t entry_count, char **entrys) {
-    uint32_t idx;
-    if (ext_list->list == NULL || ext_list->capacity == 0) {
-        VkResult res = loader_init_generic_list(inst, (struct loader_generic_list *)ext_list, sizeof(struct loader_dev_ext_props));
-        if (VK_SUCCESS != res) {
-            return res;
-        }
-    }
-
-    // look for duplicates
-    if (has_vk_dev_ext_property(props, ext_list)) {
-        return VK_SUCCESS;
-    }
-
-    idx = ext_list->count;
-    // add to list at end
-    // check for enough capacity
-    if (idx * sizeof(struct loader_dev_ext_props) >= ext_list->capacity) {
-        void *new_ptr = loader_instance_heap_realloc(inst, ext_list->list, ext_list->capacity, ext_list->capacity * 2,
-                                                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-
-        if (NULL == new_ptr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_to_dev_ext_list: Failed to reallocate space for device extension list");
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        ext_list->list = new_ptr;
-
-        // double capacity
-        ext_list->capacity *= 2;
-    }
-
-    memcpy(&ext_list->list[idx].props, props, sizeof(*props));
-    ext_list->list[idx].entrypoint_count = entry_count;
-    if (entry_count == 0) {
-        ext_list->list[idx].entrypoints = NULL;
-    } else {
-        ext_list->list[idx].entrypoints =
-            loader_instance_heap_alloc(inst, sizeof(char *) * entry_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (ext_list->list[idx].entrypoints == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_to_dev_ext_list: Failed to allocate space "
-                       "for device extension entrypoint list in list %d",
-                       idx);
-            ext_list->list[idx].entrypoint_count = 0;
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        for (uint32_t i = 0; i < entry_count; i++) {
-            ext_list->list[idx].entrypoints[i] =
-                loader_instance_heap_alloc(inst, strlen(entrys[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (ext_list->list[idx].entrypoints[i] == NULL) {
-                for (uint32_t j = 0; j < i; j++) {
-                    loader_instance_heap_free(inst, ext_list->list[idx].entrypoints[j]);
-                }
-                loader_instance_heap_free(inst, ext_list->list[idx].entrypoints);
-                ext_list->list[idx].entrypoint_count = 0;
-                ext_list->list[idx].entrypoints = NULL;
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_to_dev_ext_list: Failed to allocate space "
-                           "for device extension entrypoint %d name",
-                           i);
-                return VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-            strcpy(ext_list->list[idx].entrypoints[i], entrys[i]);
-        }
-    }
-    ext_list->count++;
-
-    return VK_SUCCESS;
-}
-
-// Prototype of loader_add_meta_layer function since we use it in the loader_add_implicit_layer, but can also
-// call loader_add_implicit_layer from loader_add_meta_layer.
-bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop,
-                           struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list,
-                           const struct loader_layer_list *source_list);
-
-// Search the given layer list for a list matching the given VkLayerProperties
-bool has_vk_layer_property(const VkLayerProperties *vk_layer_prop, const struct loader_layer_list *list) {
-    for (uint32_t i = 0; i < list->count; i++) {
-        if (strcmp(vk_layer_prop->layerName, list->list[i].info.layerName) == 0) return true;
-    }
-    return false;
-}
-
-// Search the given layer list for a layer matching the given name
-bool has_layer_name(const char *name, const struct loader_layer_list *list) {
-    for (uint32_t i = 0; i < list->count; i++) {
-        if (strcmp(name, list->list[i].info.layerName) == 0) return true;
-    }
-    return false;
-}
-
-// Search the given search_list for any layers in the props list.  Add these to the
-// output layer_list.  Don't add duplicates to the output layer_list.
-static VkResult loader_add_layer_names_to_list(const struct loader_instance *inst, struct loader_layer_list *output_list,
-                                               struct loader_layer_list *expanded_output_list, uint32_t name_count,
-                                               const char *const *names, const struct loader_layer_list *source_list) {
-    struct loader_layer_properties *layer_prop;
-    VkResult err = VK_SUCCESS;
-
-    for (uint32_t i = 0; i < name_count; i++) {
-        const char *source_name = names[i];
-        layer_prop = loader_get_layer_property(source_name, source_list);
-        if (NULL == layer_prop) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_layer_names_to_list: Unable to find layer"
-                       " %s",
-                       source_name);
-            err = VK_ERROR_LAYER_NOT_PRESENT;
-            continue;
-        }
-
-        // If not a meta-layer, simply add it.
-        if (0 == (layer_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) {
-            if (!has_vk_layer_property(&layer_prop->info, output_list)) {
-                loader_add_to_layer_list(inst, output_list, 1, layer_prop);
-            }
-            if (!has_vk_layer_property(&layer_prop->info, expanded_output_list)) {
-                loader_add_to_layer_list(inst, expanded_output_list, 1, layer_prop);
-            }
-        } else {
-            if (!has_vk_layer_property(&layer_prop->info, output_list) ||
-                !has_vk_layer_property(&layer_prop->info, expanded_output_list)) {
-                loader_add_meta_layer(inst, layer_prop, output_list, expanded_output_list, source_list);
-            }
-        }
-    }
-
-    return err;
-}
-
-// Manage lists of VkLayerProperties
-static bool loader_init_layer_list(const struct loader_instance *inst, struct loader_layer_list *list) {
-    list->capacity = 32 * sizeof(struct loader_layer_properties);
-    list->list = loader_instance_heap_alloc(inst, list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (list->list == NULL) {
-        return false;
-    }
-    memset(list->list, 0, list->capacity);
-    list->count = 0;
-    return true;
-}
-
-void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device,
-                               struct loader_layer_list *layer_list) {
-    if (device) {
-        loader_device_heap_free(device, layer_list->list);
-    } else {
-        loader_instance_heap_free(inst, layer_list->list);
-    }
-    layer_list->count = 0;
-    layer_list->capacity = 0;
-}
-
-// Append non-duplicate layer properties defined in prop_list to the given layer_info list
-VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count,
-                                  const struct loader_layer_properties *props) {
-    uint32_t i;
-    struct loader_layer_properties *layer;
-
-    if (list->list == NULL || list->capacity == 0) {
-        loader_init_layer_list(inst, list);
-    }
-
-    if (list->list == NULL) return VK_SUCCESS;
-
-    for (i = 0; i < prop_list_count; i++) {
-        layer = (struct loader_layer_properties *)&props[i];
-
-        // Look for duplicates, and skip
-        if (has_vk_layer_property(&layer->info, list)) {
-            continue;
-        }
-
-        // Check for enough capacity
-        if (((list->count + 1) * sizeof(struct loader_layer_properties)) >= list->capacity) {
-            size_t new_capacity = list->capacity * 2;
-            void *new_ptr =
-                loader_instance_heap_realloc(inst, list->list, list->capacity, new_capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (NULL == new_ptr) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_to_layer_list: Realloc failed for when attempting to add new layer");
-                return VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-            list->list = new_ptr;
-            list->capacity = new_capacity;
-        }
-
-        memcpy(&list->list[list->count], layer, sizeof(struct loader_layer_properties));
-        list->count++;
-    }
-
-    return VK_SUCCESS;
-}
-
-// Check the individual implicit layer for the enable/disable environment variable settings.  Only add it after
-// every check has passed indicating it should be used.
-static void loader_add_implicit_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop,
-                                      struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list,
-                                      const struct loader_layer_list *source_list) {
-    bool enable = loader_is_implicit_layer_enabled(inst, prop);
-    if (enable) {
-        if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) {
-            if (NULL != target_list && !has_vk_layer_property(&prop->info, target_list)) {
-                loader_add_to_layer_list(inst, target_list, 1, prop);
-            }
-            if (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list)) {
-                loader_add_to_layer_list(inst, expanded_target_list, 1, prop);
-            }
-        } else {
-            if (!has_vk_layer_property(&prop->info, target_list) ||
-                (NULL != expanded_target_list && !has_vk_layer_property(&prop->info, expanded_target_list))) {
-                loader_add_meta_layer(inst, prop, target_list, expanded_target_list, source_list);
-            }
-        }
-    }
-}
-
-// Add the component layers of a meta-layer to the active list of layers
-bool loader_add_meta_layer(const struct loader_instance *inst, const struct loader_layer_properties *prop,
-                           struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list,
-                           const struct loader_layer_list *source_list) {
-    bool found = true;
-
-    // We need to add all the individual component layers
-    for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) {
-        bool found_comp = false;
-        const struct loader_layer_properties *search_prop =
-            loader_get_layer_property(prop->component_layer_names[comp_layer], source_list);
-        if (search_prop != NULL) {
-            found_comp = true;
-
-            // If the component layer is itself an implicit layer, we need to do the implicit layer enable
-            // checks
-            if (0 == (search_prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) {
-                loader_add_implicit_layer(inst, search_prop, target_list, expanded_target_list, source_list);
-            } else {
-                if (NULL != expanded_target_list && !has_vk_layer_property(&search_prop->info, expanded_target_list)) {
-                    loader_add_to_layer_list(inst, expanded_target_list, 1, search_prop);
-                }
-            }
-        }
-        if (!found_comp) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_add_meta_layer: Failed to find layer name %s component layer "
-                       "%s to activate",
-                       search_prop->info.layerName, prop->component_layer_names[comp_layer]);
-            found = false;
-        }
-    }
-
-    // Add this layer to the overall target list (not the expanded one)
-    if (found && !has_vk_layer_property(&prop->info, target_list)) {
-        loader_add_to_layer_list(inst, target_list, 1, prop);
-    }
-
-    return found;
-}
-
-// Search the source_list for any layer with a name that matches the given name and a type
-// that matches the given type.  Add all matching layers to the target_list.
-// Do not add if found loader_layer_properties is already on the target_list.
-void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags,
-                                     const struct loader_layer_list *source_list, struct loader_layer_list *target_list,
-                                     struct loader_layer_list *expanded_target_list) {
-    bool found = false;
-    for (uint32_t i = 0; i < source_list->count; i++) {
-        struct loader_layer_properties *source_prop = &source_list->list[i];
-        if (0 == strcmp(source_prop->info.layerName, name) && (source_prop->type_flags & type_flags) == type_flags) {
-            // If not a meta-layer, simply add it.
-            if (0 == (source_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER)) {
-                if (NULL != target_list && !has_vk_layer_property(&source_prop->info, target_list) &&
-                    VK_SUCCESS == loader_add_to_layer_list(inst, target_list, 1, source_prop)) {
-                    found = true;
-                }
-                if (NULL != expanded_target_list && !has_vk_layer_property(&source_prop->info, expanded_target_list) &&
-                    VK_SUCCESS == loader_add_to_layer_list(inst, expanded_target_list, 1, source_prop)) {
-                    found = true;
-                }
-            } else {
-                found = loader_add_meta_layer(inst, source_prop, target_list, expanded_target_list, source_list);
-            }
-        }
-    }
-    if (!found) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "loader_find_layer_name_add_list: Failed to find layer name %s to activate", name);
-    }
-}
-
-static VkExtensionProperties *get_extension_property(const char *name, const struct loader_extension_list *list) {
-    for (uint32_t i = 0; i < list->count; i++) {
-        if (strcmp(name, list->list[i].extensionName) == 0) return &list->list[i];
-    }
-    return NULL;
-}
-
-static VkExtensionProperties *get_dev_extension_property(const char *name, const struct loader_device_extension_list *list) {
-    for (uint32_t i = 0; i < list->count; i++) {
-        if (strcmp(name, list->list[i].props.extensionName) == 0) return &list->list[i].props;
-    }
-    return NULL;
-}
-
-// For Instance extensions implemented within the loader (i.e. DEBUG_REPORT
-// the extension must provide two entry points for the loader to use:
-// - "trampoline" entry point - this is the address returned by GetProcAddr
-//                              and will always do what's necessary to support a
-//                              global call.
-// - "terminator" function    - this function will be put at the end of the
-//                              instance chain and will contain the necessary logic
-//                              to call / process the extension for the appropriate
-//                              ICDs that are available.
-// There is no generic mechanism for including these functions, the references
-// must be placed into the appropriate loader entry points.
-// GetInstanceProcAddr: call extension GetInstanceProcAddr to check for GetProcAddr
-// requests
-// loader_coalesce_extensions(void) - add extension records to the list of global
-//                                    extension available to the app.
-// instance_disp                    - add function pointer for terminator function
-//                                    to this array.
-// The extension itself should be in a separate file that will be linked directly
-// with the loader.
-VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
-                                                   struct loader_extension_list *inst_exts) {
-    struct loader_extension_list icd_exts;
-    VkResult res = VK_SUCCESS;
-    char *env_value;
-    bool filter_extensions = true;
-
-    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list");
-
-    // Check if a user wants to disable the instance extension filtering behavior
-    env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst);
-    if (NULL != env_value && atoi(env_value) != 0) {
-        filter_extensions = false;
-    }
-    loader_free_getenv(env_value, inst);
-
-    // traverse scanned icd list adding non-duplicate extensions to the list
-    for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
-        res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
-        if (VK_SUCCESS != res) {
-            goto out;
-        }
-        res = loader_add_instance_extensions(inst, icd_tramp_list->scanned_list[i].EnumerateInstanceExtensionProperties,
-                                             icd_tramp_list->scanned_list[i].lib_name, &icd_exts);
-        if (VK_SUCCESS == res) {
-            if (filter_extensions) {
-                // Remove any extensions not recognized by the loader
-                for (int32_t j = 0; j < (int32_t)icd_exts.count; j++) {
-                    // See if the extension is in the list of supported extensions
-                    bool found = false;
-                    for (uint32_t k = 0; LOADER_INSTANCE_EXTENSIONS[k] != NULL; k++) {
-                        if (strcmp(icd_exts.list[j].extensionName, LOADER_INSTANCE_EXTENSIONS[k]) == 0) {
-                            found = true;
-                            break;
-                        }
-                    }
-
-                    // If it isn't in the list, remove it
-                    if (!found) {
-                        for (uint32_t k = j + 1; k < icd_exts.count; k++) {
-                            icd_exts.list[k - 1] = icd_exts.list[k];
-                        }
-                        --icd_exts.count;
-                        --j;
-                    }
-                }
-            }
-
-            res = loader_add_to_ext_list(inst, inst_exts, icd_exts.count, icd_exts.list);
-        }
-        loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
-        if (VK_SUCCESS != res) {
-            goto out;
-        }
-    };
-
-    // Traverse loader's extensions, adding non-duplicate extensions to the list
-    debug_report_add_instance_extensions(inst, inst_exts);
-
-out:
-    return res;
-}
-
-struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index) {
-    *found_dev = NULL;
-    for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
-        uint32_t index = 0;
-        for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term; icd_term = icd_term->next) {
-            for (struct loader_device *dev = icd_term->logical_device_list; dev; dev = dev->next)
-                // Value comparison of device prevents object wrapping by layers
-                if (loader_get_dispatch(dev->icd_device) == loader_get_dispatch(device) ||
-                    loader_get_dispatch(dev->chain_device) == loader_get_dispatch(device)) {
-                    *found_dev = dev;
-                    if (NULL != icd_index) {
-                        *icd_index = index;
-                    }
-                    return icd_term;
-                }
-            index++;
-        }
-    }
-    return NULL;
-}
-
-void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev,
-                                   const VkAllocationCallbacks *pAllocator) {
-    if (pAllocator) {
-        dev->alloc_callbacks = *pAllocator;
-    }
-    if (NULL != dev->expanded_activated_layer_list.list) {
-        loader_deactivate_layers(inst, dev, &dev->expanded_activated_layer_list);
-    }
-    if (NULL != dev->app_activated_layer_list.list) {
-        loader_destroy_layer_list(inst, dev, &dev->app_activated_layer_list);
-    }
-    loader_device_heap_free(dev, dev);
-}
-
-struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator) {
-    struct loader_device *new_dev;
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator) {
-        new_dev = (struct loader_device *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_device),
-                                                                    sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
-    } else {
-#endif
-        new_dev = (struct loader_device *)malloc(sizeof(struct loader_device));
-    }
-
-    if (!new_dev) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_logical_device: Failed to alloc struct "
-                   "loader_device");
-        return NULL;
-    }
-
-    memset(new_dev, 0, sizeof(struct loader_device));
-    if (pAllocator) {
-        new_dev->alloc_callbacks = *pAllocator;
-    }
-
-    return new_dev;
-}
-
-void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term, struct loader_device *dev) {
-    dev->next = icd_term->logical_device_list;
-    icd_term->logical_device_list = dev;
-}
-
-void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
-                                  struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator) {
-    struct loader_device *dev, *prev_dev;
-
-    if (!icd_term || !found_dev) return;
-
-    prev_dev = NULL;
-    dev = icd_term->logical_device_list;
-    while (dev && dev != found_dev) {
-        prev_dev = dev;
-        dev = dev->next;
-    }
-
-    if (prev_dev)
-        prev_dev->next = found_dev->next;
-    else
-        icd_term->logical_device_list = found_dev->next;
-    loader_destroy_logical_device(inst, found_dev, pAllocator);
-}
-
-static void loader_icd_destroy(struct loader_instance *ptr_inst, struct loader_icd_term *icd_term,
-                               const VkAllocationCallbacks *pAllocator) {
-    ptr_inst->total_icd_count--;
-    for (struct loader_device *dev = icd_term->logical_device_list; dev;) {
-        struct loader_device *next_dev = dev->next;
-        loader_destroy_logical_device(ptr_inst, dev, pAllocator);
-        dev = next_dev;
-    }
-
-    loader_instance_heap_free(ptr_inst, icd_term);
-}
-
-static struct loader_icd_term *loader_icd_create(const struct loader_instance *inst) {
-    struct loader_icd_term *icd_term;
-
-    icd_term = loader_instance_heap_alloc(inst, sizeof(struct loader_icd_term), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (!icd_term) {
-        return NULL;
-    }
-
-    memset(icd_term, 0, sizeof(struct loader_icd_term));
-
-    return icd_term;
-}
-
-static struct loader_icd_term *loader_icd_add(struct loader_instance *ptr_inst, const struct loader_scanned_icd *scanned_icd) {
-    struct loader_icd_term *icd_term;
-
-    icd_term = loader_icd_create(ptr_inst);
-    if (!icd_term) {
-        return NULL;
-    }
-
-    icd_term->scanned_icd = scanned_icd;
-    icd_term->this_instance = ptr_inst;
-
-    // Prepend to the list
-    icd_term->next = ptr_inst->icd_terms;
-    ptr_inst->icd_terms = icd_term;
-    ptr_inst->total_icd_count++;
-
-    return icd_term;
-}
-
-// Determine the ICD interface version to use.
-//     @param icd
-//     @param pVersion Output parameter indicating which version to use or 0 if
-//            the negotiation API is not supported by the ICD
-//     @return  bool indicating true if the selected interface version is supported
-//            by the loader, false indicates the version is not supported
-bool loader_get_icd_interface_version(PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version, uint32_t *pVersion) {
-    if (fp_negotiate_icd_version == NULL) {
-        // ICD does not support the negotiation API, it supports version 0 or 1
-        // calling code must determine if it is version 0 or 1
-        *pVersion = 0;
-    } else {
-        // ICD supports the negotiation API, so call it with the loader's
-        // latest version supported
-        *pVersion = CURRENT_LOADER_ICD_INTERFACE_VERSION;
-        VkResult result = fp_negotiate_icd_version(pVersion);
-
-        if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
-            // ICD no longer supports the loader's latest interface version so
-            // fail loading the ICD
-            return false;
-        }
-    }
-
-#if MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION > 0
-    if (*pVersion < MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION) {
-        // Loader no longer supports the ICD's latest interface version so fail
-        // loading the ICD
-        return false;
-    }
-#endif
-    return true;
-}
-
-void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
-    if (0 != icd_tramp_list->capacity) {
-        for (uint32_t i = 0; i < icd_tramp_list->count; i++) {
-            loader_platform_close_library(icd_tramp_list->scanned_list[i].handle);
-            loader_instance_heap_free(inst, icd_tramp_list->scanned_list[i].lib_name);
-        }
-        loader_instance_heap_free(inst, icd_tramp_list->scanned_list);
-        icd_tramp_list->capacity = 0;
-        icd_tramp_list->count = 0;
-        icd_tramp_list->scanned_list = NULL;
-    }
-}
-
-static VkResult loader_scanned_icd_init(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
-    VkResult err = VK_SUCCESS;
-    loader_scanned_icd_clear(inst, icd_tramp_list);
-    icd_tramp_list->capacity = 8 * sizeof(struct loader_scanned_icd);
-    icd_tramp_list->scanned_list = loader_instance_heap_alloc(inst, icd_tramp_list->capacity, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == icd_tramp_list->scanned_list) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_scanned_icd_init: Realloc failed for layer list when "
-                   "attempting to add new layer");
-        err = VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    return err;
-}
-
-static VkResult loader_scanned_icd_add(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
-                                       const char *filename, uint32_t api_version) {
-    loader_platform_dl_handle handle;
-    PFN_vkCreateInstance fp_create_inst;
-    PFN_vkEnumerateInstanceExtensionProperties fp_get_inst_ext_props;
-    PFN_vkGetInstanceProcAddr fp_get_proc_addr;
-    PFN_GetPhysicalDeviceProcAddr fp_get_phys_dev_proc_addr = NULL;
-    PFN_vkNegotiateLoaderICDInterfaceVersion fp_negotiate_icd_version;
-    struct loader_scanned_icd *new_scanned_icd;
-    uint32_t interface_vers;
-    VkResult res = VK_SUCCESS;
-
-    // TODO implement smarter opening/closing of libraries. For now this
-    // function leaves libraries open and the scanned_icd_clear closes them
-    handle = loader_platform_open_library(filename);
-    if (NULL == handle) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(filename));
-        goto out;
-    }
-
-    // Get and settle on an ICD interface version
-    fp_negotiate_icd_version = loader_platform_get_proc_address(handle, "vk_icdNegotiateLoaderICDInterfaceVersion");
-
-    if (!loader_get_icd_interface_version(fp_negotiate_icd_version, &interface_vers)) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_scanned_icd_add: ICD %s doesn't support interface"
-                   " version compatible with loader, skip this ICD.",
-                   filename);
-        goto out;
-    }
-
-    fp_get_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetInstanceProcAddr");
-    if (NULL == fp_get_proc_addr) {
-        assert(interface_vers == 0);
-        // Use deprecated interface from version 0
-        fp_get_proc_addr = loader_platform_get_proc_address(handle, "vkGetInstanceProcAddr");
-        if (NULL == fp_get_proc_addr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Attempt to retrieve either "
-                       "\'vkGetInstanceProcAddr\' or "
-                       "\'vk_icdGetInstanceProcAddr\' from ICD %s failed.",
-                       filename);
-            goto out;
-        } else {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Using deprecated ICD "
-                       "interface of \'vkGetInstanceProcAddr\' instead of "
-                       "\'vk_icdGetInstanceProcAddr\' for ICD %s",
-                       filename);
-        }
-        fp_create_inst = loader_platform_get_proc_address(handle, "vkCreateInstance");
-        if (NULL == fp_create_inst) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add:  Failed querying "
-                       "\'vkCreateInstance\' via dlsym/loadlibrary for "
-                       "ICD %s",
-                       filename);
-            goto out;
-        }
-        fp_get_inst_ext_props = loader_platform_get_proc_address(handle, "vkEnumerateInstanceExtensionProperties");
-        if (NULL == fp_get_inst_ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get \'vkEnumerate"
-                       "InstanceExtensionProperties\' via dlsym/loadlibrary "
-                       "for ICD %s",
-                       filename);
-            goto out;
-        }
-    } else {
-        // Use newer interface version 1 or later
-        if (interface_vers == 0) {
-            interface_vers = 1;
-        }
-
-        fp_create_inst = (PFN_vkCreateInstance)fp_get_proc_addr(NULL, "vkCreateInstance");
-        if (NULL == fp_create_inst) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get "
-                       "\'vkCreateInstance\' via \'vk_icdGetInstanceProcAddr\'"
-                       " for ICD %s",
-                       filename);
-            goto out;
-        }
-        fp_get_inst_ext_props =
-            (PFN_vkEnumerateInstanceExtensionProperties)fp_get_proc_addr(NULL, "vkEnumerateInstanceExtensionProperties");
-        if (NULL == fp_get_inst_ext_props) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Could not get \'vkEnumerate"
-                       "InstanceExtensionProperties\' via "
-                       "\'vk_icdGetInstanceProcAddr\' for ICD %s",
-                       filename);
-            goto out;
-        }
-        fp_get_phys_dev_proc_addr = loader_platform_get_proc_address(handle, "vk_icdGetPhysicalDeviceProcAddr");
-    }
-
-    // check for enough capacity
-    if ((icd_tramp_list->count * sizeof(struct loader_scanned_icd)) >= icd_tramp_list->capacity) {
-        void *new_ptr = loader_instance_heap_realloc(inst, icd_tramp_list->scanned_list, icd_tramp_list->capacity,
-                                                     icd_tramp_list->capacity * 2, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == new_ptr) {
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_scanned_icd_add: Realloc failed on icd library list for ICD %s", filename);
-            goto out;
-        }
-        icd_tramp_list->scanned_list = new_ptr;
-
-        // double capacity
-        icd_tramp_list->capacity *= 2;
-    }
-
-    new_scanned_icd = &(icd_tramp_list->scanned_list[icd_tramp_list->count]);
-    new_scanned_icd->handle = handle;
-    new_scanned_icd->api_version = api_version;
-    new_scanned_icd->GetInstanceProcAddr = fp_get_proc_addr;
-    new_scanned_icd->GetPhysicalDeviceProcAddr = fp_get_phys_dev_proc_addr;
-    new_scanned_icd->EnumerateInstanceExtensionProperties = fp_get_inst_ext_props;
-    new_scanned_icd->CreateInstance = fp_create_inst;
-    new_scanned_icd->interface_version = interface_vers;
-
-    new_scanned_icd->lib_name = (char *)loader_instance_heap_alloc(inst, strlen(filename) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == new_scanned_icd->lib_name) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_scanned_icd_add: Out of memory can't add ICD %s", filename);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    strcpy(new_scanned_icd->lib_name, filename);
-    icd_tramp_list->count++;
-
-out:
-
-    return res;
-}
-
-static void loader_debug_init(void) {
-    char *env, *orig;
-
-    if (g_loader_debug > 0) return;
-
-    g_loader_debug = 0;
-
-    // Parse comma-separated debug options
-    orig = env = loader_getenv("VK_LOADER_DEBUG", NULL);
-    while (env) {
-        char *p = strchr(env, ',');
-        size_t len;
-
-        if (p)
-            len = p - env;
-        else
-            len = strlen(env);
-
-        if (len > 0) {
-            if (strncmp(env, "all", len) == 0) {
-                g_loader_debug = ~0u;
-                g_loader_log_msgs = ~0u;
-            } else if (strncmp(env, "warn", len) == 0) {
-                g_loader_debug |= LOADER_WARN_BIT;
-                g_loader_log_msgs |= VK_DEBUG_REPORT_WARNING_BIT_EXT;
-            } else if (strncmp(env, "info", len) == 0) {
-                g_loader_debug |= LOADER_INFO_BIT;
-                g_loader_log_msgs |= VK_DEBUG_REPORT_INFORMATION_BIT_EXT;
-            } else if (strncmp(env, "perf", len) == 0) {
-                g_loader_debug |= LOADER_PERF_BIT;
-                g_loader_log_msgs |= VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
-            } else if (strncmp(env, "error", len) == 0) {
-                g_loader_debug |= LOADER_ERROR_BIT;
-                g_loader_log_msgs |= VK_DEBUG_REPORT_ERROR_BIT_EXT;
-            } else if (strncmp(env, "debug", len) == 0) {
-                g_loader_debug |= LOADER_DEBUG_BIT;
-                g_loader_log_msgs |= VK_DEBUG_REPORT_DEBUG_BIT_EXT;
-            }
-        }
-
-        if (!p) break;
-
-        env = p + 1;
-    }
-
-    loader_free_getenv(orig, NULL);
-}
-
-void loader_initialize(void) {
-    // initialize mutexs
-    loader_platform_thread_create_mutex(&loader_lock);
-    loader_platform_thread_create_mutex(&loader_json_lock);
-
-    // initialize logging
-    loader_debug_init();
-
-    // initial cJSON to use alloc callbacks
-    cJSON_Hooks alloc_fns = {
-        .malloc_fn = loader_instance_tls_heap_alloc, .free_fn = loader_instance_tls_heap_free,
-    };
-    cJSON_InitHooks(&alloc_fns);
-}
-
-struct loader_manifest_files {
-    uint32_t count;
-    char **filename_list;
-};
-
-void loader_release() {
-    // release mutexs
-    loader_platform_thread_delete_mutex(&loader_lock);
-    loader_platform_thread_delete_mutex(&loader_json_lock);
-}
-
-// Get next file or dirname given a string list or registry key path
-//
-// \returns
-// A pointer to first char in the next path.
-// The next path (or NULL) in the list is returned in next_path.
-// Note: input string is modified in some cases. PASS IN A COPY!
-static char *loader_get_next_path(char *path) {
-    uint32_t len;
-    char *next;
-
-    if (path == NULL) return NULL;
-    next = strchr(path, PATH_SEPARATOR);
-    if (next == NULL) {
-        len = (uint32_t)strlen(path);
-        next = path + len;
-    } else {
-        *next = '\0';
-        next++;
-    }
-
-    return next;
-}
-
-// Given a path which is absolute or relative, expand the path if relative or
-// leave the path unmodified if absolute. The base path to prepend to relative
-// paths is given in rel_base.
-//
-// @return - A string in out_fullpath of the full absolute path
-static void loader_expand_path(const char *path, const char *rel_base, size_t out_size, char *out_fullpath) {
-    if (loader_platform_is_path_absolute(path)) {
-        // do not prepend a base to an absolute path
-        rel_base = "";
-    }
-
-    loader_platform_combine_path(out_fullpath, out_size, rel_base, path, NULL);
-}
-
-// Given a filename (file)  and a list of paths (dir), try to find an existing
-// file in the paths.  If filename already is a path then no searching in the given paths.
-//
-// @return - A string in out_fullpath of either the full path or file.
-static void loader_get_fullpath(const char *file, const char *dirs, size_t out_size, char *out_fullpath) {
-    if (!loader_platform_is_path(file) && *dirs) {
-        char *dirs_copy, *dir, *next_dir;
-
-        dirs_copy = loader_stack_alloc(strlen(dirs) + 1);
-        strcpy(dirs_copy, dirs);
-
-        // find if file exists after prepending paths in given list
-        for (dir = dirs_copy; *dir && (next_dir = loader_get_next_path(dir)); dir = next_dir) {
-            loader_platform_combine_path(out_fullpath, out_size, dir, file, NULL);
-            if (loader_platform_file_exists(out_fullpath)) {
-                return;
-            }
-        }
-    }
-
-    (void)snprintf(out_fullpath, out_size, "%s", file);
-}
-
-// Read a JSON file into a buffer.
-//
-// @return -  A pointer to a cJSON object representing the JSON parse tree.
-//            This returned buffer should be freed by caller.
-static VkResult loader_get_json(const struct loader_instance *inst, const char *filename, cJSON **json) {
-    FILE *file = NULL;
-    char *json_buf;
-    size_t len;
-    VkResult res = VK_SUCCESS;
-
-    if (NULL == json) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Received invalid JSON file");
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    *json = NULL;
-
-    file = fopen(filename, "rb");
-    if (!file) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to open JSON file %s", filename);
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-    fseek(file, 0, SEEK_END);
-    len = ftell(file);
-    fseek(file, 0, SEEK_SET);
-    json_buf = (char *)loader_stack_alloc(len + 1);
-    if (json_buf == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to allocate space for "
-                   "JSON file %s buffer of length %d",
-                   filename, len);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    if (fread(json_buf, sizeof(char), len, file) != len) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_get_json: Failed to read JSON file %s.", filename);
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-    json_buf[len] = '\0';
-
-    // Parse text from file
-    *json = cJSON_Parse(json_buf);
-    if (*json == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_json: Failed to parse JSON file %s, "
-                   "this is usually because something ran out of "
-                   "memory.",
-                   filename);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-out:
-    if (NULL != file) {
-        fclose(file);
-    }
-
-    return res;
-}
-
-// Do a deep copy of the loader_layer_properties structure.
-VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst,
-                                      struct loader_layer_properties *src) {
-    uint32_t cnt, i;
-    memcpy(dst, src, sizeof(*src));
-    dst->instance_extension_list.list = loader_instance_heap_alloc(
-        inst, sizeof(VkExtensionProperties) * src->instance_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == dst->instance_extension_list.list) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_copy_layer_properties: Failed to allocate space "
-                   "for instance extension list of size %d.",
-                   src->instance_extension_list.count);
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    dst->instance_extension_list.capacity = sizeof(VkExtensionProperties) * src->instance_extension_list.count;
-    memcpy(dst->instance_extension_list.list, src->instance_extension_list.list, dst->instance_extension_list.capacity);
-    dst->device_extension_list.list = loader_instance_heap_alloc(
-        inst, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == dst->device_extension_list.list) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_copy_layer_properties: Failed to allocate space "
-                   "for device extension list of size %d.",
-                   src->device_extension_list.count);
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    memset(dst->device_extension_list.list, 0, sizeof(struct loader_dev_ext_props) * src->device_extension_list.count);
-
-    dst->device_extension_list.capacity = sizeof(struct loader_dev_ext_props) * src->device_extension_list.count;
-    memcpy(dst->device_extension_list.list, src->device_extension_list.list, dst->device_extension_list.capacity);
-    if (src->device_extension_list.count > 0 && src->device_extension_list.list->entrypoint_count > 0) {
-        cnt = src->device_extension_list.list->entrypoint_count;
-        dst->device_extension_list.list->entrypoints =
-            loader_instance_heap_alloc(inst, sizeof(char *) * cnt, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == dst->device_extension_list.list->entrypoints) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_copy_layer_properties: Failed to allocate space "
-                       "for device extension entrypoint list of size %d.",
-                       cnt);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-        memset(dst->device_extension_list.list->entrypoints, 0, sizeof(char *) * cnt);
-
-        for (i = 0; i < cnt; i++) {
-            dst->device_extension_list.list->entrypoints[i] = loader_instance_heap_alloc(
-                inst, strlen(src->device_extension_list.list->entrypoints[i]) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (NULL == dst->device_extension_list.list->entrypoints[i]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_copy_layer_properties: Failed to "
-                           "allocate space for device extension entrypoint "
-                           "%d name of length",
-                           i);
-                return VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-            strcpy(dst->device_extension_list.list->entrypoints[i], src->device_extension_list.list->entrypoints[i]);
-        }
-    }
-
-    return VK_SUCCESS;
-}
-
-static bool loader_find_layer_name_list(const char *name, const struct loader_layer_list *layer_list) {
-    if (NULL == layer_list) {
-        return false;
-    }
-    for (uint32_t j = 0; j < layer_list->count; j++) {
-        if (!strcmp(name, layer_list->list[j].info.layerName)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]) {
-    if (!layer_list) return false;
-    for (uint32_t j = 0; j < layer_count; j++)
-        if (!strcmp(name, layer_list[j])) return true;
-    return false;
-}
-
-const char *std_validation_str = "VK_LAYER_LUNARG_standard_validation";
-
-// Adds the legacy VK_LAYER_LUNARG_standard_validation as a meta-layer if it
-// fails to find it in the list already.  This is usually an indication that a
-// newer loader is being used with an older layer set.
-static bool loader_add_legacy_std_val_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list) {
-    uint32_t i;
-    bool success = true;
-    struct loader_layer_properties *props = loader_get_next_layer_property(inst, layer_instance_list);
-    const char std_validation_names[6][VK_MAX_EXTENSION_NAME_SIZE] = {
-        "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker",
-        "VK_LAYER_LUNARG_core_validation", "VK_LAYER_GOOGLE_unique_objects"};
-    uint32_t layer_count = sizeof(std_validation_names) / sizeof(std_validation_names[0]);
-
-    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-               "Adding VK_LAYER_LUNARG_standard_validation using the loader legacy path.  This is"
-               " not an error.");
-
-    if (NULL == props) {
-        goto out;
-    }
-
-    memset(props, 0, sizeof(struct loader_layer_properties));
-    props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER | VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER | VK_LAYER_TYPE_FLAG_META_LAYER;
-    strncpy(props->info.description, "LunarG Standard Validation Layer", sizeof(props->info.description));
-    props->info.implementationVersion = 1;
-    strncpy(props->info.layerName, std_validation_str, sizeof(props->info.layerName));
-    props->info.specVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION);
-
-    props->component_layer_names =
-        loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * layer_count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == props->component_layer_names) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "Failed to allocate space for legacy VK_LAYER_LUNARG_standard_validation"
-                   " meta-layer component_layers information.");
-        success = false;
-        goto out;
-    }
-    for (i = 0; i < layer_count; i++) {
-        strncpy(props->component_layer_names[i], std_validation_names[i], MAX_STRING_SIZE - 1);
-        props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0';
-    }
-
-out:
-
-    if (!success && NULL != props && NULL != props->component_layer_names) {
-        loader_instance_heap_free(inst, props->component_layer_names);
-        props->component_layer_names = NULL;
-    }
-
-    return success;
-}
-
-// Verify that all component layers in a meta-layer are valid.
-static bool verify_meta_layer_comp_layers(const struct loader_instance *inst, struct loader_layer_properties *prop,
-                                          struct loader_layer_list *instance_layers) {
-    bool success = true;
-    const uint32_t expected_major = VK_VERSION_MAJOR(prop->info.specVersion);
-    const uint32_t expected_minor = VK_VERSION_MINOR(prop->info.specVersion);
-
-    for (uint32_t comp_layer = 0; comp_layer < prop->num_component_layers; comp_layer++) {
-        if (!loader_find_layer_name_list(prop->component_layer_names[comp_layer], instance_layers)) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Meta-layer %s can't find component layer %s at index %d."
-                       "  Skipping this layer.",
-                       prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer);
-            success = false;
-            break;
-        } else {
-            struct loader_layer_properties *comp_prop =
-                loader_get_layer_property(prop->component_layer_names[comp_layer], instance_layers);
-            if (comp_prop == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Meta-layer %s can't find property for component layer %s at index %d."
-                           "  Skipping this layer.",
-                           prop->info.layerName, prop->component_layer_names[comp_layer], comp_layer);
-                success = false;
-                break;
-            }
-
-            // Check the version of each layer, they need to at least match MAJOR and MINOR
-            uint32_t cur_major = VK_VERSION_MAJOR(comp_prop->info.specVersion);
-            uint32_t cur_minor = VK_VERSION_MINOR(comp_prop->info.specVersion);
-            if (cur_major != expected_major || cur_minor != expected_minor) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Meta-layer uses API version %d.%d, but component layer %d uses API "
-                           "version %d.%d.  Skipping this layer.",
-                           expected_major, expected_minor, comp_layer, cur_major, cur_minor);
-                success = false;
-                break;
-            }
-
-            // Make sure the layer isn't using it's own name
-            if (!strcmp(prop->info.layerName, prop->component_layer_names[comp_layer])) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Meta-layer %s lists itself in its component layer list at index %d."
-                           "  Skipping this layer.",
-                           prop->info.layerName, comp_layer);
-                success = false;
-                break;
-            }
-            if (comp_prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) {
-                loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                           "verify_meta_layer_comp_layers: Adding meta-layer %s which also contains meta-layer %s",
-                           prop->info.layerName, comp_prop->info.layerName);
-
-                // Make sure if the layer is using a meta-layer in its component list that we also verify that.
-                if (!verify_meta_layer_comp_layers(inst, comp_prop, instance_layers)) {
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "Meta-layer %s component layer %s can not find all component layers."
-                               "  Skipping this layer.",
-                               prop->info.layerName, prop->component_layer_names[comp_layer]);
-                    success = false;
-                    break;
-                }
-            }
-
-            // Add any instance and device extensions from component layers to this layer
-            // list, so that anyone querying extensions will only need to look at the meta-layer
-            for (uint32_t ext = 0; ext < comp_prop->instance_extension_list.count; ext++) {
-                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding instance extension %s",
-                           prop->info.layerName, prop->component_layer_names[comp_layer],
-                           comp_prop->instance_extension_list.list[ext].extensionName);
-                if (!has_vk_extension_property(&comp_prop->instance_extension_list.list[ext], &prop->instance_extension_list)) {
-                    loader_add_to_ext_list(inst, &prop->instance_extension_list, 1, &comp_prop->instance_extension_list.list[ext]);
-                }
-            }
-
-            for (uint32_t ext = 0; ext < comp_prop->device_extension_list.count; ext++) {
-                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Meta-layer %s component layer %s adding device extension %s",
-                           prop->info.layerName, prop->component_layer_names[comp_layer],
-                           comp_prop->device_extension_list.list[ext].props.extensionName);
-                if (!has_vk_dev_ext_property(&comp_prop->device_extension_list.list[ext].props, &prop->device_extension_list)) {
-                    loader_add_to_dev_ext_list(inst, &prop->device_extension_list,
-                                               &comp_prop->device_extension_list.list[ext].props, 0, NULL);
-                }
-            }
-        }
-    }
-    if (success) {
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Meta-layer %s all %d component layers appear to be valid.",
-                   prop->info.layerName, prop->num_component_layers);
-    }
-    return success;
-}
-
-// Verify that all meta-layers in a layer list are valid.
-static void verify_all_meta_layers(const struct loader_instance *inst, struct loader_layer_list *instance_layers) {
-    for (int32_t i = 0; i < (int32_t)instance_layers->count; i++) {
-        struct loader_layer_properties *prop = &instance_layers->list[i];
-
-        // If this is a meta-layer, make sure it is valid
-        if ((prop->type_flags & VK_LAYER_TYPE_FLAG_META_LAYER) && !verify_meta_layer_comp_layers(inst, prop, instance_layers)) {
-            loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                       "Removing meta-layer %s from instance layer list since it appears invalid.", prop->info.layerName);
-
-            // Delete the component layers
-            loader_instance_heap_free(inst, prop->component_layer_names);
-
-            // Remove the current invalid meta-layer from the layer list.  Use memmove since we are
-            // overlapping the source and destination addresses.
-            memmove(&instance_layers->list[i], &instance_layers->list[i + 1],
-                    sizeof(struct loader_layer_properties) * (instance_layers->count - 1 - i));
-
-            // Decrement the count (because we now have one less) and decrement the loop index since we need to
-            // re-check this index.
-            instance_layers->count--;
-            i--;
-        }
-    }
-}
-
-// This structure is used to store the json file version
-// in a more manageable way.
-typedef struct {
-    uint16_t major;
-    uint16_t minor;
-    uint16_t patch;
-} layer_json_version;
-
-static inline bool is_valid_layer_json_version(const layer_json_version *layer_json) {
-    // Supported versions are: 1.0.0, 1.0.1, 1.1.0, 1.1.1, and 1.1.2.
-    if ((layer_json->major == 1 && layer_json->minor == 1 && layer_json->patch < 3) ||
-        (layer_json->major == 1 && layer_json->minor == 0 && layer_json->patch < 2)) {
-        return true;
-    }
-    return false;
-}
-
-static inline bool layer_json_supports_layers_tag(const layer_json_version *layer_json) {
-    // Supported versions started in 1.0.1, so anything newer
-    if ((layer_json->major > 1 || layer_json->minor > 0 || layer_json->patch > 1)) {
-        return true;
-    }
-    return false;
-}
-
-static inline bool layer_json_supports_pre_instance_tag(const layer_json_version *layer_json) {
-    // Supported versions started in 1.1.2, so anything newer
-    return layer_json->major > 1 || layer_json->minor > 1 || (layer_json->minor == 1 && layer_json->patch > 1);
-}
-
-static VkResult loader_read_json_layer(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list,
-                                       cJSON *layer_node, layer_json_version version, cJSON *item, cJSON *disable_environment,
-                                       bool is_implicit, char *filename) {
-    char *temp;
-    char *name, *type, *library_path_str, *api_version;
-    char *implementation_version, *description;
-    cJSON *ext_item, *library_path, *component_layers;
-    VkExtensionProperties ext_prop;
-    VkResult result = VK_ERROR_INITIALIZATION_FAILED;
-    struct loader_layer_properties *props = NULL;
-    int i, j;
-
-// The following are required in the "layer" object:
-// (required) "name"
-// (required) "type"
-// (required) "library_path"
-// (required) "api_version"
-// (required) "implementation_version"
-// (required) "description"
-// (required for implicit layers) "disable_environment"
-#define GET_JSON_OBJECT(node, var)                                         \
-    {                                                                      \
-        var = cJSON_GetObjectItem(node, #var);                             \
-        if (var == NULL) {                                                 \
-            layer_node = layer_node->next;                                 \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,           \
-                       "Didn't find required layer object %s in manifest " \
-                       "JSON file, skipping this layer",                   \
-                       #var);                                              \
-            goto out;                                                      \
-        }                                                                  \
-    }
-#define GET_JSON_ITEM(node, var)                                               \
-    {                                                                          \
-        item = cJSON_GetObjectItem(node, #var);                                \
-        if (item == NULL) {                                                    \
-            layer_node = layer_node->next;                                     \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,               \
-                       "Didn't find required layer value %s in manifest JSON " \
-                       "file, skipping this layer",                            \
-                       #var);                                                  \
-            goto out;                                                          \
-        }                                                                      \
-        temp = cJSON_Print(item);                                              \
-        if (temp == NULL) {                                                    \
-            layer_node = layer_node->next;                                     \
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,               \
-                       "Problem accessing layer value %s in manifest JSON "    \
-                       "file, skipping this layer",                            \
-                       #var);                                                  \
-            result = VK_ERROR_OUT_OF_HOST_MEMORY;                              \
-            goto out;                                                          \
-        }                                                                      \
-        temp[strlen(temp) - 1] = '\0';                                         \
-        var = loader_stack_alloc(strlen(temp) + 1);                            \
-        strcpy(var, &temp[1]);                                                 \
-        cJSON_Free(temp);                                                      \
-    }
-    GET_JSON_ITEM(layer_node, name)
-    GET_JSON_ITEM(layer_node, type)
-    GET_JSON_ITEM(layer_node, api_version)
-    GET_JSON_ITEM(layer_node, implementation_version)
-    GET_JSON_ITEM(layer_node, description)
-
-    // Add list entry
-    if (!strcmp(type, "DEVICE")) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Device layers are deprecated skipping this layer");
-        layer_node = layer_node->next;
-        goto out;
-    }
-
-    // Allow either GLOBAL or INSTANCE type interchangeably to handle
-    // layers that must work with older loaders
-    if (!strcmp(type, "INSTANCE") || !strcmp(type, "GLOBAL")) {
-        if (layer_instance_list == NULL) {
-            layer_node = layer_node->next;
-            goto out;
-        }
-        props = loader_get_next_layer_property(inst, layer_instance_list);
-        if (NULL == props) {
-            // Error already triggered in loader_get_next_layer_property.
-            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        props->type_flags = VK_LAYER_TYPE_FLAG_INSTANCE_LAYER;
-        if (!is_implicit) {
-            props->type_flags |= VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER;
-        }
-    } else {
-        layer_node = layer_node->next;
-        goto out;
-    }
-
-    // Library path no longer required unless component_layers is also not defined
-    library_path = cJSON_GetObjectItem(layer_node, "library_path");
-    component_layers = cJSON_GetObjectItem(layer_node, "component_layers");
-    if (NULL != library_path) {
-        if (NULL != component_layers) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Indicating meta-layer-specific component_layers, but also "
-                       "defining layer library path.  Both are not compatible, so "
-                       "skipping this layer");
-            goto out;
-        }
-        props->num_component_layers = 0;
-        props->component_layer_names = NULL;
-
-        temp = cJSON_Print(library_path);
-        if (NULL == temp) {
-            layer_node = layer_node->next;
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Problem accessing layer value library_path in manifest JSON "
-                       "file, skipping this layer");
-            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        temp[strlen(temp) - 1] = '\0';
-        library_path_str = loader_stack_alloc(strlen(temp) + 1);
-        strcpy(library_path_str, &temp[1]);
-        cJSON_Free(temp);
-
-        char *fullpath = props->lib_name;
-        char *rel_base;
-        if (NULL != library_path_str) {
-            if (loader_platform_is_path(library_path_str)) {
-                // A relative or absolute path
-                char *name_copy = loader_stack_alloc(strlen(filename) + 1);
-                strcpy(name_copy, filename);
-                rel_base = loader_platform_dirname(name_copy);
-                loader_expand_path(library_path_str, rel_base, MAX_STRING_SIZE, fullpath);
-            } else {
-                // A filename which is assumed in a system directory
-                loader_get_fullpath(library_path_str, DEFAULT_VK_LAYERS_PATH, MAX_STRING_SIZE, fullpath);
-            }
-        }
-    } else if (NULL != component_layers) {
-        if (version.major == 1 && (version.minor < 1 || version.patch < 1)) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Indicating meta-layer-specific component_layers, but using older "
-                       "JSON file version.");
-        }
-        int count = cJSON_GetArraySize(component_layers);
-        props->num_component_layers = count;
-
-        // Allocate buffer for layer names
-        props->component_layer_names =
-            loader_instance_heap_alloc(inst, sizeof(char[MAX_STRING_SIZE]) * count, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == props->component_layer_names) {
-            result = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-
-        // Copy the component layers into the array
-        for (i = 0; i < count; i++) {
-            cJSON *comp_layer = cJSON_GetArrayItem(component_layers, i);
-            if (NULL != comp_layer) {
-                temp = cJSON_Print(comp_layer);
-                if (NULL == temp) {
-                    result = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    goto out;
-                }
-                temp[strlen(temp) - 1] = '\0';
-                strncpy(props->component_layer_names[i], temp + 1, MAX_STRING_SIZE - 1);
-                props->component_layer_names[i][MAX_STRING_SIZE - 1] = '\0';
-                cJSON_Free(temp);
-            }
-        }
-
-        // This is now, officially, a meta-layer
-        props->type_flags |= VK_LAYER_TYPE_FLAG_META_LAYER;
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Encountered meta-layer %s", name);
-
-        // Make sure we set up other things so we head down the correct branches below
-        library_path_str = NULL;
-    } else {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "Layer missing both library_path and component_layers fields.  One or the "
-                   "other MUST be defined.  Skipping this layer");
-        goto out;
-    }
-
-    if (is_implicit) {
-        GET_JSON_OBJECT(layer_node, disable_environment)
-    }
-#undef GET_JSON_ITEM
-#undef GET_JSON_OBJECT
-
-    strncpy(props->info.layerName, name, sizeof(props->info.layerName));
-    props->info.layerName[sizeof(props->info.layerName) - 1] = '\0';
-    props->info.specVersion = loader_make_version(api_version);
-    props->info.implementationVersion = atoi(implementation_version);
-    strncpy((char *)props->info.description, description, sizeof(props->info.description));
-    props->info.description[sizeof(props->info.description) - 1] = '\0';
-    if (is_implicit) {
-        if (!disable_environment || !disable_environment->child) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Didn't find required layer child value disable_environment"
-                       "in manifest JSON file, skipping this layer");
-            layer_node = layer_node->next;
-            goto out;
-        }
-        strncpy(props->disable_env_var.name, disable_environment->child->string, sizeof(props->disable_env_var.name));
-        props->disable_env_var.name[sizeof(props->disable_env_var.name) - 1] = '\0';
-        strncpy(props->disable_env_var.value, disable_environment->child->valuestring, sizeof(props->disable_env_var.value));
-        props->disable_env_var.value[sizeof(props->disable_env_var.value) - 1] = '\0';
-    }
-
-// Now get all optional items and objects and put in list:
-// functions
-// instance_extensions
-// device_extensions
-// enable_environment (implicit layers only)
-#define GET_JSON_OBJECT(node, var) \
-    { var = cJSON_GetObjectItem(node, #var); }
-#define GET_JSON_ITEM(node, var)                            \
-    {                                                       \
-        item = cJSON_GetObjectItem(node, #var);             \
-        if (item != NULL) {                                 \
-            temp = cJSON_Print(item);                       \
-            if (temp != NULL) {                             \
-                temp[strlen(temp) - 1] = '\0';              \
-                var = loader_stack_alloc(strlen(temp) + 1); \
-                strcpy(var, &temp[1]);                      \
-                cJSON_Free(temp);                           \
-            } else {                                        \
-                result = VK_ERROR_OUT_OF_HOST_MEMORY;       \
-                goto out;                                   \
-            }                                               \
-        }                                                   \
-    }
-
-    cJSON *instance_extensions, *device_extensions, *functions, *enable_environment;
-    cJSON *entrypoints = NULL;
-    char *vkGetInstanceProcAddr = NULL;
-    char *vkGetDeviceProcAddr = NULL;
-    char *vkNegotiateLoaderLayerInterfaceVersion = NULL;
-    char *spec_version = NULL;
-    char **entry_array = NULL;
-
-    // Layer interface functions
-    //    vkGetInstanceProcAddr
-    //    vkGetDeviceProcAddr
-    //    vkNegotiateLoaderLayerInterfaceVersion (starting with JSON file 1.1.0)
-    GET_JSON_OBJECT(layer_node, functions)
-    if (functions != NULL) {
-        if (version.major > 1 || version.minor >= 1) {
-            GET_JSON_ITEM(functions, vkNegotiateLoaderLayerInterfaceVersion)
-            if (vkNegotiateLoaderLayerInterfaceVersion != NULL)
-                strncpy(props->functions.str_negotiate_interface, vkNegotiateLoaderLayerInterfaceVersion,
-                        sizeof(props->functions.str_negotiate_interface));
-            props->functions.str_negotiate_interface[sizeof(props->functions.str_negotiate_interface) - 1] = '\0';
-        } else {
-            props->functions.str_negotiate_interface[0] = '\0';
-        }
-        GET_JSON_ITEM(functions, vkGetInstanceProcAddr)
-        GET_JSON_ITEM(functions, vkGetDeviceProcAddr)
-        if (vkGetInstanceProcAddr != NULL) {
-            strncpy(props->functions.str_gipa, vkGetInstanceProcAddr, sizeof(props->functions.str_gipa));
-            if (version.major > 1 || version.minor >= 1) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Indicating layer-specific vkGetInstanceProcAddr "
-                           "function is deprecated starting with JSON file "
-                           "version 1.1.0.  Instead, use the new "
-                           "vkNegotiateLayerInterfaceVersion function to "
-                           "return the GetInstanceProcAddr function for this"
-                           "layer");
-            }
-        }
-        props->functions.str_gipa[sizeof(props->functions.str_gipa) - 1] = '\0';
-        if (vkGetDeviceProcAddr != NULL) {
-            strncpy(props->functions.str_gdpa, vkGetDeviceProcAddr, sizeof(props->functions.str_gdpa));
-            if (version.major > 1 || version.minor >= 1) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "Indicating layer-specific vkGetDeviceProcAddr "
-                           "function is deprecated starting with JSON file "
-                           "version 1.1.0.  Instead, use the new "
-                           "vkNegotiateLayerInterfaceVersion function to "
-                           "return the GetDeviceProcAddr function for this"
-                           "layer");
-            }
-        }
-        props->functions.str_gdpa[sizeof(props->functions.str_gdpa) - 1] = '\0';
-    }
-
-    // instance_extensions
-    //   array of {
-    //     name
-    //     spec_version
-    //   }
-    GET_JSON_OBJECT(layer_node, instance_extensions)
-    if (instance_extensions != NULL) {
-        int count = cJSON_GetArraySize(instance_extensions);
-        for (i = 0; i < count; i++) {
-            ext_item = cJSON_GetArrayItem(instance_extensions, i);
-            GET_JSON_ITEM(ext_item, name)
-            if (name != NULL) {
-                strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName));
-                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0';
-            }
-            GET_JSON_ITEM(ext_item, spec_version)
-            if (NULL != spec_version) {
-                ext_prop.specVersion = atoi(spec_version);
-            } else {
-                ext_prop.specVersion = 0;
-            }
-            bool ext_unsupported = wsi_unsupported_instance_extension(&ext_prop);
-            if (!ext_unsupported) {
-                loader_add_to_ext_list(inst, &props->instance_extension_list, 1, &ext_prop);
-            }
-        }
-    }
-
-    // device_extensions
-    //   array of {
-    //     name
-    //     spec_version
-    //     entrypoints
-    //   }
-    GET_JSON_OBJECT(layer_node, device_extensions)
-    if (device_extensions != NULL) {
-        int count = cJSON_GetArraySize(device_extensions);
-        for (i = 0; i < count; i++) {
-            ext_item = cJSON_GetArrayItem(device_extensions, i);
-            GET_JSON_ITEM(ext_item, name)
-            GET_JSON_ITEM(ext_item, spec_version)
-            if (name != NULL) {
-                strncpy(ext_prop.extensionName, name, sizeof(ext_prop.extensionName));
-                ext_prop.extensionName[sizeof(ext_prop.extensionName) - 1] = '\0';
-            }
-            if (NULL != spec_version) {
-                ext_prop.specVersion = atoi(spec_version);
-            } else {
-                ext_prop.specVersion = 0;
-            }
-            // entrypoints = cJSON_GetObjectItem(ext_item, "entrypoints");
-            GET_JSON_OBJECT(ext_item, entrypoints)
-            int entry_count;
-            if (entrypoints == NULL) {
-                loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, 0, NULL);
-                continue;
-            }
-            entry_count = cJSON_GetArraySize(entrypoints);
-            if (entry_count) {
-                entry_array = (char **)loader_stack_alloc(sizeof(char *) * entry_count);
-            }
-            for (j = 0; j < entry_count; j++) {
-                ext_item = cJSON_GetArrayItem(entrypoints, j);
-                if (ext_item != NULL) {
-                    temp = cJSON_Print(ext_item);
-                    if (NULL == temp) {
-                        entry_array[j] = NULL;
-                        result = VK_ERROR_OUT_OF_HOST_MEMORY;
-                        goto out;
-                    }
-                    temp[strlen(temp) - 1] = '\0';
-                    entry_array[j] = loader_stack_alloc(strlen(temp) + 1);
-                    strcpy(entry_array[j], &temp[1]);
-                    cJSON_Free(temp);
-                }
-            }
-            loader_add_to_dev_ext_list(inst, &props->device_extension_list, &ext_prop, entry_count, entry_array);
-        }
-    }
-    if (is_implicit) {
-        GET_JSON_OBJECT(layer_node, enable_environment)
-
-        // enable_environment is optional
-        if (enable_environment) {
-            strncpy(props->enable_env_var.name, enable_environment->child->string, sizeof(props->enable_env_var.name));
-            props->enable_env_var.name[sizeof(props->enable_env_var.name) - 1] = '\0';
-            strncpy(props->enable_env_var.value, enable_environment->child->valuestring, sizeof(props->enable_env_var.value));
-            props->enable_env_var.value[sizeof(props->enable_env_var.value) - 1] = '\0';
-        }
-    }
-
-    // Read in the pre-instance stuff
-    cJSON *pre_instance = cJSON_GetObjectItem(layer_node, "pre_instance_functions");
-    if (pre_instance) {
-        if (!layer_json_supports_pre_instance_tag(&version)) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "Found pre_instance_functions section in layer from \"%s\". "
-                       "This section is only valid in manifest version 1.1.2 or later. The section will be ignored",
-                       filename);
-        } else if (!is_implicit) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "Found pre_instance_functions section in explicit layer from "
-                       "\"%s\". This section is only valid in implicit layers. The section will be ignored",
-                       filename);
-        } else {
-            cJSON *inst_ext_json = cJSON_GetObjectItem(pre_instance, "vkEnumerateInstanceExtensionProperties");
-            if (inst_ext_json) {
-                char *inst_ext_name = cJSON_Print(inst_ext_json);
-                size_t len = strlen(inst_ext_name) >= MAX_STRING_SIZE ? MAX_STRING_SIZE - 3 : strlen(inst_ext_name) - 2;
-                strncpy(props->pre_instance_functions.enumerate_instance_extension_properties, inst_ext_name + 1, len);
-                props->pre_instance_functions.enumerate_instance_extension_properties[len] = '\0';
-                cJSON_Free(inst_ext_name);
-            }
-
-            cJSON *inst_layer_json = cJSON_GetObjectItem(pre_instance, "vkEnumerateInstanceLayerProperties");
-            if (inst_layer_json) {
-                char *inst_layer_name = cJSON_Print(inst_layer_json);
-                size_t len = strlen(inst_layer_name) >= MAX_STRING_SIZE ? MAX_STRING_SIZE - 3 : strlen(inst_layer_name) - 2;
-                strncpy(props->pre_instance_functions.enumerate_instance_layer_properties, inst_layer_name + 1, len);
-                props->pre_instance_functions.enumerate_instance_layer_properties[len] = '\0';
-                cJSON_Free(inst_layer_name);
-            }
-        }
-    }
-
-    result = VK_SUCCESS;
-
-out:
-
-#undef GET_JSON_ITEM
-#undef GET_JSON_OBJECT
-
-    if (VK_SUCCESS != result && NULL != props) {
-        props->num_component_layers = 0;
-        if (NULL != props->component_layer_names) {
-            loader_instance_heap_free(inst, props->component_layer_names);
-        }
-        props->component_layer_names = NULL;
-    }
-
-    return result;
-}
-
-// Given a cJSON struct (json) of the top level JSON object from layer manifest
-// file, add entry to the layer_list. Fill out the layer_properties in this list
-// entry from the input cJSON object.
-//
-// \returns
-// void
-// layer_list has a new entry and initialized accordingly.
-// If the json input object does not have all the required fields no entry
-// is added to the list.
-static VkResult loader_add_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_instance_list,
-                                            cJSON *json, bool is_implicit, char *filename) {
-    // The following Fields in layer manifest file that are required:
-    //   - "file_format_version"
-    //   - If more than one "layer" object are used, then the "layers" array is
-    //     required
-    VkResult result = VK_ERROR_INITIALIZATION_FAILED;
-    cJSON *item, *layers_node, *layer_node;
-    layer_json_version json_version = {0, 0, 0};
-    char *vers_tok;
-    cJSON *disable_environment = NULL;
-    item = cJSON_GetObjectItem(json, "file_format_version");
-    if (item == NULL) {
-        goto out;
-    }
-    char *file_vers = cJSON_PrintUnformatted(item);
-    if (NULL == file_vers) {
-        goto out;
-    }
-    loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found manifest file %s, version %s", filename, file_vers);
-    // Get the major/minor/and patch as integers for easier comparison
-    vers_tok = strtok(file_vers, ".\"\n\r");
-    if (NULL != vers_tok) {
-        json_version.major = (uint16_t)atoi(vers_tok);
-        vers_tok = strtok(NULL, ".\"\n\r");
-        if (NULL != vers_tok) {
-            json_version.minor = (uint16_t)atoi(vers_tok);
-            vers_tok = strtok(NULL, ".\"\n\r");
-            if (NULL != vers_tok) {
-                json_version.patch = (uint16_t)atoi(vers_tok);
-            }
-        }
-    }
-
-    if (!is_valid_layer_json_version(&json_version)) {
-        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                   "loader_add_layer_properties: %s invalid layer "
-                   "manifest file version %d.%d.%d.  May cause errors.",
-                   filename, json_version.major, json_version.minor, json_version.patch);
-    }
-    cJSON_Free(file_vers);
-
-    // If "layers" is present, read in the array of layer objects
-    layers_node = cJSON_GetObjectItem(json, "layers");
-    if (layers_node != NULL) {
-        int numItems = cJSON_GetArraySize(layers_node);
-        if (!layer_json_supports_layers_tag(&json_version)) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_add_layer_properties: \'layers\' tag not "
-                       "supported until file version 1.0.1, but %s is "
-                       "reporting version %s",
-                       filename, file_vers);
-        }
-        for (int curLayer = 0; curLayer < numItems; curLayer++) {
-            layer_node = cJSON_GetArrayItem(layers_node, curLayer);
-            if (layer_node == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "loader_add_layer_properties: Can not find "
-                           "\'layers\' array element %d object in manifest "
-                           "JSON file %s.  Skipping this file",
-                           curLayer, filename);
-                goto out;
-            }
-            result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment,
-                                            is_implicit, filename);
-        }
-    } else {
-        // Otherwise, try to read in individual layers
-        layer_node = cJSON_GetObjectItem(json, "layer");
-        if (layer_node == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_add_layer_properties: Can not find \'layer\' "
-                       "object in manifest JSON file %s.  Skipping this file.",
-                       filename);
-            goto out;
-        }
-        // Loop through all "layer" objects in the file to get a count of them
-        // first.
-        uint16_t layer_count = 0;
-        cJSON *tempNode = layer_node;
-        do {
-            tempNode = tempNode->next;
-            layer_count++;
-        } while (tempNode != NULL);
-
-        // Throw a warning if we encounter multiple "layer" objects in file
-        // versions newer than 1.0.0.  Having multiple objects with the same
-        // name at the same level is actually a JSON standard violation.
-        if (layer_count > 1 && layer_json_supports_layers_tag(&json_version)) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_layer_properties: Multiple \'layer\' nodes"
-                       " are deprecated starting in file version \"1.0.1\".  "
-                       "Please use \'layers\' : [] array instead in %s.",
-                       filename);
-        } else {
-            do {
-                result = loader_read_json_layer(inst, layer_instance_list, layer_node, json_version, item, disable_environment,
-                                                is_implicit, filename);
-                layer_node = layer_node->next;
-            } while (layer_node != NULL);
-        }
-    }
-
-out:
-
-    return result;
-}
-
-// Find the Vulkan library manifest files.
-//
-// This function scans the "location" or "env_override" directories/files
-// for a list of JSON manifest files.  If env_override is non-NULL
-// and has a valid value. Then the location is ignored.  Otherwise
-// location is used to look for manifest files. The location
-// is interpreted as  Registry path on Windows and a directory path(s)
-// on Linux. "home_location" is an additional directory in the users home
-// directory to look at. It is expanded into the dir path
-// $XDG_DATA_HOME/home_location or $HOME/.local/share/home_location depending
-// on environment variables. This "home_location" is only used on Linux.
-//
-// \returns
-// VKResult
-// A string list of manifest files to be opened in out_files param.
-// List has a pointer to string for each manifest filename.
-// When done using the list in out_files, pointers should be freed.
-// Location or override  string lists can be either files or directories as
-// follows:
-//            | location | override
-// --------------------------------
-// Win ICD    | files    | files
-// Win Layer  | files    | dirs
-// Linux ICD  | dirs     | files
-// Linux Layer| dirs     | dirs
-static VkResult loader_get_manifest_files(const struct loader_instance *inst, const char *env_override, const char *source_override,
-                                          bool is_layer, bool warn_if_not_present, const char *location,
-                                          const char *relative_location, struct loader_manifest_files *out_files) {
-    const char *override = NULL;
-    char *override_getenv = NULL;
-    char *loc, *orig_loc = NULL;
-    char *reg = NULL;
-    char *file, *next_file, *name;
-    size_t alloced_count = 64;
-    char full_path[2048];
-    DIR *sysdir = NULL;
-    bool list_is_dirs = false;
-    struct dirent *dent;
-    VkResult res = VK_SUCCESS;
-
-    out_files->count = 0;
-    out_files->filename_list = NULL;
-
-    if (source_override != NULL) {
-        override = source_override;
-    } else if (env_override != NULL) {
-#if !defined(_WIN32)
-        if (geteuid() != getuid() || getegid() != getgid()) {
-            // Don't allow setuid apps to use the env var:
-            env_override = NULL;
-        }
-#endif
-        if (env_override != NULL) {
-            override = override_getenv = loader_secure_getenv(env_override, inst);
-        }
-    }
-
-#if !defined(_WIN32)
-    if (relative_location == NULL) {
-#else
-    relative_location = NULL;
-    if (location == NULL) {
-#endif
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_get_manifest_files: Can not get manifest files with "
-                   "NULL location, env_override=%s",
-                   (env_override != NULL) ? env_override : "");
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-#if defined(_WIN32)
-    list_is_dirs = (is_layer && override != NULL) ? true : false;
-#else
-    list_is_dirs = (override == NULL || is_layer) ? true : false;
-#endif
-    // Make a copy of the input we are using so it is not modified
-    // Also handle getting the location(s) from registry on Windows
-    if (override == NULL) {
-        size_t loc_size = 0;
-#if !defined(_WIN32)
-        const char *xdgconfdirs = loader_secure_getenv("XDG_CONFIG_DIRS", inst);
-        const char *xdgdatadirs = loader_secure_getenv("XDG_DATA_DIRS", inst);
-        if (xdgconfdirs == NULL || xdgconfdirs[0] == '\0') xdgconfdirs = FALLBACK_CONFIG_DIRS;
-        if (xdgdatadirs == NULL || xdgdatadirs[0] == '\0') xdgdatadirs = FALLBACK_DATA_DIRS;
-        const size_t rel_size = strlen(relative_location);
-        // Leave space for trailing separators
-        loc_size += strlen(xdgconfdirs) + strlen(xdgdatadirs) + 2 * rel_size + 2;
-        for (const char *x = xdgconfdirs; *x; ++x)
-            if (*x == PATH_SEPARATOR) loc_size += rel_size;
-        for (const char *x = xdgdatadirs; *x; ++x)
-            if (*x == PATH_SEPARATOR) loc_size += rel_size;
-        loc_size += strlen(SYSCONFDIR) + rel_size + 1;
-#if defined(EXTRASYSCONFDIR)
-        loc_size += strlen(EXTRASYSCONFDIR) + rel_size + 1;
-#endif
-#else
-        loc_size += strlen(location) + 1;
-#endif
-        loc = loader_stack_alloc(loc_size);
-        if (loc == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_manifest_files: Failed to allocate "
-                       "%d bytes for manifest file location.",
-                       loc_size);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        char *loc_write = loc;
-#if !defined(_WIN32)
-        const char *loc_read;
-        size_t start, stop;
-
-        loc_read = &xdgconfdirs[0];
-        start = 0;
-        while (loc_read[start] != '\0') {
-            while (loc_read[start] == PATH_SEPARATOR) {
-                start++;
-            }
-            stop = start;
-            while (loc_read[stop] != PATH_SEPARATOR && loc_read[stop] != '\0') {
-                stop++;
-            }
-            const size_t s = stop - start;
-            if (s) {
-                memcpy(loc_write, &loc_read[start], s);
-                loc_write += s;
-                memcpy(loc_write, relative_location, rel_size);
-                loc_write += rel_size;
-                *loc_write++ = PATH_SEPARATOR;
-                start = stop;
-            }
-        }
-
-        memcpy(loc_write, SYSCONFDIR, strlen(SYSCONFDIR));
-        loc_write += strlen(SYSCONFDIR);
-        memcpy(loc_write, relative_location, rel_size);
-        loc_write += rel_size;
-        *loc_write++ = PATH_SEPARATOR;
-
-#if defined(EXTRASYSCONFDIR)
-        memcpy(loc_write, EXTRASYSCONFDIR, strlen(EXTRASYSCONFDIR));
-        loc_write += strlen(EXTRASYSCONFDIR);
-        memcpy(loc_write, relative_location, rel_size);
-        loc_write += rel_size;
-        *loc_write++ = PATH_SEPARATOR;
-#endif
-
-        loc_read = &xdgdatadirs[0];
-        start = 0;
-        while (loc_read[start] != '\0') {
-            while (loc_read[start] == PATH_SEPARATOR) {
-                start++;
-            }
-            stop = start;
-            while (loc_read[stop] != PATH_SEPARATOR && loc_read[stop] != '\0') {
-                stop++;
-            }
-            const size_t s = stop - start;
-            if (s) {
-                memcpy(loc_write, &loc_read[start], s);
-                loc_write += s;
-                memcpy(loc_write, relative_location, rel_size);
-                loc_write += rel_size;
-                *loc_write++ = PATH_SEPARATOR;
-                start = stop;
-            }
-        }
-
-        --loc_write;
-#else
-        memcpy(loc_write, location, strlen(location));
-        loc_write += strlen(location);
-#endif
-        assert(loc_write - loc < (ptrdiff_t)loc_size);
-        *loc_write = '\0';
-
-#if defined(_WIN32)
-        VkResult regHKR_result = VK_SUCCESS;
-
-        DWORD reg_size = 4096;
-
-        if (!strncmp(loc, DEFAULT_VK_DRIVERS_INFO, sizeof(DEFAULT_VK_DRIVERS_INFO))) {
-            regHKR_result = loaderGetDeviceRegistryFiles(inst, &reg, &reg_size, LoaderPnpDriverRegistry());
-        } else if (!strncmp(loc, DEFAULT_VK_ELAYERS_INFO, sizeof(DEFAULT_VK_ELAYERS_INFO))) {
-            regHKR_result = loaderGetDeviceRegistryFiles(inst, &reg, &reg_size, LoaderPnpELayerRegistry());
-        } else if (!strncmp(loc, DEFAULT_VK_ILAYERS_INFO, sizeof(DEFAULT_VK_ILAYERS_INFO))) {
-            regHKR_result = loaderGetDeviceRegistryFiles(inst, &reg, &reg_size, LoaderPnpILayerRegistry());
-        }
-
-        VkResult reg_result = loaderGetRegistryFiles(inst, loc, is_layer, &reg, &reg_size);
-
-        if ((VK_SUCCESS != reg_result && VK_SUCCESS != regHKR_result) || NULL == reg) {
-            if (!is_layer) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_get_manifest_files: Registry lookup failed "
-                           "to get ICD manifest files.  Possibly missing Vulkan"
-                           " driver?");
-                if (VK_SUCCESS == regHKR_result || VK_ERROR_OUT_OF_HOST_MEMORY == regHKR_result) {
-                    res = regHKR_result;
-                } else if (VK_SUCCESS == reg_result || VK_ERROR_OUT_OF_HOST_MEMORY == reg_result) {
-                    res = reg_result;
-                } else {
-                    res = VK_ERROR_INCOMPATIBLE_DRIVER;
-                }
-            } else {
-                if (warn_if_not_present) {
-                    // This is only a warning for layers
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_get_manifest_files: Registry lookup failed "
-                               "to get layer manifest files.");
-                }
-                if (reg_result == VK_ERROR_OUT_OF_HOST_MEMORY) {
-                    res = reg_result;
-                } else {
-                    // Return success for now since it's not critical for layers
-                    res = VK_SUCCESS;
-                }
-            }
-            goto out;
-        }
-        orig_loc = loc;
-        loc = reg;
-#endif
-    } else {
-        loc = loader_stack_alloc(strlen(override) + 1);
-        if (loc == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_get_manifest_files: Failed to allocate space for "
-                       "override environment variable of length %d",
-                       strlen(override) + 1);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        strcpy(loc, override);
-    }
-
-    // Print out the paths being searched if debugging is enabled
-    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following paths for manifest files: %s\n", loc);
-
-    file = loc;
-    while (*file) {
-        next_file = loader_get_next_path(file);
-        if (list_is_dirs) {
-            sysdir = opendir(file);
-            name = NULL;
-            if (sysdir) {
-                dent = readdir(sysdir);
-                if (dent == NULL) break;
-                name = &(dent->d_name[0]);
-                loader_get_fullpath(name, file, sizeof(full_path), full_path);
-                name = full_path;
-            }
-        } else {
-#if defined(_WIN32)
-            name = file;
-#else
-            // only Linux has relative paths
-            char *dir;
-            // make a copy of location so it isn't modified
-            dir = loader_stack_alloc(strlen(loc) + 1);
-            if (dir == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_get_manifest_files: Failed to allocate "
-                           "space for relative location path length %d",
-                           strlen(loc) + 1);
-                goto out;
-            }
-            strcpy(dir, loc);
-
-            loader_get_fullpath(file, dir, sizeof(full_path), full_path);
-
-            name = full_path;
-#endif
-        }
-        while (name) {
-            // Look for files ending with ".json" suffix
-            uint32_t nlen = (uint32_t)strlen(name);
-            const char *suf = name + nlen - 5;
-
-            // Check if the file is already present
-            bool file_already_loaded = false;
-            for (uint32_t i = 0; i < out_files->count; ++i) {
-                if (!strcmp(out_files->filename_list[i], name)) {
-                    file_already_loaded = true;
-                }
-            }
-
-            if (!file_already_loaded && (nlen > 5) && !strncmp(suf, ".json", 5)) {
-                if (out_files->count == 0) {
-                    out_files->filename_list =
-                        loader_instance_heap_alloc(inst, alloced_count * sizeof(char *), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-                    if (NULL == out_files->filename_list) {
-                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                   "loader_get_manifest_files: Failed to allocate space for manifest file name list");
-                        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                        goto out;
-                    }
-                } else if (out_files->count == alloced_count) {
-                    void *new_ptr =
-                        loader_instance_heap_realloc(inst, out_files->filename_list, alloced_count * sizeof(char *),
-                                                     alloced_count * sizeof(char *) * 2, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-                    if (NULL == new_ptr) {
-                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                   "loader_get_manifest_files: Failed to reallocate space for manifest file name list");
-                        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                        goto out;
-                    }
-                    out_files->filename_list = new_ptr;
-                    alloced_count *= 2;
-                }
-                out_files->filename_list[out_files->count] =
-                    loader_instance_heap_alloc(inst, strlen(name) + 1, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
-                if (out_files->filename_list[out_files->count] == NULL) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_get_manifest_files: Failed to allocate "
-                               "space for manifest file %d list",
-                               out_files->count);
-                    res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    goto out;
-                }
-                strcpy(out_files->filename_list[out_files->count], name);
-                out_files->count++;
-            } else if(file_already_loaded) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                    "Skipping manifest file %s - The file has already been read once", name);
-            } else if (!list_is_dirs) {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "Skipping manifest file %s, file name must end in .json",
-                           name);
-            }
-            if (list_is_dirs) {
-                dent = readdir(sysdir);
-                if (dent == NULL) {
-                    break;
-                }
-                name = &(dent->d_name[0]);
-                loader_get_fullpath(name, file, sizeof(full_path), full_path);
-                name = full_path;
-            } else {
-                break;
-            }
-        }
-        if (sysdir) {
-            closedir(sysdir);
-            sysdir = NULL;
-        }
-        file = next_file;
-#if !defined(_WIN32)
-        if (relative_location != NULL && (next_file == NULL || *next_file == '\0') && override == NULL) {
-            char *xdgdatahome = loader_secure_getenv("XDG_DATA_HOME", inst);
-            size_t len;
-            if (xdgdatahome != NULL) {
-                size_t alloc_len = strlen(xdgdatahome) + 2 + strlen(relative_location);
-                char *home_loc = loader_stack_alloc(alloc_len);
-                if (home_loc == NULL) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_get_manifest_files: Failed to allocate "
-                               "space for manifest file XDG Home location");
-                    res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    goto out;
-                }
-                strcpy(home_loc, xdgdatahome);
-                // Add directory separator if needed
-                if (relative_location[0] != DIRECTORY_SYMBOL) {
-                    len = strlen(home_loc);
-                    home_loc[len] = DIRECTORY_SYMBOL;
-                    home_loc[len + 1] = '\0';
-                }
-                strncat(home_loc, relative_location, alloc_len);
-                file = home_loc;
-                next_file = loader_get_next_path(file);
-                relative_location = NULL;
-
-                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n",
-                           home_loc);
-                list_is_dirs = true;
-
-            } else {
-                char *home = loader_secure_getenv("HOME", inst);
-                if (home != NULL) {
-                    size_t alloc_len = strlen(home) + 16 + strlen(relative_location);
-                    char *home_loc = loader_stack_alloc(alloc_len);
-                    if (home_loc == NULL) {
-                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                   "loader_get_manifest_files: Failed to allocate "
-                                   "space for manifest file Home location");
-                        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                        goto out;
-                    }
-                    strncpy(home_loc, home, alloc_len);
-
-                    len = strlen(home);
-                    if (home[len] != DIRECTORY_SYMBOL) {
-                        home_loc[len] = DIRECTORY_SYMBOL;
-                        home_loc[len + 1] = '\0';
-                    }
-                    strncat(home_loc, ".local/share", alloc_len);
-
-                    if (relative_location[0] != DIRECTORY_SYMBOL) {
-                        len = strlen(home_loc);
-                        home_loc[len] = DIRECTORY_SYMBOL;
-                        home_loc[len + 1] = '\0';
-                    }
-                    strncat(home_loc, relative_location, alloc_len);
-                    file = home_loc;
-                    next_file = loader_get_next_path(file);
-                    relative_location = NULL;
-
-                    loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching the following path for manifest files: %s\n",
-                               home_loc);
-                    list_is_dirs = true;
-                } else {
-                    // without knowing HOME, we just.. give up
-                }
-            }
-        }
-#endif
-    }
-
-out:
-    if (VK_SUCCESS != res && NULL != out_files->filename_list) {
-        for (uint32_t remove = 0; remove < out_files->count; remove++) {
-            loader_instance_heap_free(inst, out_files->filename_list[remove]);
-        }
-        loader_instance_heap_free(inst, out_files->filename_list);
-        out_files->count = 0;
-        out_files->filename_list = NULL;
-    }
-
-    if (NULL != sysdir) {
-        closedir(sysdir);
-    }
-
-    if (override_getenv != NULL) {
-        loader_free_getenv(override_getenv, inst);
-    }
-
-    if (NULL != reg && reg != orig_loc) {
-        loader_instance_heap_free(inst, reg);
-    }
-    return res;
-}
-
-void loader_init_icd_lib_list() {}
-
-void loader_destroy_icd_lib_list() {}
-
-// Try to find the Vulkan ICD driver(s).
-//
-// This function scans the default system loader path(s) or path
-// specified by the \c VK_ICD_FILENAMES environment variable in
-// order to find loadable VK ICDs manifest files. From these
-// manifest files it finds the ICD libraries.
-//
-// \returns
-// Vulkan result
-// (on result == VK_SUCCESS) a list of icds that were discovered
-VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list) {
-    char *file_str;
-    uint16_t file_major_vers = 0;
-    uint16_t file_minor_vers = 0;
-    uint16_t file_patch_vers = 0;
-    char *vers_tok;
-    struct loader_manifest_files manifest_files;
-    VkResult res = VK_SUCCESS;
-    bool lockedMutex = false;
-    cJSON *json = NULL;
-    uint32_t num_good_icds = 0;
-
-    memset(&manifest_files, 0, sizeof(struct loader_manifest_files));
-
-    res = loader_scanned_icd_init(inst, icd_tramp_list);
-    if (VK_SUCCESS != res) {
-        goto out;
-    }
-
-    // Get a list of manifest files for ICDs
-    res = loader_get_manifest_files(inst, "VK_ICD_FILENAMES", NULL, false, true, DEFAULT_VK_DRIVERS_INFO, RELATIVE_VK_DRIVERS_INFO,
-                                    &manifest_files);
-    if (VK_SUCCESS != res || manifest_files.count == 0) {
-        goto out;
-    }
-
-    loader_platform_thread_lock_mutex(&loader_json_lock);
-    lockedMutex = true;
-    for (uint32_t i = 0; i < manifest_files.count; i++) {
-        file_str = manifest_files.filename_list[i];
-        if (file_str == NULL) {
-            continue;
-        }
-
-        VkResult temp_res = loader_get_json(inst, file_str, &json);
-        if (NULL == json || temp_res != VK_SUCCESS) {
-            if (NULL != json) {
-                cJSON_Delete(json);
-                json = NULL;
-            }
-            // If we haven't already found an ICD, copy this result to
-            // the returned result.
-            if (num_good_icds == 0) {
-                res = temp_res;
-            }
-            if (temp_res == VK_ERROR_OUT_OF_HOST_MEMORY) {
-                break;
-            } else {
-                continue;
-            }
-        }
-        res = temp_res;
-
-        cJSON *item, *itemICD;
-        item = cJSON_GetObjectItem(json, "file_format_version");
-        if (item == NULL) {
-            if (num_good_icds == 0) {
-                res = VK_ERROR_INITIALIZATION_FAILED;
-            }
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: ICD JSON %s does not have a"
-                       " \'file_format_version\' field. Skipping ICD JSON.",
-                       file_str);
-            cJSON_Delete(json);
-            json = NULL;
-            continue;
-        }
-
-        char *file_vers = cJSON_Print(item);
-        if (NULL == file_vers) {
-            // Only reason the print can fail is if there was an allocation issue
-            if (num_good_icds == 0) {
-                res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            }
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: Failed retrieving ICD JSON %s"
-                       " \'file_format_version\' field.  Skipping ICD JSON",
-                       file_str);
-            cJSON_Delete(json);
-            json = NULL;
-            continue;
-        }
-        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Found ICD manifest file %s, version %s", file_str, file_vers);
-
-        // Get the major/minor/and patch as integers for easier comparison
-        vers_tok = strtok(file_vers, ".\"\n\r");
-        if (NULL != vers_tok) {
-            file_major_vers = (uint16_t)atoi(vers_tok);
-            vers_tok = strtok(NULL, ".\"\n\r");
-            if (NULL != vers_tok) {
-                file_minor_vers = (uint16_t)atoi(vers_tok);
-                vers_tok = strtok(NULL, ".\"\n\r");
-                if (NULL != vers_tok) {
-                    file_patch_vers = (uint16_t)atoi(vers_tok);
-                }
-            }
-        }
-
-        if (file_major_vers != 1 || file_minor_vers != 0 || file_patch_vers > 1) {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: Unexpected manifest file version "
-                       "(expected 1.0.0 or 1.0.1), may cause errors");
-        }
-        cJSON_Free(file_vers);
-
-        itemICD = cJSON_GetObjectItem(json, "ICD");
-        if (itemICD != NULL) {
-            item = cJSON_GetObjectItem(itemICD, "library_path");
-            if (item != NULL) {
-                char *temp = cJSON_Print(item);
-                if (!temp || strlen(temp) == 0) {
-                    if (num_good_icds == 0) {
-                        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    }
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: Failed retrieving ICD JSON %s"
-                               " \'library_path\' field.  Skipping ICD JSON.",
-                               file_str);
-                    cJSON_Free(temp);
-                    cJSON_Delete(json);
-                    json = NULL;
-                    continue;
-                }
-                // strip out extra quotes
-                temp[strlen(temp) - 1] = '\0';
-                char *library_path = loader_stack_alloc(strlen(temp) + 1);
-                if (NULL == library_path) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_icd_scan: Failed to allocate space for "
-                               "ICD JSON %s \'library_path\' value.  Skipping "
-                               "ICD JSON.",
-                               file_str);
-                    res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    cJSON_Free(temp);
-                    cJSON_Delete(json);
-                    json = NULL;
-                    goto out;
-                }
-                strcpy(library_path, &temp[1]);
-                cJSON_Free(temp);
-                if (strlen(library_path) == 0) {
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: ICD JSON %s \'library_path\'"
-                               " field is empty.  Skipping ICD JSON.",
-                               file_str);
-                    cJSON_Delete(json);
-                    json = NULL;
-                    continue;
-                }
-                char fullpath[MAX_STRING_SIZE];
-                // Print out the paths being searched if debugging is enabled
-                loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Searching for ICD drivers named %s, using default dir %s",
-                           library_path, DEFAULT_VK_DRIVERS_PATH);
-                if (loader_platform_is_path(library_path)) {
-                    // a relative or absolute path
-                    char *name_copy = loader_stack_alloc(strlen(file_str) + 1);
-                    char *rel_base;
-                    strcpy(name_copy, file_str);
-                    rel_base = loader_platform_dirname(name_copy);
-                    loader_expand_path(library_path, rel_base, sizeof(fullpath), fullpath);
-                } else {
-                    // a filename which is assumed in a system directory
-                    loader_get_fullpath(library_path, DEFAULT_VK_DRIVERS_PATH, sizeof(fullpath), fullpath);
-                }
-
-                uint32_t vers = 0;
-                item = cJSON_GetObjectItem(itemICD, "api_version");
-                if (item != NULL) {
-                    temp = cJSON_Print(item);
-                    if (NULL == temp) {
-                        loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                                   "loader_icd_scan: Failed retrieving ICD JSON %s"
-                                   " \'api_version\' field.  Skipping ICD JSON.",
-                                   file_str);
-
-                        // Only reason the print can fail is if there was an
-                        // allocation issue
-                        if (num_good_icds == 0) {
-                            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                        }
-
-                        cJSON_Free(temp);
-                        cJSON_Delete(json);
-                        json = NULL;
-                        continue;
-                    }
-                    vers = loader_make_version(temp);
-                    cJSON_Free(temp);
-                } else {
-                    loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                               "loader_icd_scan: ICD JSON %s does not have an"
-                               " \'api_version\' field.",
-                               file_str);
-                }
-
-                res = loader_scanned_icd_add(inst, icd_tramp_list, fullpath, vers);
-                if (VK_SUCCESS != res) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "loader_icd_scan: Failed to add ICD JSON %s. "
-                               " Skipping ICD JSON.",
-                               fullpath);
-                    cJSON_Delete(json);
-                    json = NULL;
-                    continue;
-                }
-                num_good_icds++;
-            } else {
-                loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                           "loader_icd_scan: Failed to find \'library_path\' "
-                           "object in ICD JSON file %s.  Skipping ICD JSON.",
-                           file_str);
-            }
-        } else {
-            loader_log(inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "loader_icd_scan: Can not find \'ICD\' object in ICD JSON "
-                       "file %s.  Skipping ICD JSON",
-                       file_str);
-        }
-
-        cJSON_Delete(json);
-        json = NULL;
-    }
-
-out:
-
-    if (NULL != json) {
-        cJSON_Delete(json);
-    }
-
-    if (NULL != manifest_files.filename_list) {
-        for (uint32_t i = 0; i < manifest_files.count; i++) {
-            if (NULL != manifest_files.filename_list[i]) {
-                loader_instance_heap_free(inst, manifest_files.filename_list[i]);
-            }
-        }
-        loader_instance_heap_free(inst, manifest_files.filename_list);
-    }
-    if (lockedMutex) {
-        loader_platform_thread_unlock_mutex(&loader_json_lock);
-    }
-
-    return res;
-}
-
-void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) {
-    char *file_str;
-    struct loader_manifest_files manifest_files[2];  // [0] = explicit, [1] = implicit
-    cJSON *json;
-    uint32_t implicit;
-    bool lockedMutex = false;
-
-    memset(manifest_files, 0, sizeof(struct loader_manifest_files) * 2);
-
-    // Get a list of manifest files for explicit layers
-    if (VK_SUCCESS != loader_get_manifest_files(inst, LAYERS_PATH_ENV, LAYERS_SOURCE_PATH, true, true, DEFAULT_VK_ELAYERS_INFO,
-                                                RELATIVE_VK_ELAYERS_INFO, &manifest_files[0])) {
-        goto out;
-    }
-
-    // Get a list of manifest files for any implicit layers
-    // Pass NULL for environment variable override - implicit layers are not
-    // overridden by LAYERS_PATH_ENV
-    if (VK_SUCCESS != loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO,
-                                                &manifest_files[1])) {
-        goto out;
-    }
-
-    // Make sure we have at least one layer, if not, go ahead and return
-    if (manifest_files[0].count == 0 && manifest_files[1].count == 0) {
-        goto out;
-    }
-
-    // cleanup any previously scanned libraries
-    loader_delete_layer_properties(inst, instance_layers);
-
-    loader_platform_thread_lock_mutex(&loader_json_lock);
-    lockedMutex = true;
-    for (implicit = 0; implicit < 2; implicit++) {
-        for (uint32_t i = 0; i < manifest_files[implicit].count; i++) {
-            file_str = manifest_files[implicit].filename_list[i];
-            if (file_str == NULL) continue;
-
-            // parse file into JSON struct
-            VkResult res = loader_get_json(inst, file_str, &json);
-            if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
-                break;
-            } else if (VK_SUCCESS != res || NULL == json) {
-                continue;
-            }
-
-            VkResult local_res = loader_add_layer_properties(inst, instance_layers, json, (implicit == 1), file_str);
-            cJSON_Delete(json);
-
-            if (VK_SUCCESS != local_res) {
-                goto out;
-            }
-        }
-    }
-
-    // See if "VK_LAYER_LUNARG_standard_validation" already in list.
-    bool found_std_val = false;
-    for (uint32_t i = 0; i < instance_layers->count; i++) {
-        struct loader_layer_properties *props = &instance_layers->list[i];
-        if (strcmp(props->info.layerName, std_validation_str) == 0) {
-            found_std_val = true;
-            break;
-        }
-    }
-
-    // If we didn't find the VK_LAYER_LUNARG_standard_validation meta-layer in
-    // the list, then we need to add it manually.  This is likely because we're
-    // dealing with a new loader, but an old layer folder.
-    if (!found_std_val && !loader_add_legacy_std_val_layer(inst, instance_layers)) {
-        goto out;
-    }
-
-    // Verify any meta-layers in the list are valid and all the component layers are
-    // actually present in the available layer list
-    verify_all_meta_layers(inst, instance_layers);
-
-out:
-
-    for (uint32_t manFile = 0; manFile < 2; manFile++) {
-        if (NULL != manifest_files[manFile].filename_list) {
-            for (uint32_t i = 0; i < manifest_files[manFile].count; i++) {
-                if (NULL != manifest_files[manFile].filename_list[i]) {
-                    loader_instance_heap_free(inst, manifest_files[manFile].filename_list[i]);
-                }
-            }
-            loader_instance_heap_free(inst, manifest_files[manFile].filename_list);
-        }
-    }
-    if (lockedMutex) {
-        loader_platform_thread_unlock_mutex(&loader_json_lock);
-    }
-}
-
-void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers) {
-    char *file_str;
-    struct loader_manifest_files manifest_files;
-    cJSON *json;
-    uint32_t i;
-
-    // Pass NULL for environment variable override - implicit layers are not
-    // overridden by LAYERS_PATH_ENV
-    VkResult res = loader_get_manifest_files(inst, NULL, NULL, true, false, DEFAULT_VK_ILAYERS_INFO, RELATIVE_VK_ILAYERS_INFO,
-                                             &manifest_files);
-    if (VK_SUCCESS != res || manifest_files.count == 0) {
-        return;
-    }
-
-    // Cleanup any previously scanned libraries
-    loader_delete_layer_properties(inst, instance_layers);
-
-    loader_platform_thread_lock_mutex(&loader_json_lock);
-
-    for (i = 0; i < manifest_files.count; i++) {
-        file_str = manifest_files.filename_list[i];
-        if (file_str == NULL) {
-            continue;
-        }
-
-        // parse file into JSON struct
-        res = loader_get_json(inst, file_str, &json);
-        if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
-            break;
-        } else if (VK_SUCCESS != res || NULL == json) {
-            continue;
-        }
-
-        res = loader_add_layer_properties(inst, instance_layers, json, true, file_str);
-
-        loader_instance_heap_free(inst, file_str);
-        cJSON_Delete(json);
-
-        if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
-            break;
-        }
-    }
-    loader_instance_heap_free(inst, manifest_files.filename_list);
-    loader_platform_thread_unlock_mutex(&loader_json_lock);
-}
-
-// Check if an implicit layer should be enabled.
-bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop) {
-    bool enable = false;
-    char *env_value = NULL;
-
-    // if no enable_environment variable is specified, this implicit layer
-    // should always be enabled. Otherwise check if the variable is set
-    if (prop->enable_env_var.name[0] == 0) {
-        enable = true;
-    } else {
-        env_value = loader_secure_getenv(prop->enable_env_var.name, inst);
-        if (env_value && !strcmp(prop->enable_env_var.value, env_value)) enable = true;
-        loader_free_getenv(env_value, inst);
-    }
-
-    // disable_environment has priority, i.e. if both enable and disable
-    // environment variables are set, the layer is disabled. Implicit
-    // layers are required to have a disable_environment variables
-    env_value = loader_secure_getenv(prop->disable_env_var.name, inst);
-    if (env_value && !strcmp(prop->disable_env_var.value, env_value)) enable = false;
-    loader_free_getenv(env_value, inst);
-
-    return enable;
-}
-
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_internal(VkInstance inst, const char *pName) {
-    // inst is not wrapped
-    if (inst == VK_NULL_HANDLE) {
-        return NULL;
-    }
-    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
-    void *addr;
-
-    if (disp_table == NULL) return NULL;
-
-    bool found_name;
-    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
-    if (found_name) {
-        return addr;
-    }
-
-    if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, true, NULL, &addr)) return addr;
-
-    // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_internal() unrecognized name %s", pName);
-    return NULL;
-}
-
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpdpa_instance_terminator(VkInstance inst, const char *pName) {
-    // inst is not wrapped
-    if (inst == VK_NULL_HANDLE) {
-        return NULL;
-    }
-    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
-    void *addr;
-
-    if (disp_table == NULL) return NULL;
-
-    bool found_name;
-    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
-    if (found_name) {
-        return addr;
-    }
-
-    // Get the terminator, but don't perform checking since it should already
-    // have been setup if we get here.
-    if (loader_phys_dev_ext_gpa(loader_get_instance(inst), pName, false, NULL, &addr)) {
-        return addr;
-    }
-
-    // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpdpa_instance_terminator() unrecognized name %s", pName);
-    return NULL;
-}
-
-static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_instance_internal(VkInstance inst, const char *pName) {
-    if (!strcmp(pName, "vkGetInstanceProcAddr")) {
-        return (PFN_vkVoidFunction)loader_gpa_instance_internal;
-    }
-    if (!strcmp(pName, "vk_layerGetPhysicalDeviceProcAddr")) {
-        return (PFN_vkVoidFunction)loader_gpdpa_instance_terminator;
-    }
-    if (!strcmp(pName, "vkCreateInstance")) {
-        return (PFN_vkVoidFunction)terminator_CreateInstance;
-    }
-    if (!strcmp(pName, "vkCreateDevice")) {
-        return (PFN_vkVoidFunction)terminator_CreateDevice;
-    }
-
-    // inst is not wrapped
-    if (inst == VK_NULL_HANDLE) {
-        return NULL;
-    }
-    VkLayerInstanceDispatchTable *disp_table = *(VkLayerInstanceDispatchTable **)inst;
-    void *addr;
-
-    if (disp_table == NULL) return NULL;
-
-    bool found_name;
-    addr = loader_lookup_instance_dispatch_table(disp_table, pName, &found_name);
-    if (found_name) {
-        return addr;
-    }
-
-    // Don't call down the chain, this would be an infinite loop
-    loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, "loader_gpa_instance_internal() unrecognized name %s", pName);
-    return NULL;
-}
-
-VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL loader_gpa_device_internal(VkDevice device, const char *pName) {
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
-
-    // Return this function if a layer above here is asking for the vkGetDeviceProcAddr.
-    // This is so we can properly intercept any device commands needing a terminator.
-    if (!strcmp(pName, "vkGetDeviceProcAddr")) {
-        return (PFN_vkVoidFunction)loader_gpa_device_internal;
-    }
-
-    // NOTE: Device Funcs needing Trampoline/Terminator.
-    // Overrides for device functions needing a trampoline and
-    // a terminator because certain device entry-points still need to go
-    // through a terminator before hitting the ICD.  This could be for
-    // several reasons, but the main one is currently unwrapping an
-    // object before passing the appropriate info along to the ICD.
-    // This is why we also have to override the direct ICD call to
-    // vkGetDeviceProcAddr to intercept those calls.
-    PFN_vkVoidFunction addr = get_extension_device_proc_terminator(pName);
-    if (NULL != addr) {
-        return addr;
-    }
-
-    return icd_term->dispatch.GetDeviceProcAddr(device, pName);
-}
-
-// Initialize device_ext dispatch table entry as follows:
-// If dev == NULL find all logical devices created within this instance and
-//  init the entry (given by idx) in the ext dispatch table.
-// If dev != NULL only initialize the entry in the given dev's dispatch table.
-// The initialization value is gotten by calling down the device chain with
-// GDPA.
-// If GDPA returns NULL then don't initialize the dispatch table entry.
-static void loader_init_dispatch_dev_ext_entry(struct loader_instance *inst, struct loader_device *dev, uint32_t idx,
-                                               const char *funcName)
-
-{
-    void *gdpa_value;
-    if (dev != NULL) {
-        gdpa_value = dev->loader_dispatch.core_dispatch.GetDeviceProcAddr(dev->chain_device, funcName);
-        if (gdpa_value != NULL) dev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value;
-    } else {
-        for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next) {
-            struct loader_device *ldev = icd_term->logical_device_list;
-            while (ldev) {
-                gdpa_value = ldev->loader_dispatch.core_dispatch.GetDeviceProcAddr(ldev->chain_device, funcName);
-                if (gdpa_value != NULL) ldev->loader_dispatch.ext_dispatch.dev_ext[idx] = (PFN_vkDevExt)gdpa_value;
-                ldev = ldev->next;
-            }
-        }
-    }
-}
-
-// Find all dev extension in the hash table  and initialize the dispatch table
-// for dev  for each of those extension entrypoints found in hash table.
-void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev) {
-    for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) {
-        if (inst->dev_ext_disp_hash[i].func_name != NULL)
-            loader_init_dispatch_dev_ext_entry(inst, dev, i, inst->dev_ext_disp_hash[i].func_name);
-    }
-}
-
-static bool loader_check_icds_for_dev_ext_address(struct loader_instance *inst, const char *funcName) {
-    struct loader_icd_term *icd_term;
-    icd_term = inst->icd_terms;
-    while (NULL != icd_term) {
-        if (icd_term->scanned_icd->GetInstanceProcAddr(icd_term->instance, funcName))
-            // this icd supports funcName
-            return true;
-        icd_term = icd_term->next;
-    }
-
-    return false;
-}
-
-static bool loader_check_layer_list_for_dev_ext_address(const struct loader_layer_list *const layers, const char *funcName) {
-    // Iterate over the layers.
-    for (uint32_t layer = 0; layer < layers->count; ++layer) {
-        // Iterate over the extensions.
-        const struct loader_device_extension_list *const extensions = &(layers->list[layer].device_extension_list);
-        for (uint32_t extension = 0; extension < extensions->count; ++extension) {
-            // Iterate over the entry points.
-            const struct loader_dev_ext_props *const property = &(extensions->list[extension]);
-            for (uint32_t entry = 0; entry < property->entrypoint_count; ++entry) {
-                if (strcmp(property->entrypoints[entry], funcName) == 0) {
-                    return true;
-                }
-            }
-        }
-    }
-
-    return false;
-}
-
-static void loader_free_dev_ext_table(struct loader_instance *inst) {
-    for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) {
-        loader_instance_heap_free(inst, inst->dev_ext_disp_hash[i].func_name);
-        loader_instance_heap_free(inst, inst->dev_ext_disp_hash[i].list.index);
-    }
-    memset(inst->dev_ext_disp_hash, 0, sizeof(inst->dev_ext_disp_hash));
-}
-
-static bool loader_add_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) {
-    uint32_t i;
-    uint32_t idx = *ptr_idx;
-    struct loader_dispatch_hash_list *list = &inst->dev_ext_disp_hash[idx].list;
-
-    if (!inst->dev_ext_disp_hash[idx].func_name) {
-        // no entry here at this idx, so use it
-        assert(list->capacity == 0);
-        inst->dev_ext_disp_hash[idx].func_name =
-            (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (inst->dev_ext_disp_hash[idx].func_name == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_dev_ext_table: Failed to allocate memory "
-                       "for func_name %s",
-                       funcName);
-            return false;
-        }
-        strncpy(inst->dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1);
-        return true;
-    }
-
-    // check for enough capacity
-    if (list->capacity == 0) {
-        list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (list->index == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_dev_ext_table: Failed to allocate memory for list index",
-                       funcName);
-            return false;
-        }
-        list->capacity = 8 * sizeof(*(list->index));
-    } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) {
-        void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2,
-                                                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == new_ptr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_dev_ext_table: Failed to reallocate memory for list index", funcName);
-            return false;
-        }
-        list->index = new_ptr;
-        list->capacity *= 2;
-    }
-
-    // find an unused index in the hash table and use it
-    i = (idx + 1) % MAX_NUM_UNKNOWN_EXTS;
-    do {
-        if (!inst->dev_ext_disp_hash[i].func_name) {
-            assert(inst->dev_ext_disp_hash[i].list.capacity == 0);
-            inst->dev_ext_disp_hash[i].func_name =
-                (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (inst->dev_ext_disp_hash[i].func_name == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_dev_ext_table: Failed to allocate memory "
-                           "for func_name %s",
-                           funcName);
-                return false;
-            }
-            strncpy(inst->dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1);
-            list->index[list->count] = i;
-            list->count++;
-            *ptr_idx = i;
-            return true;
-        }
-        i = (i + 1) % MAX_NUM_UNKNOWN_EXTS;
-    } while (i != idx);
-
-    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-               "loader_add_dev_ext_table:  Could not insert into hash table; is "
-               "it full?");
-
-    return false;
-}
-
-static bool loader_name_in_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) {
-    uint32_t alt_idx;
-    if (inst->dev_ext_disp_hash[*idx].func_name && !strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName)) return true;
-
-    // funcName wasn't at the primary spot in the hash table
-    // search the list of secondary locations (shallow search, not deep search)
-    for (uint32_t i = 0; i < inst->dev_ext_disp_hash[*idx].list.count; i++) {
-        alt_idx = inst->dev_ext_disp_hash[*idx].list.index[i];
-        if (!strcmp(inst->dev_ext_disp_hash[*idx].func_name, funcName)) {
-            *idx = alt_idx;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// This function returns generic trampoline code address for unknown entry
-// points.
-// Presumably, these unknown entry points (as given by funcName) are device
-// extension entrypoints.  A hash table is used to keep a list of unknown entry
-// points and their mapping to the device extension dispatch table
-// (struct loader_dev_ext_dispatch_table).
-// \returns
-// For a given entry point string (funcName), if an existing mapping is found
-// the
-// trampoline address for that mapping is returned. Otherwise, this unknown
-// entry point
-// has not been seen yet. Next check if a layer or ICD supports it.  If so then
-// a
-// new entry in the hash table is initialized and that trampoline address for
-// the new entry is returned. Null is returned if the hash table is full or
-// if no discovered layer or ICD returns a non-NULL GetProcAddr for it.
-void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName) {
-    uint32_t idx;
-    uint32_t seed = 0;
-
-    idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_UNKNOWN_EXTS;
-
-    if (loader_name_in_dev_ext_table(inst, &idx, funcName))
-        // found funcName already in hash
-        return loader_get_dev_ext_trampoline(idx);
-
-    // Check if funcName is supported in either ICDs or a layer library
-    if (!loader_check_icds_for_dev_ext_address(inst, funcName) &&
-        !loader_check_layer_list_for_dev_ext_address(&inst->app_activated_layer_list, funcName)) {
-        // if support found in layers continue on
-        return NULL;
-    }
-
-    if (loader_add_dev_ext_table(inst, &idx, funcName)) {
-        // successfully added new table entry
-        // init any dev dispatch table entries as needed
-        loader_init_dispatch_dev_ext_entry(inst, NULL, idx, funcName);
-        return loader_get_dev_ext_trampoline(idx);
-    }
-
-    return NULL;
-}
-
-static bool loader_check_icds_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) {
-    struct loader_icd_term *icd_term;
-    icd_term = inst->icd_terms;
-    while (NULL != icd_term) {
-        if (icd_term->scanned_icd->interface_version >= MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION &&
-            icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName))
-            // this icd supports funcName
-            return true;
-        icd_term = icd_term->next;
-    }
-
-    return false;
-}
-
-static bool loader_check_layer_list_for_phys_dev_ext_address(struct loader_instance *inst, const char *funcName) {
-    struct loader_layer_properties *layer_prop_list = inst->expanded_activated_layer_list.list;
-    for (uint32_t layer = 0; layer < inst->expanded_activated_layer_list.count; ++layer) {
-        // If this layer supports the vk_layerGetPhysicalDeviceProcAddr, then call
-        // it and see if it returns a valid pointer for this function name.
-        if (layer_prop_list[layer].interface_version > 1) {
-            const struct loader_layer_functions *const functions = &(layer_prop_list[layer].functions);
-            if (NULL != functions->get_physical_device_proc_addr &&
-                NULL != functions->get_physical_device_proc_addr((VkInstance)inst->instance, funcName)) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-static void loader_free_phys_dev_ext_table(struct loader_instance *inst) {
-    for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) {
-        loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].func_name);
-        loader_instance_heap_free(inst, inst->phys_dev_ext_disp_hash[i].list.index);
-    }
-    memset(inst->phys_dev_ext_disp_hash, 0, sizeof(inst->phys_dev_ext_disp_hash));
-}
-
-static bool loader_add_phys_dev_ext_table(struct loader_instance *inst, uint32_t *ptr_idx, const char *funcName) {
-    uint32_t i;
-    uint32_t idx = *ptr_idx;
-    struct loader_dispatch_hash_list *list = &inst->phys_dev_ext_disp_hash[idx].list;
-
-    if (!inst->phys_dev_ext_disp_hash[idx].func_name) {
-        // no entry here at this idx, so use it
-        assert(list->capacity == 0);
-        inst->phys_dev_ext_disp_hash[idx].func_name =
-            (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (inst->phys_dev_ext_disp_hash[idx].func_name == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_add_phys_dev_ext_table() can't allocate memory for "
-                       "func_name");
-            return false;
-        }
-        strncpy(inst->phys_dev_ext_disp_hash[idx].func_name, funcName, strlen(funcName) + 1);
-        return true;
-    }
-
-    // check for enough capacity
-    if (list->capacity == 0) {
-        list->index = loader_instance_heap_alloc(inst, 8 * sizeof(*(list->index)), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (list->index == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't allocate list memory");
-            return false;
-        }
-        list->capacity = 8 * sizeof(*(list->index));
-    } else if (list->capacity < (list->count + 1) * sizeof(*(list->index))) {
-        void *new_ptr = loader_instance_heap_realloc(inst, list->index, list->capacity, list->capacity * 2,
-                                                     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-        if (NULL == new_ptr) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "loader_add_phys_dev_ext_table() can't reallocate list memory");
-            return false;
-        }
-        list->index = new_ptr;
-        list->capacity *= 2;
-    }
-
-    // find an unused index in the hash table and use it
-    i = (idx + 1) % MAX_NUM_UNKNOWN_EXTS;
-    do {
-        if (!inst->phys_dev_ext_disp_hash[i].func_name) {
-            assert(inst->phys_dev_ext_disp_hash[i].list.capacity == 0);
-            inst->phys_dev_ext_disp_hash[i].func_name =
-                (char *)loader_instance_heap_alloc(inst, strlen(funcName) + 1, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (inst->phys_dev_ext_disp_hash[i].func_name == NULL) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_add_dev_ext_table() can't reallocate "
-                           "func_name memory");
-                return false;
-            }
-            strncpy(inst->phys_dev_ext_disp_hash[i].func_name, funcName, strlen(funcName) + 1);
-            list->index[list->count] = i;
-            list->count++;
-            *ptr_idx = i;
-            return true;
-        }
-        i = (i + 1) % MAX_NUM_UNKNOWN_EXTS;
-    } while (i != idx);
-
-    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-               "loader_add_phys_dev_ext_table() couldn't insert into hash table; is "
-               "it full?");
-    return false;
-}
-
-static bool loader_name_in_phys_dev_ext_table(struct loader_instance *inst, uint32_t *idx, const char *funcName) {
-    uint32_t alt_idx;
-    if (inst->phys_dev_ext_disp_hash[*idx].func_name && !strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName))
-        return true;
-
-    // funcName wasn't at the primary spot in the hash table
-    // search the list of secondary locations (shallow search, not deep search)
-    for (uint32_t i = 0; i < inst->phys_dev_ext_disp_hash[*idx].list.count; i++) {
-        alt_idx = inst->phys_dev_ext_disp_hash[*idx].list.index[i];
-        if (!strcmp(inst->phys_dev_ext_disp_hash[*idx].func_name, funcName)) {
-            *idx = alt_idx;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-// This function returns a generic trampoline and/or terminator function
-// address for any unknown physical device extension commands.  A hash
-// table is used to keep a list of unknown entry points and their
-// mapping to the physical device extension dispatch table (struct
-// loader_phys_dev_ext_dispatch_table).
-// For a given entry point string (funcName), if an existing mapping is
-// found, then the trampoline address for that mapping is returned in
-// tramp_addr (if it is not NULL) and the terminator address for that
-// mapping is returned in term_addr (if it is not NULL). Otherwise,
-// this unknown entry point has not been seen yet.
-// If it has not been seen before, and perform_checking is 'true',
-// check if a layer or and ICD supports it.  If so then a new entry in
-// the hash table is initialized and the trampoline and/or terminator
-// addresses are returned.
-// Null is returned if the hash table is full or if no discovered layer or
-// ICD returns a non-NULL GetProcAddr for it.
-bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr,
-                             void **term_addr) {
-    uint32_t idx;
-    uint32_t seed = 0;
-    bool success = false;
-
-    if (inst == NULL) {
-        goto out;
-    }
-
-    if (NULL != tramp_addr) {
-        *tramp_addr = NULL;
-    }
-    if (NULL != term_addr) {
-        *term_addr = NULL;
-    }
-
-    // We should always check to see if any ICD supports it.
-    if (!loader_check_icds_for_phys_dev_ext_address(inst, funcName)) {
-        // If we're not checking layers, or we are and it's not in a layer, just
-        // return
-        if (!perform_checking || !loader_check_layer_list_for_phys_dev_ext_address(inst, funcName)) {
-            goto out;
-        }
-    }
-
-    idx = murmurhash(funcName, strlen(funcName), seed) % MAX_NUM_UNKNOWN_EXTS;
-    if (perform_checking && !loader_name_in_phys_dev_ext_table(inst, &idx, funcName)) {
-        uint32_t i;
-        bool added = false;
-
-        // Only need to add first one to get index in Instance.  Others will use
-        // the same index.
-        if (!added && loader_add_phys_dev_ext_table(inst, &idx, funcName)) {
-            added = true;
-        }
-
-        // Setup the ICD function pointers
-        struct loader_icd_term *icd_term = inst->icd_terms;
-        while (NULL != icd_term) {
-            if (MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION <= icd_term->scanned_icd->interface_version &&
-                NULL != icd_term->scanned_icd->GetPhysicalDeviceProcAddr) {
-                icd_term->phys_dev_ext[idx] =
-                    (PFN_PhysDevExt)icd_term->scanned_icd->GetPhysicalDeviceProcAddr(icd_term->instance, funcName);
-
-                // Make sure we set the instance dispatch to point to the
-                // loader's terminator now since we can at least handle it
-                // in one ICD.
-                inst->disp->phys_dev_ext[idx] = loader_get_phys_dev_ext_termin(idx);
-            } else {
-                icd_term->phys_dev_ext[idx] = NULL;
-            }
-
-            icd_term = icd_term->next;
-        }
-
-        // Now, search for the first layer attached and query using it to get
-        // the first entry point.
-        for (i = 0; i < inst->expanded_activated_layer_list.count; i++) {
-            struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i];
-            if (layer_prop->interface_version > 1 && NULL != layer_prop->functions.get_physical_device_proc_addr) {
-                inst->disp->phys_dev_ext[idx] =
-                    (PFN_PhysDevExt)layer_prop->functions.get_physical_device_proc_addr((VkInstance)inst->instance, funcName);
-                if (NULL != inst->disp->phys_dev_ext[idx]) {
-                    break;
-                }
-            }
-        }
-    }
-
-    if (NULL != tramp_addr) {
-        *tramp_addr = loader_get_phys_dev_ext_tramp(idx);
-    }
-
-    if (NULL != term_addr) {
-        *term_addr = loader_get_phys_dev_ext_termin(idx);
-    }
-
-    success = true;
-
-out:
-    return success;
-}
-
-struct loader_instance *loader_get_instance(const VkInstance instance) {
-    // look up the loader_instance in our list by comparing dispatch tables, as
-    // there is no guarantee the instance is still a loader_instance* after any
-    // layers which wrap the instance object.
-    const VkLayerInstanceDispatchTable *disp;
-    struct loader_instance *ptr_instance = NULL;
-    disp = loader_get_instance_layer_dispatch(instance);
-    for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
-        if (&inst->disp->layer_inst_disp == disp) {
-            ptr_instance = inst;
-            break;
-        }
-    }
-    return ptr_instance;
-}
-
-static loader_platform_dl_handle loader_open_layer_lib(const struct loader_instance *inst, const char *chain_type,
-                                                       struct loader_layer_properties *prop) {
-    if ((prop->lib_handle = loader_platform_open_library(prop->lib_name)) == NULL) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, loader_platform_open_library_error(prop->lib_name));
-    } else {
-        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Loading layer library %s", prop->lib_name);
-    }
-
-    return prop->lib_handle;
-}
-
-static void loader_close_layer_lib(const struct loader_instance *inst, struct loader_layer_properties *prop) {
-    if (prop->lib_handle) {
-        loader_platform_close_library(prop->lib_handle);
-        loader_log(inst, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Unloading layer library %s", prop->lib_name);
-        prop->lib_handle = NULL;
-    }
-}
-
-void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device,
-                              struct loader_layer_list *list) {
-    // Delete instance list of enabled layers and close any layer libraries
-    for (uint32_t i = 0; i < list->count; i++) {
-        struct loader_layer_properties *layer_prop = &list->list[i];
-
-        loader_close_layer_lib(instance, layer_prop);
-    }
-    loader_destroy_layer_list(instance, device, list);
-}
-
-// Go through the search_list and find any layers which match type. If layer
-// type match is found in then add it to ext_list.
-static void loader_add_implicit_layers(const struct loader_instance *inst, struct loader_layer_list *target_list,
-                                       struct loader_layer_list *expanded_target_list,
-                                       const struct loader_layer_list *source_list) {
-    for (uint32_t src_layer = 0; src_layer < source_list->count; src_layer++) {
-        const struct loader_layer_properties *prop = &source_list->list[src_layer];
-        if (0 == (prop->type_flags & VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER)) {
-            loader_add_implicit_layer(inst, prop, target_list, expanded_target_list, source_list);
-        }
-    }
-}
-
-// Get the layer name(s) from the env_name environment variable. If layer is found in
-// search_list then add it to layer_list.  But only add it to layer_list if type_flags matches.
-static void loader_add_env_layers(const struct loader_instance *inst, const enum layer_type_flags type_flags, const char *env_name,
-                                  struct loader_layer_list *target_list, struct loader_layer_list *expanded_target_list,
-                                  const struct loader_layer_list *source_list) {
-    char *next, *name;
-    char *layer_env = loader_secure_getenv(env_name, inst);
-    if (layer_env == NULL) {
-        goto out;
-    }
-    name = loader_stack_alloc(strlen(layer_env) + 1);
-    if (name == NULL) {
-        goto out;
-    }
-    strcpy(name, layer_env);
-
-    while (name && *name) {
-        next = loader_get_next_path(name);
-        loader_find_layer_name_add_list(inst, name, type_flags, source_list, target_list, expanded_target_list);
-        name = next;
-    }
-
-out:
-
-    if (layer_env != NULL) {
-        loader_free_getenv(layer_env, inst);
-    }
-
-    return;
-}
-
-VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
-                                       const struct loader_layer_list *instance_layers) {
-    VkResult err;
-
-    assert(inst && "Cannot have null instance");
-
-    if (!loader_init_layer_list(inst, &inst->app_activated_layer_list)) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_enable_instance_layers: Failed to initialize"
-                   " application version of the layer list");
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    if (!loader_init_layer_list(inst, &inst->expanded_activated_layer_list)) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_enable_instance_layers: Failed to initialize"
-                   " expanded version of the layer list");
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    // Add any implicit layers first
-    loader_add_implicit_layers(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list, instance_layers);
-
-    // Add any layers specified via environment variable next
-    loader_add_env_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, ENABLED_LAYERS_ENV, &inst->app_activated_layer_list,
-                          &inst->expanded_activated_layer_list, instance_layers);
-
-    // Add layers specified by the application
-    err = loader_add_layer_names_to_list(inst, &inst->app_activated_layer_list, &inst->expanded_activated_layer_list,
-                                         pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, instance_layers);
-
-    return err;
-}
-
-// Determine the layer interface version to use.
-bool loader_get_layer_interface_version(PFN_vkNegotiateLoaderLayerInterfaceVersion fp_negotiate_layer_version,
-                                        VkNegotiateLayerInterface *interface_struct) {
-    memset(interface_struct, 0, sizeof(VkNegotiateLayerInterface));
-    interface_struct->sType = LAYER_NEGOTIATE_INTERFACE_STRUCT;
-    interface_struct->loaderLayerInterfaceVersion = 1;
-
-    if (fp_negotiate_layer_version != NULL) {
-        // Layer supports the negotiation API, so call it with the loader's
-        // latest version supported
-        interface_struct->loaderLayerInterfaceVersion = CURRENT_LOADER_LAYER_INTERFACE_VERSION;
-        VkResult result = fp_negotiate_layer_version(interface_struct);
-
-        if (result != VK_SUCCESS) {
-            // Layer no longer supports the loader's latest interface version so
-            // fail loading the Layer
-            return false;
-        }
-    }
-
-    if (interface_struct->loaderLayerInterfaceVersion < MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION) {
-        // Loader no longer supports the layer's latest interface version so
-        // fail loading the layer
-        return false;
-    }
-
-    return true;
-}
-
-// Given the list of layers to activate in the loader_instance
-// structure. This function will add a VkLayerInstanceCreateInfo
-// structure to the VkInstanceCreateInfo.pNext pointer.
-// Each activated layer will have it's own VkLayerInstanceLink
-// structure that tells the layer what Get*ProcAddr to call to
-// get function pointers to the next layer down.
-// Once the chain info has been created this function will
-// execute the CreateInstance call chain. Each layer will
-// then have an opportunity in it's CreateInstance function
-// to setup it's dispatch table when the lower layer returns
-// successfully.
-// Each layer can wrap or not-wrap the returned VkInstance object
-// as it sees fit.
-// The instance chain is terminated by a loader function
-// that will call CreateInstance on all available ICD's and
-// cache those VkInstance objects for future use.
-VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
-                                      struct loader_instance *inst, VkInstance *created_instance) {
-    uint32_t activated_layers = 0;
-    VkLayerInstanceCreateInfo chain_info;
-    VkLayerInstanceLink *layer_instance_link_info = NULL;
-    VkInstanceCreateInfo loader_create_info;
-    VkResult res;
-
-    PFN_vkGetInstanceProcAddr next_gipa = loader_gpa_instance_internal;
-    PFN_vkGetInstanceProcAddr cur_gipa = loader_gpa_instance_internal;
-    PFN_GetPhysicalDeviceProcAddr next_gpdpa = loader_gpdpa_instance_internal;
-    PFN_GetPhysicalDeviceProcAddr cur_gpdpa = loader_gpdpa_instance_internal;
-
-    memcpy(&loader_create_info, pCreateInfo, sizeof(VkInstanceCreateInfo));
-
-    if (inst->expanded_activated_layer_list.count > 0) {
-        chain_info.u.pLayerInfo = NULL;
-        chain_info.pNext = pCreateInfo->pNext;
-        chain_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
-        chain_info.function = VK_LAYER_LINK_INFO;
-        loader_create_info.pNext = &chain_info;
-
-        layer_instance_link_info = loader_stack_alloc(sizeof(VkLayerInstanceLink) * inst->expanded_activated_layer_list.count);
-        if (!layer_instance_link_info) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_create_instance_chain: Failed to alloc Instance"
-                       " objects for layer");
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-
-        // Create instance chain of enabled layers
-        for (int32_t i = inst->expanded_activated_layer_list.count - 1; i >= 0; i--) {
-            struct loader_layer_properties *layer_prop = &inst->expanded_activated_layer_list.list[i];
-            loader_platform_dl_handle lib_handle;
-
-            lib_handle = loader_open_layer_lib(inst, "instance", layer_prop);
-            if (!lib_handle) {
-                continue;
-            }
-
-            if (NULL == layer_prop->functions.negotiate_layer_interface) {
-                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL;
-                bool functions_in_interface = false;
-                if (strlen(layer_prop->functions.str_negotiate_interface) == 0) {
-                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
-                        lib_handle, "vkNegotiateLoaderLayerInterfaceVersion");
-                } else {
-                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
-                        lib_handle, layer_prop->functions.str_negotiate_interface);
-                }
-
-                // If we can negotiate an interface version, then we can also
-                // get everything we need from the one function call, so try
-                // that first, and see if we can get all the function pointers
-                // necessary from that one call.
-                if (NULL != negotiate_interface) {
-                    layer_prop->functions.negotiate_layer_interface = negotiate_interface;
-
-                    VkNegotiateLayerInterface interface_struct;
-
-                    if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) {
-                        // Go ahead and set the properties version to the
-                        // correct value.
-                        layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion;
-
-                        // If the interface is 2 or newer, we have access to the
-                        // new GetPhysicalDeviceProcAddr function, so grab it,
-                        // and the other necessary functions, from the
-                        // structure.
-                        if (interface_struct.loaderLayerInterfaceVersion > 1) {
-                            cur_gipa = interface_struct.pfnGetInstanceProcAddr;
-                            cur_gpdpa = interface_struct.pfnGetPhysicalDeviceProcAddr;
-                            if (cur_gipa != NULL) {
-                                // We've set the functions, so make sure we
-                                // don't do the unnecessary calls later.
-                                functions_in_interface = true;
-                            }
-                        }
-                    }
-                }
-
-                if (!functions_in_interface) {
-                    if ((cur_gipa = layer_prop->functions.get_instance_proc_addr) == NULL) {
-                        if (strlen(layer_prop->functions.str_gipa) == 0) {
-                            cur_gipa =
-                                (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr");
-                            layer_prop->functions.get_instance_proc_addr = cur_gipa;
-                        } else {
-                            cur_gipa = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle,
-                                                                                                   layer_prop->functions.str_gipa);
-                        }
-
-                        if (NULL == cur_gipa) {
-                            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                       "loader_create_instance_chain: Failed to"
-                                       " find \'vkGetInstanceProcAddr\' in "
-                                       "layer %s",
-                                       layer_prop->lib_name);
-                            continue;
-                        }
-                    }
-                }
-            }
-
-            layer_instance_link_info[activated_layers].pNext = chain_info.u.pLayerInfo;
-            layer_instance_link_info[activated_layers].pfnNextGetInstanceProcAddr = next_gipa;
-            layer_instance_link_info[activated_layers].pfnNextGetPhysicalDeviceProcAddr = next_gpdpa;
-            next_gipa = cur_gipa;
-            if (layer_prop->interface_version > 1 && cur_gpdpa != NULL) {
-                layer_prop->functions.get_physical_device_proc_addr = cur_gpdpa;
-                next_gpdpa = cur_gpdpa;
-            }
-
-            chain_info.u.pLayerInfo = &layer_instance_link_info[activated_layers];
-
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Insert instance layer %s (%s)", layer_prop->info.layerName,
-                       layer_prop->lib_name);
-
-            activated_layers++;
-        }
-    }
-
-    PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)next_gipa(*created_instance, "vkCreateInstance");
-    if (fpCreateInstance) {
-        VkLayerInstanceCreateInfo create_info_disp;
-
-        create_info_disp.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
-        create_info_disp.function = VK_LOADER_DATA_CALLBACK;
-
-        create_info_disp.u.pfnSetInstanceLoaderData = vkSetInstanceDispatch;
-
-        create_info_disp.pNext = loader_create_info.pNext;
-        loader_create_info.pNext = &create_info_disp;
-        res = fpCreateInstance(&loader_create_info, pAllocator, created_instance);
-    } else {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_instance_chain: Failed to find "
-                   "\'vkCreateInstance\'");
-        // Couldn't find CreateInstance function!
-        res = VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    if (res == VK_SUCCESS) {
-        loader_init_instance_core_dispatch_table(&inst->disp->layer_inst_disp, next_gipa, *created_instance);
-        inst->instance = *created_instance;
-    }
-
-    return res;
-}
-
-void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst) {
-    loader_init_instance_extension_dispatch_table(&inst->disp->layer_inst_disp, inst->disp->layer_inst_disp.GetInstanceProcAddr,
-                                                  created_inst);
-}
-
-VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo,
-                                    const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
-                                    struct loader_device *dev) {
-    uint32_t activated_layers = 0;
-    VkLayerDeviceLink *layer_device_link_info;
-    VkLayerDeviceCreateInfo chain_info;
-    VkDeviceCreateInfo loader_create_info;
-    VkResult res;
-
-    PFN_vkGetDeviceProcAddr fpGDPA = NULL, nextGDPA = loader_gpa_device_internal;
-    PFN_vkGetInstanceProcAddr fpGIPA = NULL, nextGIPA = loader_gpa_instance_internal;
-
-    memcpy(&loader_create_info, pCreateInfo, sizeof(VkDeviceCreateInfo));
-
-    // Before we continue, we need to find out if the KHX_device_group extension is in the enabled list.  If it is, we then
-    // need to look for the corresponding VkDeviceGroupDeviceCreateInfoKHX struct in the device list.  This is because we
-    // need to replace all the incoming physical device values (which are really loader trampoline physical device values)
-    // with the layer/ICD version.
-    if (inst->enabled_known_extensions.khx_device_group_creation == 1) {
-        struct VkStructureHeader *pNext = (struct VkStructureHeader *)loader_create_info.pNext;
-        struct VkStructureHeader *pPrev = (struct VkStructureHeader *)&loader_create_info;
-        while (NULL != pNext) {
-            if (VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX == pNext->sType) {
-                VkDeviceGroupDeviceCreateInfoKHX *cur_struct = (VkDeviceGroupDeviceCreateInfoKHX *)pNext;
-                if (0 < cur_struct->physicalDeviceCount && NULL != cur_struct->pPhysicalDevices) {
-                    VkDeviceGroupDeviceCreateInfoKHX *temp_struct = loader_stack_alloc(sizeof(VkDeviceGroupDeviceCreateInfoKHX));
-                    VkPhysicalDevice *phys_dev_array = NULL;
-                    if (NULL == temp_struct) {
-                        return VK_ERROR_OUT_OF_HOST_MEMORY;
-                    }
-                    memcpy(temp_struct, cur_struct, sizeof(VkDeviceGroupDeviceCreateInfoKHX));
-                    phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * cur_struct->physicalDeviceCount);
-                    if (NULL == phys_dev_array) {
-                        return VK_ERROR_OUT_OF_HOST_MEMORY;
-                    }
-
-                    // Before calling down, replace the incoming physical device values (which are really loader trampoline
-                    // physical devices) with the next layer (or possibly even the terminator) physical device values.
-                    struct loader_physical_device_tramp *cur_tramp;
-                    for (uint32_t phys_dev = 0; phys_dev < cur_struct->physicalDeviceCount; phys_dev++) {
-                        cur_tramp = (struct loader_physical_device_tramp *)cur_struct->pPhysicalDevices[phys_dev];
-                        phys_dev_array[phys_dev] = cur_tramp->phys_dev;
-                    }
-                    temp_struct->pPhysicalDevices = phys_dev_array;
-
-                    // Replace the old struct in the pNext chain with this one.
-                    pPrev->pNext = (const void *)temp_struct;
-                    pNext = (struct VkStructureHeader *)(temp_struct);
-                }
-                break;
-            }
-
-            pPrev = pNext;
-            pNext = (struct VkStructureHeader *)(pPrev->pNext);
-        }
-    }
-
-    layer_device_link_info = loader_stack_alloc(sizeof(VkLayerDeviceLink) * dev->expanded_activated_layer_list.count);
-    if (!layer_device_link_info) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_device_chain: Failed to alloc Device objects"
-                   " for layer.  Skipping Layer.");
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    if (dev->expanded_activated_layer_list.count > 0) {
-        chain_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
-        chain_info.function = VK_LAYER_LINK_INFO;
-        chain_info.u.pLayerInfo = NULL;
-        chain_info.pNext = loader_create_info.pNext;
-        loader_create_info.pNext = &chain_info;
-
-        // Create instance chain of enabled layers
-        for (int32_t i = dev->expanded_activated_layer_list.count - 1; i >= 0; i--) {
-            struct loader_layer_properties *layer_prop = &dev->expanded_activated_layer_list.list[i];
-            loader_platform_dl_handle lib_handle;
-            bool functions_in_interface = false;
-
-            lib_handle = loader_open_layer_lib(inst, "device", layer_prop);
-            if (!lib_handle) {
-                continue;
-            }
-
-            // If we can negotiate an interface version, then we can also get everything we need from the one function
-            // call, so try that first, and see if we can get all the function pointers necessary from that one call.
-            if (NULL == layer_prop->functions.negotiate_layer_interface) {
-                PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_interface = NULL;
-                if (strlen(layer_prop->functions.str_negotiate_interface) == 0) {
-                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
-                        lib_handle, "vkNegotiateLoaderLayerInterfaceVersion");
-                } else {
-                    negotiate_interface = (PFN_vkNegotiateLoaderLayerInterfaceVersion)loader_platform_get_proc_address(
-                        lib_handle, layer_prop->functions.str_negotiate_interface);
-                }
-
-                if (NULL != negotiate_interface) {
-                    layer_prop->functions.negotiate_layer_interface = negotiate_interface;
-
-                    VkNegotiateLayerInterface interface_struct;
-
-                    if (loader_get_layer_interface_version(negotiate_interface, &interface_struct)) {
-                        // Go ahead and set the properties version to the correct value.
-                        layer_prop->interface_version = interface_struct.loaderLayerInterfaceVersion;
-
-                        // If the interface is 2 or newer, we have access to the new GetPhysicalDeviceProcAddr
-                        // function, so grab it, and the other necessary functions, from the structure.
-                        if (interface_struct.loaderLayerInterfaceVersion > 1) {
-                            fpGIPA = interface_struct.pfnGetInstanceProcAddr;
-                            fpGDPA = interface_struct.pfnGetDeviceProcAddr;
-                            if (fpGIPA != NULL && fpGDPA) {
-                                // We've set the functions, so make sure we
-                                // don't do the unnecessary calls later.
-                                functions_in_interface = true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (!functions_in_interface) {
-                if ((fpGIPA = layer_prop->functions.get_instance_proc_addr) == NULL) {
-                    if (strlen(layer_prop->functions.str_gipa) == 0) {
-                        fpGIPA = (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetInstanceProcAddr");
-                        layer_prop->functions.get_instance_proc_addr = fpGIPA;
-                    } else
-                        fpGIPA =
-                            (PFN_vkGetInstanceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gipa);
-                    if (!fpGIPA) {
-                        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                   "loader_create_device_chain: Failed to find "
-                                   "\'vkGetInstanceProcAddr\' in layer %s.  Skipping"
-                                   " layer.",
-                                   layer_prop->lib_name);
-                        continue;
-                    }
-                }
-                if ((fpGDPA = layer_prop->functions.get_device_proc_addr) == NULL) {
-                    if (strlen(layer_prop->functions.str_gdpa) == 0) {
-                        fpGDPA = (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, "vkGetDeviceProcAddr");
-                        layer_prop->functions.get_device_proc_addr = fpGDPA;
-                    } else
-                        fpGDPA =
-                            (PFN_vkGetDeviceProcAddr)loader_platform_get_proc_address(lib_handle, layer_prop->functions.str_gdpa);
-                    if (!fpGDPA) {
-                        loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Failed to find vkGetDeviceProcAddr in layer %s",
-                                   layer_prop->lib_name);
-                        continue;
-                    }
-                }
-            }
-            layer_device_link_info[activated_layers].pNext = chain_info.u.pLayerInfo;
-            layer_device_link_info[activated_layers].pfnNextGetInstanceProcAddr = nextGIPA;
-            layer_device_link_info[activated_layers].pfnNextGetDeviceProcAddr = nextGDPA;
-            chain_info.u.pLayerInfo = &layer_device_link_info[activated_layers];
-            nextGIPA = fpGIPA;
-            nextGDPA = fpGDPA;
-
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0, "Inserted device layer %s (%s)", layer_prop->info.layerName,
-                       layer_prop->lib_name);
-
-            activated_layers++;
-        }
-    }
-
-    VkDevice created_device = (VkDevice)dev;
-    PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)nextGIPA(inst->instance, "vkCreateDevice");
-    if (fpCreateDevice) {
-        VkLayerDeviceCreateInfo create_info_disp;
-
-        create_info_disp.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
-        create_info_disp.function = VK_LOADER_DATA_CALLBACK;
-
-        create_info_disp.u.pfnSetDeviceLoaderData = vkSetDeviceDispatch;
-
-        create_info_disp.pNext = loader_create_info.pNext;
-        loader_create_info.pNext = &create_info_disp;
-        res = fpCreateDevice(pd->phys_dev, &loader_create_info, pAllocator, &created_device);
-        if (res != VK_SUCCESS) {
-            return res;
-        }
-        dev->chain_device = created_device;
-    } else {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "loader_create_device_chain: Failed to find \'vkCreateDevice\' "
-                   "in layer %s");
-        // Couldn't find CreateDevice function!
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-
-    // Initialize device dispatch table
-    loader_init_device_dispatch_table(&dev->loader_dispatch, nextGDPA, dev->chain_device);
-
-    return res;
-}
-
-VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
-                                const char *const *ppEnabledLayerNames, const struct loader_layer_list *list) {
-    struct loader_layer_properties *prop;
-
-    for (uint32_t i = 0; i < layer_count; i++) {
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, ppEnabledLayerNames[i]);
-        if (result != VK_STRING_ERROR_NONE) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_layers: Device ppEnabledLayerNames "
-                       "contains string that is too long or is badly formed");
-            return VK_ERROR_LAYER_NOT_PRESENT;
-        }
-
-        prop = loader_get_layer_property(ppEnabledLayerNames[i], list);
-        if (NULL == prop) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_layers: Layer %d does not exist in the list of available layers", i);
-            return VK_ERROR_LAYER_NOT_PRESENT;
-        }
-    }
-    return VK_SUCCESS;
-}
-
-VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts,
-                                             const struct loader_layer_list *instance_layers,
-                                             const VkInstanceCreateInfo *pCreateInfo) {
-    VkExtensionProperties *extension_prop;
-    char *env_value;
-    bool check_if_known = true;
-    VkResult res = VK_SUCCESS;
-
-    struct loader_layer_list active_layers;
-    struct loader_layer_list expanded_layers;
-    memset(&active_layers, 0, sizeof(active_layers));
-    memset(&expanded_layers, 0, sizeof(expanded_layers));
-    if (!loader_init_layer_list(inst, &active_layers)) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    if (!loader_init_layer_list(inst, &expanded_layers)) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    // Build the lists of active layers (including metalayers) and expanded layers (with metalayers resolved to their components)
-    loader_add_implicit_layers(inst, &active_layers, &expanded_layers, instance_layers);
-    loader_add_env_layers(inst, VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER, ENABLED_LAYERS_ENV, &active_layers, &expanded_layers,
-                          instance_layers);
-    res = loader_add_layer_names_to_list(inst, &active_layers, &expanded_layers, pCreateInfo->enabledLayerCount,
-                                         pCreateInfo->ppEnabledLayerNames, instance_layers);
-    if (VK_SUCCESS != res) {
-        goto out;
-    }
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
-        if (result != VK_STRING_ERROR_NONE) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_instance_extensions: Instance ppEnabledExtensionNames contains "
-                       "string that is too long or is badly formed");
-            res = VK_ERROR_EXTENSION_NOT_PRESENT;
-            goto out;
-        }
-
-        // Check if a user wants to disable the instance extension filtering behavior
-        env_value = loader_getenv("VK_LOADER_DISABLE_INST_EXT_FILTER", inst);
-        if (NULL != env_value && atoi(env_value) != 0) {
-            check_if_known = false;
-        }
-        loader_free_getenv(env_value, inst);
-
-        if (check_if_known) {
-            // See if the extension is in the list of supported extensions
-            bool found = false;
-            for (uint32_t j = 0; LOADER_INSTANCE_EXTENSIONS[j] != NULL; j++) {
-                if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], LOADER_INSTANCE_EXTENSIONS[j]) == 0) {
-                    found = true;
-                    break;
-                }
-            }
-
-            // If it isn't in the list, return an error
-            if (!found) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "loader_validate_instance_extensions: Extension %s not found in list of known instance extensions.",
-                           pCreateInfo->ppEnabledExtensionNames[i]);
-                res = VK_ERROR_EXTENSION_NOT_PRESENT;
-                goto out;
-            }
-        }
-
-        extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], icd_exts);
-
-        if (extension_prop) {
-            continue;
-        }
-
-        extension_prop = NULL;
-
-        // Not in global list, search expanded layer extension list
-        for (uint32_t j = 0; NULL == extension_prop && j < expanded_layers.count; ++j) {
-            extension_prop =
-                get_extension_property(pCreateInfo->ppEnabledExtensionNames[i], &expanded_layers.list[j].instance_extension_list);
-        }
-
-        if (!extension_prop) {
-            // Didn't find extension name in any of the global layers, error out
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_instance_extensions: Instance extension %s not supported by available ICDs or enabled "
-                       "layers.",
-                       pCreateInfo->ppEnabledExtensionNames[i]);
-            res = VK_ERROR_EXTENSION_NOT_PRESENT;
-            goto out;
-        }
-    }
-
-out:
-    loader_destroy_layer_list(inst, NULL, &active_layers);
-    loader_destroy_layer_list(inst, NULL, &expanded_layers);
-    return res;
-}
-
-VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev,
-                                           const struct loader_layer_list *activated_device_layers,
-                                           const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo) {
-    VkExtensionProperties *extension_prop;
-    struct loader_layer_properties *layer_prop;
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        VkStringErrorFlags result = vk_string_validate(MaxLoaderStringLength, pCreateInfo->ppEnabledExtensionNames[i]);
-        if (result != VK_STRING_ERROR_NONE) {
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_device_extensions: Device ppEnabledExtensionNames contains "
-                       "string that is too long or is badly formed");
-            return VK_ERROR_EXTENSION_NOT_PRESENT;
-        }
-
-        const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
-        extension_prop = get_extension_property(extension_name, icd_exts);
-
-        if (extension_prop) {
-            continue;
-        }
-
-        // Not in global list, search activated layer extension lists
-        for (uint32_t j = 0; j < activated_device_layers->count; j++) {
-            layer_prop = &activated_device_layers->list[j];
-
-            extension_prop = get_dev_extension_property(extension_name, &layer_prop->device_extension_list);
-            if (extension_prop) {
-                // Found the extension in one of the layers enabled by the app.
-                break;
-            }
-        }
-
-        if (!extension_prop) {
-            // Didn't find extension name in any of the device layers, error out
-            loader_log(phys_dev->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "loader_validate_device_extensions: Device extension %s not supported by selected physical device "
-                       "or enabled layers.",
-                       pCreateInfo->ppEnabledExtensionNames[i]);
-            return VK_ERROR_EXTENSION_NOT_PRESENT;
-        }
-    }
-    return VK_SUCCESS;
-}
-
-// Terminator functions for the Instance chain
-// All named terminator_<Vulakn API name>
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
-                                                         const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
-    struct loader_icd_term *icd_term;
-    VkExtensionProperties *prop;
-    char **filtered_extension_names = NULL;
-    VkInstanceCreateInfo icd_create_info;
-    VkResult res = VK_SUCCESS;
-    bool one_icd_successful = false;
-
-    struct loader_instance *ptr_instance = (struct loader_instance *)*pInstance;
-    memcpy(&icd_create_info, pCreateInfo, sizeof(icd_create_info));
-
-    icd_create_info.enabledLayerCount = 0;
-    icd_create_info.ppEnabledLayerNames = NULL;
-
-    // NOTE: Need to filter the extensions to only those supported by the ICD.
-    //       No ICD will advertise support for layers. An ICD library could
-    //       support a layer, but it would be independent of the actual ICD,
-    //       just in the same library.
-    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
-    if (!filtered_extension_names) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "terminator_CreateInstance: Failed create extension name array for %d extensions",
-                   pCreateInfo->enabledExtensionCount);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    icd_create_info.ppEnabledExtensionNames = (const char *const *)filtered_extension_names;
-
-    for (uint32_t i = 0; i < ptr_instance->icd_tramp_list.count; i++) {
-        icd_term = loader_icd_add(ptr_instance, &ptr_instance->icd_tramp_list.scanned_list[i]);
-        if (NULL == icd_term) {
-            loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "terminator_CreateInstance: Failed to add ICD %d to ICD trampoline list.", i);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-
-        // If any error happens after here, we need to remove the ICD from the list,
-        // because we've already added it, but haven't validated it
-
-        icd_create_info.enabledExtensionCount = 0;
-        struct loader_extension_list icd_exts;
-
-        loader_log(ptr_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0, "Build ICD instance extension list");
-        // traverse scanned icd list adding non-duplicate extensions to the list
-        res = loader_init_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
-        if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
-            // If out of memory, bail immediately.
-            goto out;
-        } else if (VK_SUCCESS != res) {
-            // Something bad happened with this ICD, so free it and try the
-            // next.
-            ptr_instance->icd_terms = icd_term->next;
-            icd_term->next = NULL;
-            loader_icd_destroy(ptr_instance, icd_term, pAllocator);
-            continue;
-        }
-
-        res = loader_add_instance_extensions(ptr_instance, icd_term->scanned_icd->EnumerateInstanceExtensionProperties,
-                                             icd_term->scanned_icd->lib_name, &icd_exts);
-        if (VK_SUCCESS != res) {
-            loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts);
-            if (VK_ERROR_OUT_OF_HOST_MEMORY == res) {
-                // If out of memory, bail immediately.
-                goto out;
-            } else {
-                // Something bad happened with this ICD, so free it and try the next.
-                ptr_instance->icd_terms = icd_term->next;
-                icd_term->next = NULL;
-                loader_icd_destroy(ptr_instance, icd_term, pAllocator);
-                continue;
-            }
-        }
-
-        for (uint32_t j = 0; j < pCreateInfo->enabledExtensionCount; j++) {
-            prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[j], &icd_exts);
-            if (prop) {
-                filtered_extension_names[icd_create_info.enabledExtensionCount] = (char *)pCreateInfo->ppEnabledExtensionNames[j];
-                icd_create_info.enabledExtensionCount++;
-            }
-        }
-
-        loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&icd_exts);
-
-        VkResult icd_result =
-            ptr_instance->icd_tramp_list.scanned_list[i].CreateInstance(&icd_create_info, pAllocator, &(icd_term->instance));
-        if (VK_ERROR_OUT_OF_HOST_MEMORY == icd_result) {
-            // If out of memory, bail immediately.
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        } else if (VK_SUCCESS != icd_result) {
-            loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "terminator_CreateInstance: Failed to CreateInstance in "
-                       "ICD %d.  Skipping ICD.",
-                       i);
-            ptr_instance->icd_terms = icd_term->next;
-            icd_term->next = NULL;
-            loader_icd_destroy(ptr_instance, icd_term, pAllocator);
-            continue;
-        }
-
-        if (!loader_icd_init_entries(icd_term, icd_term->instance,
-                                     ptr_instance->icd_tramp_list.scanned_list[i].GetInstanceProcAddr)) {
-            loader_log(ptr_instance, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "terminator_CreateInstance: Failed to CreateInstance and find "
-                       "entrypoints with ICD.  Skipping ICD.");
-            ptr_instance->icd_terms = icd_term->next;
-            icd_term->next = NULL;
-            loader_icd_destroy(ptr_instance, icd_term, pAllocator);
-            continue;
-        }
-
-        // If we made it this far, at least one ICD was successful
-        one_icd_successful = true;
-    }
-
-    // If no ICDs were added to instance list and res is unchanged from it's initial value, the loader was unable to
-    // find a suitable ICD.
-    if (VK_SUCCESS == res && (ptr_instance->icd_terms == NULL || !one_icd_successful)) {
-        res = VK_ERROR_INCOMPATIBLE_DRIVER;
-    }
-
-out:
-
-    if (VK_SUCCESS != res) {
-        while (NULL != ptr_instance->icd_terms) {
-            icd_term = ptr_instance->icd_terms;
-            ptr_instance->icd_terms = icd_term->next;
-            if (NULL != icd_term->instance) {
-                icd_term->dispatch.DestroyInstance(icd_term->instance, pAllocator);
-            }
-            loader_icd_destroy(ptr_instance, icd_term, pAllocator);
-        }
-    }
-
-    return res;
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
-    struct loader_instance *ptr_instance = loader_instance(instance);
-    if (NULL == ptr_instance) {
-        return;
-    }
-    struct loader_icd_term *icd_terms = ptr_instance->icd_terms;
-    struct loader_icd_term *next_icd_term;
-
-    // Remove this instance from the list of instances:
-    struct loader_instance *prev = NULL;
-    struct loader_instance *next = loader.instances;
-    while (next != NULL) {
-        if (next == ptr_instance) {
-            // Remove this instance from the list:
-            if (prev)
-                prev->next = next->next;
-            else
-                loader.instances = next->next;
-            break;
-        }
-        prev = next;
-        next = next->next;
-    }
-
-    while (NULL != icd_terms) {
-        if (icd_terms->instance) {
-            icd_terms->dispatch.DestroyInstance(icd_terms->instance, pAllocator);
-        }
-        next_icd_term = icd_terms->next;
-        icd_terms->instance = VK_NULL_HANDLE;
-        loader_icd_destroy(ptr_instance, icd_terms, pAllocator);
-
-        icd_terms = next_icd_term;
-    }
-
-    loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
-    loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
-    loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
-    if (NULL != ptr_instance->phys_devs_term) {
-        for (uint32_t i = 0; i < ptr_instance->phys_dev_count_term; i++) {
-            loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term[i]);
-        }
-        loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_term);
-    }
-    if (NULL != ptr_instance->phys_dev_groups_term) {
-        for (uint32_t i = 0; i < ptr_instance->phys_dev_group_count_term; i++) {
-            loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_term[i]);
-        }
-        loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_term);
-    }
-    loader_free_dev_ext_table(ptr_instance);
-    loader_free_phys_dev_ext_table(ptr_instance);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
-                                                       const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
-    VkResult res = VK_SUCCESS;
-    struct loader_physical_device_term *phys_dev_term;
-    phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-
-    struct loader_device *dev = (struct loader_device *)*pDevice;
-    PFN_vkCreateDevice fpCreateDevice = icd_term->dispatch.CreateDevice;
-    struct loader_extension_list icd_exts;
-
-    struct VkStructureHeader *caller_dgci_container = NULL;
-    VkDeviceGroupDeviceCreateInfoKHX *caller_dgci = NULL;
-
-    dev->phys_dev_term = phys_dev_term;
-
-    icd_exts.list = NULL;
-
-    if (fpCreateDevice == NULL) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "terminator_CreateDevice: No vkCreateDevice command exposed "
-                   "by ICD %s",
-                   icd_term->scanned_icd->lib_name);
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    VkDeviceCreateInfo localCreateInfo;
-    memcpy(&localCreateInfo, pCreateInfo, sizeof(localCreateInfo));
-
-    // NOTE: Need to filter the extensions to only those supported by the ICD.
-    //       No ICD will advertise support for layers. An ICD library could support a layer,
-    //       but it would be independent of the actual ICD, just in the same library.
-    char **filtered_extension_names = NULL;
-    if (0 < pCreateInfo->enabledExtensionCount) {
-        filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionCount * sizeof(char *));
-        if (NULL == filtered_extension_names) {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "terminator_CreateDevice: Failed to create extension name "
-                       "storage for %d extensions %d",
-                       pCreateInfo->enabledExtensionCount);
-            return VK_ERROR_OUT_OF_HOST_MEMORY;
-        }
-    }
-
-    localCreateInfo.enabledLayerCount = 0;
-    localCreateInfo.ppEnabledLayerNames = NULL;
-
-    localCreateInfo.enabledExtensionCount = 0;
-    localCreateInfo.ppEnabledExtensionNames = (const char *const *)filtered_extension_names;
-
-    // Get the physical device (ICD) extensions
-    res = loader_init_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
-    if (VK_SUCCESS != res) {
-        goto out;
-    }
-
-    res = loader_add_device_extensions(icd_term->this_instance, icd_term->dispatch.EnumerateDeviceExtensionProperties,
-                                       phys_dev_term->phys_dev, icd_term->scanned_icd->lib_name, &icd_exts);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
-        VkExtensionProperties *prop = get_extension_property(extension_name, &icd_exts);
-        if (prop) {
-            filtered_extension_names[localCreateInfo.enabledExtensionCount] = (char *)extension_name;
-            localCreateInfo.enabledExtensionCount++;
-        } else {
-            loader_log(icd_term->this_instance, VK_DEBUG_REPORT_DEBUG_BIT_EXT, 0,
-                       "vkCreateDevice extension %s not available for "
-                       "devices associated with ICD %s",
-                       extension_name, icd_term->scanned_icd->lib_name);
-        }
-    }
-
-    // Before we continue, If KHX_device_group is the list of enabled and viable extensions, then we then need to look for the
-    // corresponding VkDeviceGroupDeviceCreateInfoKHX struct in the device list and replace all the physical device values (which
-    // are really loader physical device terminator values) with the ICD versions.
-    if (icd_term->this_instance->enabled_known_extensions.khx_device_group_creation == 1) {
-        struct VkStructureHeader *pNext = (struct VkStructureHeader *)localCreateInfo.pNext;
-        struct VkStructureHeader *pPrev = (struct VkStructureHeader *)&localCreateInfo;
-        while (NULL != pNext) {
-            if (VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX == pNext->sType) {
-                VkDeviceGroupDeviceCreateInfoKHX *cur_struct = (VkDeviceGroupDeviceCreateInfoKHX *)pNext;
-                if (0 < cur_struct->physicalDeviceCount && NULL != cur_struct->pPhysicalDevices) {
-                    VkDeviceGroupDeviceCreateInfoKHX *temp_struct = loader_stack_alloc(sizeof(VkDeviceGroupDeviceCreateInfoKHX));
-                    VkPhysicalDevice *phys_dev_array = NULL;
-                    if (NULL == temp_struct) {
-                        return VK_ERROR_OUT_OF_HOST_MEMORY;
-                    }
-                    memcpy(temp_struct, cur_struct, sizeof(VkDeviceGroupDeviceCreateInfoKHX));
-                    phys_dev_array = loader_stack_alloc(sizeof(VkPhysicalDevice) * cur_struct->physicalDeviceCount);
-                    if (NULL == phys_dev_array) {
-                        return VK_ERROR_OUT_OF_HOST_MEMORY;
-                    }
-
-                    // Before calling down, replace the incoming physical device values (which are really loader terminator
-                    // physical devices) with the ICDs physical device values.
-                    struct loader_physical_device_term *cur_term;
-                    for (uint32_t phys_dev = 0; phys_dev < cur_struct->physicalDeviceCount; phys_dev++) {
-                        cur_term = (struct loader_physical_device_term *)cur_struct->pPhysicalDevices[phys_dev];
-                        phys_dev_array[phys_dev] = cur_term->phys_dev;
-                    }
-                    temp_struct->pPhysicalDevices = phys_dev_array;
-
-                    // Keep track of pointers to restore pNext chain before returning
-                    caller_dgci_container = pPrev;
-                    caller_dgci = cur_struct;
-
-                    // Replace the old struct in the pNext chain with this one.
-                    pPrev->pNext = (const void *)temp_struct;
-                    pNext = (struct VkStructureHeader *)(temp_struct);
-                }
-                break;
-            }
-
-            pPrev = pNext;
-            pNext = (struct VkStructureHeader *)(pPrev->pNext);
-        }
-    }
-
-    // Handle loader emulation for structs that are not supported by the ICD:
-    // Presently, the emulation leaves the pNext chain alone. This means that the ICD will receive items in the chain which
-    // are not recognized by the ICD. If this causes the ICD to fail, then the items would have to be removed here. The current
-    // implementation does not remove them because copying the pNext chain would be impossible if the loader does not recognize
-    // the any of the struct types, as the loader would not know the size to allocate and copy.
-    if (icd_term->dispatch.GetPhysicalDeviceFeatures2KHR == NULL) {
-        const void *pNext = localCreateInfo.pNext;
-        while (pNext != NULL) {
-            switch (*(VkStructureType *)pNext) {
-                case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: {
-                    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                               "vkCreateDevice: Emulating handling of VkPhysicalDeviceFeatures2KHR in pNext chain for ICD \"%s\"",
-                               icd_term->scanned_icd->lib_name);
-                    const VkPhysicalDeviceFeatures2KHR *features = pNext;
-
-                    // Verify that VK_KHR_get_physical_device_properties2 is enabled
-                    if (icd_term->this_instance->enabled_known_extensions.khr_get_physical_device_properties2) {
-                        localCreateInfo.pEnabledFeatures = &features->features;
-                    }
-
-                    // Leave this item in the pNext chain for now
-
-                    pNext = features->pNext;
-                    break;
-                }
-
-                case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX: {
-                    loader_log(
-                        icd_term->this_instance, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                        "vkCreateDevice: Emulating handling of VkDeviceGroupDeviceCreateInfoKHX in pNext chain for ICD \"%s\"",
-                        icd_term->scanned_icd->lib_name);
-                    const VkDeviceGroupDeviceCreateInfoKHX *group_info = pNext;
-
-                    // The group must contain only this one device, since physical device groups aren't actually supported
-                    if (group_info->physicalDeviceCount != 1 || group_info->pPhysicalDevices[0] != physicalDevice) {
-                        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                                   "vkCreateDevice: Emulation failed to create device from device group info");
-                        res = VK_ERROR_INITIALIZATION_FAILED;
-                        goto out;
-                    }
-
-                    // Nothing needs to be done here because we're leaving the item in the pNext chain and because the spec states
-                    // that the physicalDevice argument must be included in the device group, and we've already checked that it is
-
-                    pNext = group_info->pNext;
-                    break;
-                }
-
-                // Multiview properties are also allowed, but since VK_KHX_multiview is a device extension, we'll just let the ICD
-                // handle that error when the user enables the extension here
-                default: {
-                    const struct VkStructureHeader *header = pNext;
-                    pNext = header->pNext;
-                    break;
-                }
-            }
-        }
-    }
-
-    res = fpCreateDevice(phys_dev_term->phys_dev, &localCreateInfo, pAllocator, &dev->icd_device);
-    if (res != VK_SUCCESS) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "terminator_CreateDevice: Failed in ICD %s vkCreateDevice"
-                   "call",
-                   icd_term->scanned_icd->lib_name);
-        goto out;
-    }
-
-    *pDevice = dev->icd_device;
-    loader_add_logical_device(icd_term->this_instance, icd_term, dev);
-
-    // Init dispatch pointer in new device object
-    loader_init_dispatch(*pDevice, &dev->loader_dispatch);
-
-out:
-    if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts);
-    }
-
-    // Restore pNext pointer to old VkDeviceGroupDeviceCreateInfoKHX
-    // in the chain to maintain consistency for the caller.
-    if (caller_dgci_container != NULL) {
-        caller_dgci_container->pNext = caller_dgci;
-    }
-
-    return res;
-}
-
-VkResult setupLoaderTrampPhysDevs(VkInstance instance) {
-    VkResult res = VK_SUCCESS;
-    VkPhysicalDevice *local_phys_devs = NULL;
-    struct loader_instance *inst;
-    uint32_t total_count = 0;
-    struct loader_physical_device_tramp **new_phys_devs = NULL;
-
-    inst = loader_get_instance(instance);
-    if (NULL == inst) {
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    // Query how many GPUs there
-    res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, NULL);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed during dispatch call "
-                   "of \'vkEnumeratePhysicalDevices\' to lower layers or "
-                   "loader to get count.");
-        goto out;
-    }
-
-    // Really use what the total GPU count is since Optimus and other layers may mess
-    // the count up.
-    total_count = inst->total_gpu_count;
-
-    // Create an array for the new physical devices, which will be stored
-    // in the instance for the trampoline code.
-    new_phys_devs = (struct loader_physical_device_tramp **)loader_instance_heap_alloc(
-        inst, total_count * sizeof(struct loader_physical_device_tramp *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == new_phys_devs) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed to allocate new physical device"
-                   " array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(new_phys_devs, 0, total_count * sizeof(struct loader_physical_device_tramp *));
-
-    // Create a temporary array (on the stack) to keep track of the
-    // returned VkPhysicalDevice values.
-    local_phys_devs = loader_stack_alloc(sizeof(VkPhysicalDevice) * total_count);
-    if (NULL == local_phys_devs) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed to allocate local "
-                   "physical device array of size %d",
-                   total_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(local_phys_devs, 0, sizeof(VkPhysicalDevice) * total_count);
-
-    res = inst->disp->layer_inst_disp.EnumeratePhysicalDevices(instance, &total_count, local_phys_devs);
-    if (VK_SUCCESS != res) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTrampPhysDevs:  Failed during dispatch call "
-                   "of \'vkEnumeratePhysicalDevices\' to lower layers or "
-                   "loader to get content.");
-        goto out;
-    }
-
-    // Copy or create everything to fill the new array of physical devices
-    for (uint32_t new_idx = 0; new_idx < total_count; new_idx++) {
-        // Check if this physical device is already in the old buffer
-        for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_tramp; old_idx++) {
-            if (local_phys_devs[new_idx] == inst->phys_devs_tramp[old_idx]->phys_dev) {
-                new_phys_devs[new_idx] = inst->phys_devs_tramp[old_idx];
-                break;
-            }
-        }
-
-        // If this physical device isn't in the old buffer, create it
-        if (NULL == new_phys_devs[new_idx]) {
-            new_phys_devs[new_idx] = (struct loader_physical_device_tramp *)loader_instance_heap_alloc(
-                inst, sizeof(struct loader_physical_device_tramp), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-            if (NULL == new_phys_devs[new_idx]) {
-                loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                           "setupLoaderTrampPhysDevs:  Failed to allocate "
-                           "physical device trampoline object %d",
-                           new_idx);
-                total_count = new_idx;
-                res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                goto out;
-            }
-
-            // Initialize the new physicalDevice object
-            loader_set_dispatch((void *)new_phys_devs[new_idx], inst->disp);
-            new_phys_devs[new_idx]->this_instance = inst;
-            new_phys_devs[new_idx]->phys_dev = local_phys_devs[new_idx];
-        }
-    }
-
-out:
-
-    if (VK_SUCCESS != res) {
-        if (NULL != new_phys_devs) {
-            for (uint32_t i = 0; i < total_count; i++) {
-                loader_instance_heap_free(inst, new_phys_devs[i]);
-            }
-            loader_instance_heap_free(inst, new_phys_devs);
-        }
-        total_count = 0;
-    } else {
-        // Free everything that didn't carry over to the new array of
-        // physical devices
-        if (NULL != inst->phys_devs_tramp) {
-            for (uint32_t i = 0; i < inst->phys_dev_count_tramp; i++) {
-                bool found = false;
-                for (uint32_t j = 0; j < total_count; j++) {
-                    if (inst->phys_devs_tramp[i] == new_phys_devs[j]) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    loader_instance_heap_free(inst, inst->phys_devs_tramp[i]);
-                }
-            }
-            loader_instance_heap_free(inst, inst->phys_devs_tramp);
-        }
-
-        // Swap in the new physical device list
-        inst->phys_dev_count_tramp = total_count;
-        inst->phys_devs_tramp = new_phys_devs;
-    }
-
-    return res;
-}
-
-VkResult setupLoaderTermPhysDevs(struct loader_instance *inst) {
-    VkResult res = VK_SUCCESS;
-    struct loader_icd_term *icd_term;
-    struct loader_phys_dev_per_icd *icd_phys_dev_array = NULL;
-    struct loader_physical_device_term **new_phys_devs = NULL;
-
-    inst->total_gpu_count = 0;
-
-    // Allocate something to store the physical device characteristics
-    // that we read from each ICD.
-    icd_phys_dev_array =
-        (struct loader_phys_dev_per_icd *)loader_stack_alloc(sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
-    if (NULL == icd_phys_dev_array) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to allocate temporary "
-                   "ICD Physical device info array of size %d",
-                   inst->total_gpu_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(icd_phys_dev_array, 0, sizeof(struct loader_phys_dev_per_icd) * inst->total_icd_count);
-    icd_term = inst->icd_terms;
-
-    // For each ICD, query the number of physical devices, and then get an
-    // internal value for those physical devices.
-    for (uint32_t icd_idx = 0; NULL != icd_term; icd_term = icd_term->next, icd_idx++) {
-        res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &icd_phys_dev_array[icd_idx].count, NULL);
-        if (VK_SUCCESS != res) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "setupLoaderTermPhysDevs:  Call to "
-                       "ICD %d's \'vkEnumeratePhysicalDevices\' failed with"
-                       " error 0x%08x",
-                       icd_idx, res);
-            goto out;
-        }
-
-        icd_phys_dev_array[icd_idx].phys_devs =
-            (VkPhysicalDevice *)loader_stack_alloc(icd_phys_dev_array[icd_idx].count * sizeof(VkPhysicalDevice));
-        if (NULL == icd_phys_dev_array[icd_idx].phys_devs) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "setupLoaderTermPhysDevs:  Failed to allocate temporary "
-                       "ICD Physical device array for ICD %d of size %d",
-                       icd_idx, inst->total_gpu_count);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-
-        res = icd_term->dispatch.EnumeratePhysicalDevices(icd_term->instance, &(icd_phys_dev_array[icd_idx].count),
-                                                          icd_phys_dev_array[icd_idx].phys_devs);
-        if (VK_SUCCESS != res) {
-            goto out;
-        }
-        inst->total_gpu_count += icd_phys_dev_array[icd_idx].count;
-        icd_phys_dev_array[icd_idx].this_icd_term = icd_term;
-    }
-
-    if (0 == inst->total_gpu_count) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to detect any valid"
-                   " GPUs in the current config");
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    new_phys_devs = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count,
-                                               VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (NULL == new_phys_devs) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "setupLoaderTermPhysDevs:  Failed to allocate new physical"
-                   " device array of size %d",
-                   inst->total_gpu_count);
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memset(new_phys_devs, 0, sizeof(struct loader_physical_device_term *) * inst->total_gpu_count);
-
-    // Copy or create everything to fill the new array of physical devices
-    uint32_t idx = 0;
-    for (uint32_t icd_idx = 0; icd_idx < inst->total_icd_count; icd_idx++) {
-        for (uint32_t pd_idx = 0; pd_idx < icd_phys_dev_array[icd_idx].count; pd_idx++) {
-            // Check if this physical device is already in the old buffer
-            if (NULL != inst->phys_devs_term) {
-                for (uint32_t old_idx = 0; old_idx < inst->phys_dev_count_term; old_idx++) {
-                    if (icd_phys_dev_array[icd_idx].phys_devs[pd_idx] == inst->phys_devs_term[old_idx]->phys_dev) {
-                        new_phys_devs[idx] = inst->phys_devs_term[old_idx];
-                        break;
-                    }
-                }
-            }
-            // If this physical device isn't in the old buffer, then we
-            // need to create it.
-            if (NULL == new_phys_devs[idx]) {
-                new_phys_devs[idx] = loader_instance_heap_alloc(inst, sizeof(struct loader_physical_device_term),
-                                                                VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-                if (NULL == new_phys_devs[idx]) {
-                    loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                               "setupLoaderTermPhysDevs:  Failed to allocate "
-                               "physical device terminator object %d",
-                               idx);
-                    inst->total_gpu_count = idx;
-                    res = VK_ERROR_OUT_OF_HOST_MEMORY;
-                    goto out;
-                }
-
-                loader_set_dispatch((void *)new_phys_devs[idx], inst->disp);
-                new_phys_devs[idx]->this_icd_term = icd_phys_dev_array[icd_idx].this_icd_term;
-                new_phys_devs[idx]->icd_index = (uint8_t)(icd_idx);
-                new_phys_devs[idx]->phys_dev = icd_phys_dev_array[icd_idx].phys_devs[pd_idx];
-            }
-            idx++;
-        }
-    }
-
-out:
-
-    if (VK_SUCCESS != res) {
-        if (NULL != new_phys_devs) {
-            // We've encountered an error, so we should free the new buffers.
-            for (uint32_t i = 0; i < inst->total_gpu_count; i++) {
-                loader_instance_heap_free(inst, new_phys_devs[i]);
-            }
-            loader_instance_heap_free(inst, new_phys_devs);
-        }
-        inst->total_gpu_count = 0;
-    } else {
-        // Free everything that didn't carry over to the new array of
-        // physical devices.  Everything else will have been copied over
-        // to the new array.
-        if (NULL != inst->phys_devs_term) {
-            for (uint32_t cur_pd = 0; cur_pd < inst->phys_dev_count_term; cur_pd++) {
-                bool found = false;
-                for (uint32_t new_pd_idx = 0; new_pd_idx < inst->total_gpu_count; new_pd_idx++) {
-                    if (inst->phys_devs_term[cur_pd] == new_phys_devs[new_pd_idx]) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    loader_instance_heap_free(inst, inst->phys_devs_term[cur_pd]);
-                }
-            }
-            loader_instance_heap_free(inst, inst->phys_devs_term);
-        }
-
-        // Swap out old and new devices list
-        inst->phys_dev_count_term = inst->total_gpu_count;
-        inst->phys_devs_term = new_phys_devs;
-    }
-
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
-                                                                   VkPhysicalDevice *pPhysicalDevices) {
-    struct loader_instance *inst = (struct loader_instance *)instance;
-    VkResult res = VK_SUCCESS;
-
-    // Always call the setup loader terminator physical devices because they may
-    // have changed at any point.
-    res = setupLoaderTermPhysDevs(inst);
-    if (VK_SUCCESS != res) {
-        goto out;
-    }
-
-    uint32_t copy_count = inst->total_gpu_count;
-    if (NULL != pPhysicalDevices) {
-        if (copy_count > *pPhysicalDeviceCount) {
-            copy_count = *pPhysicalDeviceCount;
-            res = VK_INCOMPLETE;
-        }
-
-        for (uint32_t i = 0; i < copy_count; i++) {
-            pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_term[i];
-        }
-    }
-
-    *pPhysicalDeviceCount = copy_count;
-
-out:
-
-    return res;
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
-                                                                  VkPhysicalDeviceProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceProperties) {
-        icd_term->dispatch.GetPhysicalDeviceProperties(phys_dev_term->phys_dev, pProperties);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
-                                                                             uint32_t *pQueueFamilyPropertyCount,
-                                                                             VkQueueFamilyProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties) {
-        icd_term->dispatch.GetPhysicalDeviceQueueFamilyProperties(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, pProperties);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
-                                                                        VkPhysicalDeviceMemoryProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceMemoryProperties) {
-        icd_term->dispatch.GetPhysicalDeviceMemoryProperties(phys_dev_term->phys_dev, pProperties);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
-                                                                VkPhysicalDeviceFeatures *pFeatures) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceFeatures) {
-        icd_term->dispatch.GetPhysicalDeviceFeatures(phys_dev_term->phys_dev, pFeatures);
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                        VkFormatProperties *pFormatInfo) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceFormatProperties) {
-        icd_term->dispatch.GetPhysicalDeviceFormatProperties(phys_dev_term->phys_dev, format, pFormatInfo);
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                                 VkImageType type, VkImageTiling tiling,
-                                                                                 VkImageUsageFlags usage, VkImageCreateFlags flags,
-                                                                                 VkImageFormatProperties *pImageFormatProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceImageFormatProperties) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "Encountered the vkEnumerateDeviceLayerProperties "
-                   "terminator.  This means a layer improperly continued.");
-        return VK_ERROR_INITIALIZATION_FAILED;
-    }
-    return icd_term->dispatch.GetPhysicalDeviceImageFormatProperties(phys_dev_term->phys_dev, format, type, tiling, usage, flags,
-                                                                     pImageFormatProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                                   VkImageType type, VkSampleCountFlagBits samples,
-                                                                                   VkImageUsageFlags usage, VkImageTiling tiling,
-                                                                                   uint32_t *pNumProperties,
-                                                                                   VkSparseImageFormatProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL != icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties) {
-        icd_term->dispatch.GetPhysicalDeviceSparseImageFormatProperties(phys_dev_term->phys_dev, format, type, samples, usage,
-                                                                        tiling, pNumProperties, pProperties);
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                                             const char *pLayerName, uint32_t *pPropertyCount,
-                                                                             VkExtensionProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term;
-
-    struct loader_layer_list implicit_layer_list = {0};
-    struct loader_extension_list all_exts = {0};
-    struct loader_extension_list icd_exts = {0};
-
-    assert(pLayerName == NULL || strlen(pLayerName) == 0);
-
-    // Any layer or trampoline wrapping should be removed at this point in time can just cast to the expected
-    // type for VkPhysicalDevice.
-    phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-
-    // This case is during the call down the instance chain with pLayerName == NULL
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    uint32_t icd_ext_count = *pPropertyCount;
-    VkResult res;
-
-    // Get the available device extensions
-    res = icd_term->dispatch.EnumerateDeviceExtensionProperties(phys_dev_term->phys_dev, NULL, &icd_ext_count, pProperties);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-
-    if (!loader_init_layer_list(icd_term->this_instance, &implicit_layer_list)) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL, &icd_term->this_instance->instance_layer_list);
-    // We need to determine which implicit layers are active, and then add their extensions. This can't be cached as
-    // it depends on results of environment variables (which can change).
-    if (pProperties != NULL) {
-        // Initialize dev_extension list within the physicalDevice object
-        res = loader_init_device_extensions(icd_term->this_instance, phys_dev_term, icd_ext_count, pProperties, &icd_exts);
-        if (res != VK_SUCCESS) {
-            goto out;
-        }
-
-        // We need to determine which implicit layers are active, and then add their extensions. This can't be cached as
-        // it depends on results of environment variables (which can change).
-        res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, icd_exts.count, icd_exts.list);
-        if (res != VK_SUCCESS) {
-            goto out;
-        }
-
-        loader_add_implicit_layers(icd_term->this_instance, &implicit_layer_list, NULL,
-                                   &icd_term->this_instance->instance_layer_list);
-
-        for (uint32_t i = 0; i < implicit_layer_list.count; i++) {
-            for (uint32_t j = 0; j < implicit_layer_list.list[i].device_extension_list.count; j++) {
-                res = loader_add_to_ext_list(icd_term->this_instance, &all_exts, 1,
-                                             &implicit_layer_list.list[i].device_extension_list.list[j].props);
-                if (res != VK_SUCCESS) {
-                    goto out;
-                }
-            }
-        }
-        uint32_t capacity = *pPropertyCount;
-        VkExtensionProperties *props = pProperties;
-
-        for (uint32_t i = 0; i < all_exts.count && i < capacity; i++) {
-            props[i] = all_exts.list[i];
-        }
-
-        // Wasn't enough space for the extensions, we did partial copy now return VK_INCOMPLETE
-        if (capacity < all_exts.count) {
-            res = VK_INCOMPLETE;
-        } else {
-            *pPropertyCount = all_exts.count;
-        }
-    } else {
-        // Just return the count; need to add in the count of implicit layer extensions
-        // don't worry about duplicates being added in the count
-        *pPropertyCount = icd_ext_count;
-
-        for (uint32_t i = 0; i < implicit_layer_list.count; i++) {
-            *pPropertyCount += implicit_layer_list.list[i].device_extension_list.count;
-        }
-        res = VK_SUCCESS;
-    }
-
-out:
-
-    if (NULL != implicit_layer_list.list) {
-        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&implicit_layer_list);
-    }
-    if (NULL != all_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&all_exts);
-    }
-    if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(icd_term->this_instance, (struct loader_generic_list *)&icd_exts);
-    }
-
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-                                                                         VkLayerProperties *pProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-               "Encountered the vkEnumerateDeviceLayerProperties "
-               "terminator.  This means a layer improperly continued.");
-    // Should never get here this call isn't dispatched down the chain
-    return VK_ERROR_INITIALIZATION_FAILED;
-}
-
-VkStringErrorFlags vk_string_validate(const int max_length, const char *utf8) {
-    VkStringErrorFlags result = VK_STRING_ERROR_NONE;
-    int num_char_bytes = 0;
-    int i, j;
-
-    for (i = 0; i <= max_length; i++) {
-        if (utf8[i] == 0) {
-            break;
-        } else if (i == max_length) {
-            result |= VK_STRING_ERROR_LENGTH;
-            break;
-        } else if ((utf8[i] >= 0x20) && (utf8[i] < 0x7f)) {
-            num_char_bytes = 0;
-        } else if ((utf8[i] & UTF8_ONE_BYTE_MASK) == UTF8_ONE_BYTE_CODE) {
-            num_char_bytes = 1;
-        } else if ((utf8[i] & UTF8_TWO_BYTE_MASK) == UTF8_TWO_BYTE_CODE) {
-            num_char_bytes = 2;
-        } else if ((utf8[i] & UTF8_THREE_BYTE_MASK) == UTF8_THREE_BYTE_CODE) {
-            num_char_bytes = 3;
-        } else {
-            result = VK_STRING_ERROR_BAD_DATA;
-        }
-
-        // Validate the following num_char_bytes of data
-        for (j = 0; (j < num_char_bytes) && (i < max_length); j++) {
-            if (++i == max_length) {
-                result |= VK_STRING_ERROR_LENGTH;
-                break;
-            }
-            if ((utf8[i] & UTF8_DATA_BYTE_MASK) != UTF8_DATA_BYTE_CODE) {
-                result |= VK_STRING_ERROR_BAD_DATA;
-            }
-        }
-    }
-    return result;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL
-terminator_EnumerateInstanceExtensionProperties(const VkEnumerateInstanceExtensionPropertiesChain *chain, const char *pLayerName,
-                                                uint32_t *pPropertyCount, VkExtensionProperties *pProperties) {
-    struct loader_extension_list *global_ext_list = NULL;
-    struct loader_layer_list instance_layers;
-    struct loader_extension_list local_ext_list;
-    struct loader_icd_tramp_list icd_tramp_list;
-    uint32_t copy_size;
-    VkResult res = VK_SUCCESS;
-
-    // tls_instance = NULL;
-    memset(&local_ext_list, 0, sizeof(local_ext_list));
-    memset(&instance_layers, 0, sizeof(instance_layers));
-
-    // Get layer libraries if needed
-    if (pLayerName && strlen(pLayerName) != 0) {
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) != VK_STRING_ERROR_NONE) {
-            assert(VK_FALSE &&
-                   "vkEnumerateInstanceExtensionProperties:  "
-                   "pLayerName is too long or is badly formed");
-            res = VK_ERROR_EXTENSION_NOT_PRESENT;
-            goto out;
-        }
-
-        loader_layer_scan(NULL, &instance_layers);
-        for (uint32_t i = 0; i < instance_layers.count; i++) {
-            struct loader_layer_properties *props = &instance_layers.list[i];
-            if (strcmp(props->info.layerName, pLayerName) == 0) {
-                global_ext_list = &props->instance_extension_list;
-                break;
-            }
-        }
-    } else {
-        // Scan/discover all ICD libraries
-        memset(&icd_tramp_list, 0, sizeof(icd_tramp_list));
-        res = loader_icd_scan(NULL, &icd_tramp_list);
-        if (VK_SUCCESS != res) {
-            goto out;
-        }
-        // Get extensions from all ICD's, merge so no duplicates
-        res = loader_get_icd_loader_instance_extensions(NULL, &icd_tramp_list, &local_ext_list);
-        if (VK_SUCCESS != res) {
-            goto out;
-        }
-        loader_scanned_icd_clear(NULL, &icd_tramp_list);
-
-        // Append enabled implicit layers.
-        loader_implicit_layer_scan(NULL, &instance_layers);
-        for (uint32_t i = 0; i < instance_layers.count; i++) {
-            if (!loader_is_implicit_layer_enabled(NULL, &instance_layers.list[i])) {
-                continue;
-            }
-            struct loader_extension_list *ext_list = &instance_layers.list[i].instance_extension_list;
-            loader_add_to_ext_list(NULL, &local_ext_list, ext_list->count, ext_list->list);
-        }
-
-        global_ext_list = &local_ext_list;
-    }
-
-    if (global_ext_list == NULL) {
-        res = VK_ERROR_LAYER_NOT_PRESENT;
-        goto out;
-    }
-
-    if (pProperties == NULL) {
-        *pPropertyCount = global_ext_list->count;
-        goto out;
-    }
-
-    copy_size = *pPropertyCount < global_ext_list->count ? *pPropertyCount : global_ext_list->count;
-    for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &global_ext_list->list[i], sizeof(VkExtensionProperties));
-    }
-    *pPropertyCount = copy_size;
-
-    if (copy_size < global_ext_list->count) {
-        res = VK_INCOMPLETE;
-        goto out;
-    }
-
-out:
-
-    loader_destroy_generic_list(NULL, (struct loader_generic_list *)&local_ext_list);
-    loader_delete_layer_properties(NULL, &instance_layers);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceLayerProperties(const VkEnumerateInstanceLayerPropertiesChain *chain,
-                                                                           uint32_t *pPropertyCount,
-                                                                           VkLayerProperties *pProperties) {
-    VkResult result = VK_SUCCESS;
-    struct loader_layer_list instance_layer_list;
-    tls_instance = NULL;
-
-    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
-
-    uint32_t copy_size;
-
-    // Get layer libraries
-    memset(&instance_layer_list, 0, sizeof(instance_layer_list));
-    loader_layer_scan(NULL, &instance_layer_list);
-
-    if (pProperties == NULL) {
-        *pPropertyCount = instance_layer_list.count;
-        goto out;
-    }
-
-    copy_size = (*pPropertyCount < instance_layer_list.count) ? *pPropertyCount : instance_layer_list.count;
-    for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &instance_layer_list.list[i].info, sizeof(VkLayerProperties));
-    }
-
-    *pPropertyCount = copy_size;
-
-    if (copy_size < instance_layer_list.count) {
-        result = VK_INCOMPLETE;
-        goto out;
-    }
-
-out:
-
-    loader_delete_layer_properties(NULL, &instance_layer_list);
-    return result;
-}
-
-#if defined(_WIN32) && defined(LOADER_DYNAMIC_LIB)
-BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
-    switch (reason) {
-        case DLL_PROCESS_ATTACH:
-            loader_initialize();
-            break;
-        case DLL_PROCESS_DETACH:
-            if (NULL == reserved) {
-                loader_release();
-            }
-            break;
-        default:
-            // Do nothing
-            break;
-    }
-    return TRUE;
-}
-#elif !defined(_WIN32)
-__attribute__((constructor)) void loader_init_library() { loader_initialize(); }
-
-__attribute__((destructor)) void loader_free_library() { loader_release(); }
-#endif
diff --git a/third_party/vulkan/loader/loader.h b/third_party/vulkan/loader/loader.h
deleted file mode 100644
index 58dfefedc..000000000
--- a/third_party/vulkan/loader/loader.h
+++ /dev/null
@@ -1,490 +0,0 @@
-/*
- *
- * Copyright (c) 2014-2017 The Khronos Group Inc.
- * Copyright (c) 2014-2017 Valve Corporation
- * Copyright (c) 2014-2017 LunarG, Inc.
- * Copyright (C) 2015 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
- * Author: Chia-I Wu <olvaffe@gmail.com>
- * Author: Chia-I Wu <olv@lunarg.com>
- * Author: Mark Lobodzinski <mark@LunarG.com>
- *
- */
-
-#ifndef LOADER_H
-#define LOADER_H
-
-#include <vulkan/vulkan.h>
-#include "vk_loader_platform.h"
-#include "vk_loader_layer.h"
-#include <vulkan/vk_layer.h>
-#include <vulkan/vk_icd.h>
-#include <assert.h>
-#include "vk_loader_extensions.h"
-
-#if defined(__GNUC__) && __GNUC__ >= 4
-#define LOADER_EXPORT __attribute__((visibility("default")))
-#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
-#define LOADER_EXPORT __attribute__((visibility("default")))
-#else
-#define LOADER_EXPORT
-#endif
-
-// A debug option to disable allocators at compile time to investigate future issues.
-#define DEBUG_DISABLE_APP_ALLOCATORS 0
-
-#define MAX_STRING_SIZE 1024
-
-// This is defined in vk_layer.h, but if there's problems we need to create the define
-// here.
-#ifndef MAX_NUM_UNKNOWN_EXTS
-#define MAX_NUM_UNKNOWN_EXTS 250
-#endif
-
-enum layer_type_flags {
-    VK_LAYER_TYPE_FLAG_INSTANCE_LAYER = 0x1,  // If not set, indicates Device layer
-    VK_LAYER_TYPE_FLAG_EXPLICIT_LAYER = 0x2,  // If not set, indicates Implicit layer
-    VK_LAYER_TYPE_FLAG_META_LAYER = 0x4,      // If not set, indicates standard layer
-};
-
-typedef enum VkStringErrorFlagBits {
-    VK_STRING_ERROR_NONE = 0x00000000,
-    VK_STRING_ERROR_LENGTH = 0x00000001,
-    VK_STRING_ERROR_BAD_DATA = 0x00000002,
-} VkStringErrorFlagBits;
-typedef VkFlags VkStringErrorFlags;
-
-static const int MaxLoaderStringLength = 256;
-static const char UTF8_ONE_BYTE_CODE = 0xC0;
-static const char UTF8_ONE_BYTE_MASK = 0xE0;
-static const char UTF8_TWO_BYTE_CODE = 0xE0;
-static const char UTF8_TWO_BYTE_MASK = 0xF0;
-static const char UTF8_THREE_BYTE_CODE = 0xF0;
-static const char UTF8_THREE_BYTE_MASK = 0xF8;
-static const char UTF8_DATA_BYTE_CODE = 0x80;
-static const char UTF8_DATA_BYTE_MASK = 0xC0;
-
-struct VkStructureHeader {
-    VkStructureType sType;
-    const void *pNext;
-};
-
-// form of all dynamic lists/arrays
-// only the list element should be changed
-struct loader_generic_list {
-    size_t capacity;
-    uint32_t count;
-    void *list;
-};
-
-struct loader_extension_list {
-    size_t capacity;
-    uint32_t count;
-    VkExtensionProperties *list;
-};
-
-struct loader_dev_ext_props {
-    VkExtensionProperties props;
-    uint32_t entrypoint_count;
-    char **entrypoints;
-};
-
-struct loader_device_extension_list {
-    size_t capacity;
-    uint32_t count;
-    struct loader_dev_ext_props *list;
-};
-
-struct loader_name_value {
-    char name[MAX_STRING_SIZE];
-    char value[MAX_STRING_SIZE];
-};
-
-struct loader_layer_functions {
-    char str_gipa[MAX_STRING_SIZE];
-    char str_gdpa[MAX_STRING_SIZE];
-    char str_negotiate_interface[MAX_STRING_SIZE];
-    PFN_vkNegotiateLoaderLayerInterfaceVersion negotiate_layer_interface;
-    PFN_vkGetInstanceProcAddr get_instance_proc_addr;
-    PFN_vkGetDeviceProcAddr get_device_proc_addr;
-    PFN_GetPhysicalDeviceProcAddr get_physical_device_proc_addr;
-};
-
-struct loader_layer_properties {
-    VkLayerProperties info;
-    enum layer_type_flags type_flags;
-    uint32_t interface_version;  // PFN_vkNegotiateLoaderLayerInterfaceVersion
-    char lib_name[MAX_STRING_SIZE];
-    loader_platform_dl_handle lib_handle;
-    struct loader_layer_functions functions;
-    struct loader_extension_list instance_extension_list;
-    struct loader_device_extension_list device_extension_list;
-    struct loader_name_value disable_env_var;
-    struct loader_name_value enable_env_var;
-    uint32_t num_component_layers;
-    char (*component_layer_names)[MAX_STRING_SIZE];
-    struct {
-        char enumerate_instance_extension_properties[MAX_STRING_SIZE];
-        char enumerate_instance_layer_properties[MAX_STRING_SIZE];
-    } pre_instance_functions;
-};
-
-struct loader_layer_list {
-    size_t capacity;
-    uint32_t count;
-    struct loader_layer_properties *list;
-};
-
-struct loader_dispatch_hash_list {
-    size_t capacity;
-    uint32_t count;
-    uint32_t *index;  // index into the dev_ext dispatch table
-};
-
-// loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.dev_ext have
-// one to one correspondence; one loader_dispatch_hash_entry for one dev_ext
-// dispatch entry.
-// Also have a one to one correspondence with functions in dev_ext_trampoline.c
-struct loader_dispatch_hash_entry {
-    char *func_name;
-    struct loader_dispatch_hash_list list;  // to handle hashing collisions
-};
-
-typedef void(VKAPI_PTR *PFN_vkDevExt)(VkDevice device);
-struct loader_dev_ext_dispatch_table {
-    PFN_vkDevExt dev_ext[MAX_NUM_UNKNOWN_EXTS];
-};
-
-struct loader_dev_dispatch_table {
-    VkLayerDispatchTable core_dispatch;
-    struct loader_dev_ext_dispatch_table ext_dispatch;
-};
-
-// per CreateDevice structure
-struct loader_device {
-    struct loader_dev_dispatch_table loader_dispatch;
-    VkDevice chain_device;  // device object from the dispatch chain
-    VkDevice icd_device;    // device object from the icd
-    struct loader_physical_device_term *phys_dev_term;
-
-    // List of activated layers.
-    //  app_      is the version based on exactly what the application asked for.
-    //            This is what must be returned to the application on Enumerate calls.
-    //  expanded_ is the version based on expanding meta-layers into their
-    //            individual component layers.  This is what is used internally.
-    struct loader_layer_list app_activated_layer_list;
-    struct loader_layer_list expanded_activated_layer_list;
-
-    VkAllocationCallbacks alloc_callbacks;
-
-    struct loader_device *next;
-};
-
-// Per ICD information
-
-// Per ICD structure
-struct loader_icd_term {
-    // pointers to find other structs
-    const struct loader_scanned_icd *scanned_icd;
-    const struct loader_instance *this_instance;
-    struct loader_device *logical_device_list;
-    VkInstance instance;  // instance object from the icd
-    struct loader_icd_term_dispatch dispatch;
-
-    struct loader_icd_term *next;
-
-    PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
-};
-
-// Per ICD library structure
-struct loader_icd_tramp_list {
-    size_t capacity;
-    uint32_t count;
-    struct loader_scanned_icd *scanned_list;
-};
-
-struct loader_instance_dispatch_table {
-    VkLayerInstanceDispatchTable layer_inst_disp;  // must be first entry in structure
-
-    // Physical device functions unknown to the loader
-    PFN_PhysDevExt phys_dev_ext[MAX_NUM_UNKNOWN_EXTS];
-};
-
-// Per instance structure
-struct loader_instance {
-    struct loader_instance_dispatch_table *disp;  // must be first entry in structure
-
-    // We need to manually track physical devices over time.  If the user
-    // re-queries the information, we don't want to delete old data or
-    // create new data unless necessary.
-    uint32_t total_gpu_count;
-    uint32_t phys_dev_count_term;
-    struct loader_physical_device_term **phys_devs_term;
-    uint32_t phys_dev_count_tramp;
-    struct loader_physical_device_tramp **phys_devs_tramp;
-
-    // We also need to manually track physical device groups, but we don't need
-    // loader specific structures since we have that content in the physical
-    // device stored internal to the public structures.
-    uint32_t phys_dev_group_count_term;
-    struct VkPhysicalDeviceGroupPropertiesKHX **phys_dev_groups_term;
-    uint32_t phys_dev_group_count_tramp;
-    struct VkPhysicalDeviceGroupPropertiesKHX **phys_dev_groups_tramp;
-
-    struct loader_instance *next;
-
-    uint32_t total_icd_count;
-    struct loader_icd_term *icd_terms;
-    struct loader_icd_tramp_list icd_tramp_list;
-
-    struct loader_dispatch_hash_entry dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS];
-    struct loader_dispatch_hash_entry phys_dev_ext_disp_hash[MAX_NUM_UNKNOWN_EXTS];
-
-    struct loader_msg_callback_map_entry *icd_msg_callback_map;
-
-    struct loader_layer_list instance_layer_list;
-
-    // List of activated layers.
-    //  app_      is the version based on exactly what the application asked for.
-    //            This is what must be returned to the application on Enumerate calls.
-    //  expanded_ is the version based on expanding meta-layers into their
-    //            individual component layers.  This is what is used internally.
-    struct loader_layer_list app_activated_layer_list;
-    struct loader_layer_list expanded_activated_layer_list;
-
-    VkInstance instance;  // layers/ICD instance returned to trampoline
-
-    struct loader_extension_list ext_list;  // icds and loaders extensions
-    union loader_instance_extension_enables enabled_known_extensions;
-
-    VkLayerDbgFunctionNode *DbgFunctionHead;
-    uint32_t num_tmp_callbacks;
-    VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos;
-    VkDebugReportCallbackEXT *tmp_callbacks;
-
-    VkAllocationCallbacks alloc_callbacks;
-
-    bool wsi_surface_enabled;
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    bool wsi_win32_surface_enabled;
-#endif
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    bool wsi_mir_surface_enabled;
-#endif
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    bool wsi_wayland_surface_enabled;
-#endif
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    bool wsi_xcb_surface_enabled;
-#endif
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    bool wsi_xlib_surface_enabled;
-#endif
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    bool wsi_android_surface_enabled;
-#endif
-    bool wsi_display_enabled;
-};
-
-// VkPhysicalDevice requires special treatment by loader.  Firstly, terminator
-// code must be able to get the struct loader_icd_term to call into the proper
-// driver  (multiple ICD/gpu case). This can be accomplished by wrapping the
-// created VkPhysicalDevice in loader terminate_EnumeratePhysicalDevices().
-// Secondly, the loader must be able to handle wrapped by layer VkPhysicalDevice
-// in trampoline code.  This implies, that the loader trampoline code must also
-// wrap the VkPhysicalDevice object in trampoline code.  Thus, loader has to
-// wrap the VkPhysicalDevice created object twice. In trampoline code it can't
-// rely on the terminator object wrapping since a layer may also wrap. Since
-// trampoline code wraps the VkPhysicalDevice this means all loader trampoline
-// code that passes a VkPhysicalDevice should unwrap it.
-
-// Per enumerated PhysicalDevice structure, used to wrap in trampoline code and
-// also same structure used to wrap in terminator code
-struct loader_physical_device_tramp {
-    struct loader_instance_dispatch_table *disp;  // must be first entry in structure
-    struct loader_instance *this_instance;
-    VkPhysicalDevice phys_dev;  // object from layers/loader terminator
-};
-
-// Per enumerated PhysicalDevice structure, used to wrap in terminator code
-struct loader_physical_device_term {
-    struct loader_instance_dispatch_table *disp;  // must be first entry in structure
-    struct loader_icd_term *this_icd_term;
-    uint8_t icd_index;
-    VkPhysicalDevice phys_dev;  // object from ICD
-};
-
-struct loader_struct {
-    struct loader_instance *instances;
-};
-
-struct loader_scanned_icd {
-    char *lib_name;
-    loader_platform_dl_handle handle;
-    uint32_t api_version;
-    uint32_t interface_version;
-    PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
-    PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;
-    PFN_vkCreateInstance CreateInstance;
-    PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
-};
-
-static inline struct loader_instance *loader_instance(VkInstance instance) { return (struct loader_instance *)instance; }
-
-static inline VkPhysicalDevice loader_unwrap_physical_device(VkPhysicalDevice physicalDevice) {
-    struct loader_physical_device_tramp *phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
-    return phys_dev->phys_dev;
-}
-
-static inline void loader_set_dispatch(void *obj, const void *data) { *((const void **)obj) = data; }
-
-static inline VkLayerDispatchTable *loader_get_dispatch(const void *obj) { return *((VkLayerDispatchTable **)obj); }
-
-static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void *obj) {
-    return *((struct loader_dev_dispatch_table **)obj);
-}
-
-static inline VkLayerInstanceDispatchTable *loader_get_instance_layer_dispatch(const void *obj) {
-    return *((VkLayerInstanceDispatchTable **)obj);
-}
-
-static inline struct loader_instance_dispatch_table *loader_get_instance_dispatch(const void *obj) {
-    return *((struct loader_instance_dispatch_table **)obj);
-}
-
-static inline void loader_init_dispatch(void *obj, const void *data) {
-#ifdef DEBUG
-    assert(valid_loader_magic_value(obj) &&
-           "Incompatible ICD, first dword must be initialized to "
-           "ICD_LOADER_MAGIC. See loader/README.md for details.");
-#endif
-
-    loader_set_dispatch(obj, data);
-}
-
-// Global variables used across files
-extern struct loader_struct loader;
-extern THREAD_LOCAL_DECL struct loader_instance *tls_instance;
-#if defined(_WIN32) && !defined(LOADER_DYNAMIC_LIB)
-extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init);
-#endif
-extern loader_platform_thread_mutex loader_lock;
-extern loader_platform_thread_mutex loader_json_lock;
-
-struct loader_msg_callback_map_entry {
-    VkDebugReportCallbackEXT icd_obj;
-    VkDebugReportCallbackEXT loader_obj;
-};
-
-// Helper function definitions
-void *loader_instance_heap_alloc(const struct loader_instance *instance, size_t size, VkSystemAllocationScope allocationScope);
-void loader_instance_heap_free(const struct loader_instance *instance, void *pMemory);
-void *loader_instance_heap_realloc(const struct loader_instance *instance, void *pMemory, size_t orig_size, size_t size,
-                                   VkSystemAllocationScope alloc_scope);
-void *loader_instance_tls_heap_alloc(size_t size);
-void loader_instance_tls_heap_free(void *pMemory);
-void *loader_device_heap_alloc(const struct loader_device *device, size_t size, VkSystemAllocationScope allocationScope);
-void loader_device_heap_free(const struct loader_device *device, void *pMemory);
-void *loader_device_heap_realloc(const struct loader_device *device, void *pMemory, size_t orig_size, size_t size,
-                                 VkSystemAllocationScope alloc_scope);
-
-void loader_log(const struct loader_instance *inst, VkFlags msg_type, int32_t msg_code, const char *format, ...);
-
-bool compare_vk_extension_properties(const VkExtensionProperties *op1, const VkExtensionProperties *op2);
-
-VkResult loader_validate_layers(const struct loader_instance *inst, const uint32_t layer_count,
-                                const char *const *ppEnabledLayerNames, const struct loader_layer_list *list);
-
-VkResult loader_validate_instance_extensions(const struct loader_instance *inst, const struct loader_extension_list *icd_exts,
-                                             const struct loader_layer_list *instance_layer,
-                                             const VkInstanceCreateInfo *pCreateInfo);
-
-void loader_initialize(void);
-VkResult loader_copy_layer_properties(const struct loader_instance *inst, struct loader_layer_properties *dst,
-                                      struct loader_layer_properties *src);
-bool has_vk_extension_property_array(const VkExtensionProperties *vk_ext_prop, const uint32_t count,
-                                     const VkExtensionProperties *ext_array);
-bool has_vk_extension_property(const VkExtensionProperties *vk_ext_prop, const struct loader_extension_list *ext_list);
-
-VkResult loader_add_to_ext_list(const struct loader_instance *inst, struct loader_extension_list *ext_list,
-                                uint32_t prop_list_count, const VkExtensionProperties *props);
-VkResult loader_add_to_dev_ext_list(const struct loader_instance *inst, struct loader_device_extension_list *ext_list,
-                                    const VkExtensionProperties *props, uint32_t entry_count, char **entrys);
-VkResult loader_add_device_extensions(const struct loader_instance *inst,
-                                      PFN_vkEnumerateDeviceExtensionProperties fpEnumerateDeviceExtensionProperties,
-                                      VkPhysicalDevice physical_device, const char *lib_name,
-                                      struct loader_extension_list *ext_list);
-VkResult loader_init_generic_list(const struct loader_instance *inst, struct loader_generic_list *list_info, size_t element_size);
-void loader_destroy_generic_list(const struct loader_instance *inst, struct loader_generic_list *list);
-void loader_destroy_layer_list(const struct loader_instance *inst, struct loader_device *device,
-                               struct loader_layer_list *layer_list);
-void loader_delete_layer_properties(const struct loader_instance *inst, struct loader_layer_list *layer_list);
-bool loader_find_layer_name_array(const char *name, uint32_t layer_count, const char layer_list[][VK_MAX_EXTENSION_NAME_SIZE]);
-VkResult loader_add_to_layer_list(const struct loader_instance *inst, struct loader_layer_list *list, uint32_t prop_list_count,
-                                  const struct loader_layer_properties *props);
-void loader_find_layer_name_add_list(const struct loader_instance *inst, const char *name, const enum layer_type_flags type_flags,
-                                     const struct loader_layer_list *source_list, struct loader_layer_list *target_list,
-                                     struct loader_layer_list *expanded_target_list);
-void loader_scanned_icd_clear(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
-VkResult loader_icd_scan(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list);
-void loader_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
-void loader_implicit_layer_scan(const struct loader_instance *inst, struct loader_layer_list *instance_layers);
-bool loader_is_implicit_layer_enabled(const struct loader_instance *inst, const struct loader_layer_properties *prop);
-VkResult loader_get_icd_loader_instance_extensions(const struct loader_instance *inst, struct loader_icd_tramp_list *icd_tramp_list,
-                                                   struct loader_extension_list *inst_exts);
-struct loader_icd_term *loader_get_icd_and_device(const VkDevice device, struct loader_device **found_dev, uint32_t *icd_index);
-void loader_init_dispatch_dev_ext(struct loader_instance *inst, struct loader_device *dev);
-void *loader_dev_ext_gpa(struct loader_instance *inst, const char *funcName);
-void *loader_get_dev_ext_trampoline(uint32_t index);
-bool loader_phys_dev_ext_gpa(struct loader_instance *inst, const char *funcName, bool perform_checking, void **tramp_addr,
-                             void **term_addr);
-void *loader_get_phys_dev_ext_tramp(uint32_t index);
-void *loader_get_phys_dev_ext_termin(uint32_t index);
-struct loader_instance *loader_get_instance(const VkInstance instance);
-void loader_deactivate_layers(const struct loader_instance *instance, struct loader_device *device, struct loader_layer_list *list);
-struct loader_device *loader_create_logical_device(const struct loader_instance *inst, const VkAllocationCallbacks *pAllocator);
-void loader_add_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
-                               struct loader_device *found_dev);
-void loader_remove_logical_device(const struct loader_instance *inst, struct loader_icd_term *icd_term,
-                                  struct loader_device *found_dev, const VkAllocationCallbacks *pAllocator);
-// NOTE: Outside of loader, this entry-point is only provided for error
-// cleanup.
-void loader_destroy_logical_device(const struct loader_instance *inst, struct loader_device *dev,
-                                   const VkAllocationCallbacks *pAllocator);
-
-VkResult loader_enable_instance_layers(struct loader_instance *inst, const VkInstanceCreateInfo *pCreateInfo,
-                                       const struct loader_layer_list *instance_layers);
-
-VkResult loader_create_instance_chain(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
-                                      struct loader_instance *inst, VkInstance *created_instance);
-
-void loader_activate_instance_layer_extensions(struct loader_instance *inst, VkInstance created_inst);
-
-VkResult loader_create_device_chain(const struct loader_physical_device_tramp *pd, const VkDeviceCreateInfo *pCreateInfo,
-                                    const VkAllocationCallbacks *pAllocator, const struct loader_instance *inst,
-                                    struct loader_device *dev);
-
-VkResult loader_validate_device_extensions(struct loader_physical_device_tramp *phys_dev,
-                                           const struct loader_layer_list *activated_device_layers,
-                                           const struct loader_extension_list *icd_exts, const VkDeviceCreateInfo *pCreateInfo);
-
-VkResult setupLoaderTrampPhysDevs(VkInstance instance);
-VkResult setupLoaderTermPhysDevs(struct loader_instance *inst);
-
-VkStringErrorFlags vk_string_validate(const int max_length, const char *char_array);
-
-#endif  // LOADER_H
diff --git a/third_party/vulkan/loader/loader_cmake_config.h b/third_party/vulkan/loader/loader_cmake_config.h
deleted file mode 100644
index 3d89882bd..000000000
--- a/third_party/vulkan/loader/loader_cmake_config.h
+++ /dev/null
@@ -1,2 +0,0 @@
-/* #undef HAVE_SECURE_GETENV */
-/* #undef HAVE___SECURE_GETENV */
diff --git a/third_party/vulkan/loader/murmurhash.c b/third_party/vulkan/loader/murmurhash.c
deleted file mode 100644
index db6276f5a..000000000
--- a/third_party/vulkan/loader/murmurhash.c
+++ /dev/null
@@ -1,97 +0,0 @@
-
-/**
- * `murmurhash.h' - murmurhash
- *
- * copyright (c) 2014 joseph werle <joseph.werle@gmail.com>
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and/or associated documentation files (the "Materials"), to
- * deal in the Materials without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Materials, and to permit persons to whom the Materials are
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included in
- * all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- *
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
- * USE OR OTHER DEALINGS IN THE MATERIALS.
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include "murmurhash.h"
-
-uint32_t murmurhash(const char *key, size_t len, uint32_t seed) {
-    uint32_t c1 = 0xcc9e2d51;
-    uint32_t c2 = 0x1b873593;
-    uint32_t r1 = 15;
-    uint32_t r2 = 13;
-    uint32_t m = 5;
-    uint32_t n = 0xe6546b64;
-    uint32_t h = 0;
-    uint32_t k = 0;
-    uint8_t *d = (uint8_t *)key;  // 32 bit extract from `key'
-    const uint32_t *chunks = NULL;
-    const uint8_t *tail = NULL;  // tail - last 8 bytes
-    int i = 0;
-    int l = (int)len / 4;  // chunk length
-
-    h = seed;
-
-    chunks = (const uint32_t *)(d + l * 4);  // body
-    tail = (const uint8_t *)(d + l * 4);     // last 8 byte chunk of `key'
-
-    // for each 4 byte chunk of `key'
-    for (i = -l; i != 0; ++i) {
-        // next 4 byte chunk of `key'
-        k = chunks[i];
-
-        // encode next 4 byte chunk of `key'
-        k *= c1;
-        k = (k << r1) | (k >> (32 - r1));
-        k *= c2;
-
-        // append to hash
-        h ^= k;
-        h = (h << r2) | (h >> (32 - r2));
-        h = h * m + n;
-    }
-
-    k = 0;
-
-    // remainder
-    switch (len & 3) {  // `len % 4'
-        case 3:
-            k ^= (tail[2] << 16);
-        case 2:
-            k ^= (tail[1] << 8);
-
-        case 1:
-            k ^= tail[0];
-            k *= c1;
-            k = (k << r1) | (k >> (32 - r1));
-            k *= c2;
-            h ^= k;
-    }
-
-    h ^= len;
-
-    h ^= (h >> 16);
-    h *= 0x85ebca6b;
-    h ^= (h >> 13);
-    h *= 0xc2b2ae35;
-    h ^= (h >> 16);
-
-    return h;
-}
diff --git a/third_party/vulkan/loader/murmurhash.h b/third_party/vulkan/loader/murmurhash.h
deleted file mode 100644
index 775532e8b..000000000
--- a/third_party/vulkan/loader/murmurhash.h
+++ /dev/null
@@ -1,52 +0,0 @@
-
-/**
- * `murmurhash.h' - murmurhash
- *
- * copyright (c) 2014 joseph werle <joseph.werle@gmail.com>
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and/or associated documentation files (the "Materials"), to
- * deal in the Materials without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Materials, and to permit persons to whom the Materials are
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included in
- * all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- *
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
- * USE OR OTHER DEALINGS IN THE MATERIALS.
- */
-
-#ifndef MURMURHASH_H
-#define MURMURHASH_H 1
-
-#include <stdint.h>
-
-#define MURMURHASH_VERSION "0.0.3"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Returns a murmur hash of `key' based on `seed'
- * using the MurmurHash3 algorithm
- */
-
-uint32_t murmurhash(const char *key, size_t len, uint32_t seed);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/third_party/vulkan/loader/phys_dev_ext.c b/third_party/vulkan/loader/phys_dev_ext.c
deleted file mode 100644
index 91e0ef8f6..000000000
--- a/third_party/vulkan/loader/phys_dev_ext.c
+++ /dev/null
@@ -1,1056 +0,0 @@
-/*
- *
- * Copyright (c) 2016-17 The Khronos Group Inc.
- * Copyright (c) 2016-17 Valve Corporation
- * Copyright (c) 2016-17 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Young <marky@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- *
- */
-
-// This code is used to enable generic instance extensions which use a physical device
-// as the first parameter.  If the extension is already known by the loader, it will
-// not use this code, but instead use the more direct route.  However, if it is
-// unknown to the loader, it will use this code.  Technically, this is not trampoline
-// code since we don't want to optimize it out.
-
-#include "vk_loader_platform.h"
-#include "loader.h"
-
-#if defined(__GNUC__) && !defined(__clang__)
-#pragma GCC optimize(3)  // force gcc to use tail-calls
-#endif
-
-// Declarations for the trampoline
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp0(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp1(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp2(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp3(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp4(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp5(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp6(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp7(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp8(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp9(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp10(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp11(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp12(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp13(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp14(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp15(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp16(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp17(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp18(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp19(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp20(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp21(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp22(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp23(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp24(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp25(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp26(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp27(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp28(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp29(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp30(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp31(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp32(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp33(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp34(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp35(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp36(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp37(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp38(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp39(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp40(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp41(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp42(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp43(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp44(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp45(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp46(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp47(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp48(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp49(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp50(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp51(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp52(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp53(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp54(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp55(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp56(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp57(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp58(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp59(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp60(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp61(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp62(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp63(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp64(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp65(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp66(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp67(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp68(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp69(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp70(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp71(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp72(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp73(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp74(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp75(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp76(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp77(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp78(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp79(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp80(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp81(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp82(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp83(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp84(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp85(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp86(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp87(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp88(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp89(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp90(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp91(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp92(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp93(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp94(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp95(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp96(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp97(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp98(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp99(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp100(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp101(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp102(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp103(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp104(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp105(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp106(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp107(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp108(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp109(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp110(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp111(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp112(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp113(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp114(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp115(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp116(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp117(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp118(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp119(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp120(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp121(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp122(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp123(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp124(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp125(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp126(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp127(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp128(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp129(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp130(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp131(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp132(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp133(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp134(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp135(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp136(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp137(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp138(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp139(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp140(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp141(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp142(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp143(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp144(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp145(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp146(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp147(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp148(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp149(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp150(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp151(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp152(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp153(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp154(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp155(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp156(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp157(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp158(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp159(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp160(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp161(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp162(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp163(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp164(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp165(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp166(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp167(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp168(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp169(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp170(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp171(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp172(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp173(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp174(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp175(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp176(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp177(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp178(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp179(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp180(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp181(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp182(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp183(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp184(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp185(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp186(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp187(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp188(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp189(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp190(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp191(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp192(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp193(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp194(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp195(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp196(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp197(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp198(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp199(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp200(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp201(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp202(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp203(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp204(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp205(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp206(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp207(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp208(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp209(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp210(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp211(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp212(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp213(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp214(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp215(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp216(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp217(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp218(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp219(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp220(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp221(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp222(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp223(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp224(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp225(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp226(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp227(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp228(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp229(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp230(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp231(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp232(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp233(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp234(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp235(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp236(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp237(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp238(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp239(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp240(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp241(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp242(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp243(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp244(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp245(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp246(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp247(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp248(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp249(VkPhysicalDevice);
-
-// Disable clang-format for lists of macros
-// clang-format off
-
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin0(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin1(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin2(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin3(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin4(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin5(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin6(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin7(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin8(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin9(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin10(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin11(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin12(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin13(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin14(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin15(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin16(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin17(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin18(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin19(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin20(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin21(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin22(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin23(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin24(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin25(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin26(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin27(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin28(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin29(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin30(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin31(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin32(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin33(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin34(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin35(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin36(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin37(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin38(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin39(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin40(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin41(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin42(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin43(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin44(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin45(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin46(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin47(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin48(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin49(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin50(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin51(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin52(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin53(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin54(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin55(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin56(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin57(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin58(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin59(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin60(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin61(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin62(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin63(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin64(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin65(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin66(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin67(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin68(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin69(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin70(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin71(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin72(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin73(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin74(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin75(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin76(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin77(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin78(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin79(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin80(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin81(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin82(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin83(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin84(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin85(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin86(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin87(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin88(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin89(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin90(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin91(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin92(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin93(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin94(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin95(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin96(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin97(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin98(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin99(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin100(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin101(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin102(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin103(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin104(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin105(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin106(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin107(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin108(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin109(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin110(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin111(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin112(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin113(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin114(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin115(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin116(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin117(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin118(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin119(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin120(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin121(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin122(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin123(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin124(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin125(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin126(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin127(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin128(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin129(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin130(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin131(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin132(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin133(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin134(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin135(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin136(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin137(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin138(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin139(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin140(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin141(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin142(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin143(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin144(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin145(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin146(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin147(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin148(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin149(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin150(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin151(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin152(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin153(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin154(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin155(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin156(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin157(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin158(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin159(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin160(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin161(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin162(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin163(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin164(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin165(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin166(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin167(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin168(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin169(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin170(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin171(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin172(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin173(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin174(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin175(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin176(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin177(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin178(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin179(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin180(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin181(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin182(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin183(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin184(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin185(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin186(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin187(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin188(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin189(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin190(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin191(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin192(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin193(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin194(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin195(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin196(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin197(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin198(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin199(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin200(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin201(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin202(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin203(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin204(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin205(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin206(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin207(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin208(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin209(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin210(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin211(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin212(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin213(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin214(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin215(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin216(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin217(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin218(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin219(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin220(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin221(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin222(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin223(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin224(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin225(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin226(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin227(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin228(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin229(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin230(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin231(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin232(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin233(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin234(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin235(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin236(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin237(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin238(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin239(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin240(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin241(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin242(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin243(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin244(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin245(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin246(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin247(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin248(VkPhysicalDevice);
-VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin249(VkPhysicalDevice);
-
-
-void *loader_get_phys_dev_ext_tramp(uint32_t index) {
-    switch (index) {
-#define TRAMP_CASE_HANDLE(num) case num: return vkPhysDevExtTramp##num
-        TRAMP_CASE_HANDLE(0);
-        TRAMP_CASE_HANDLE(1);
-        TRAMP_CASE_HANDLE(2);
-        TRAMP_CASE_HANDLE(3);
-        TRAMP_CASE_HANDLE(4);
-        TRAMP_CASE_HANDLE(5);
-        TRAMP_CASE_HANDLE(6);
-        TRAMP_CASE_HANDLE(7);
-        TRAMP_CASE_HANDLE(8);
-        TRAMP_CASE_HANDLE(9);
-        TRAMP_CASE_HANDLE(10);
-        TRAMP_CASE_HANDLE(11);
-        TRAMP_CASE_HANDLE(12);
-        TRAMP_CASE_HANDLE(13);
-        TRAMP_CASE_HANDLE(14);
-        TRAMP_CASE_HANDLE(15);
-        TRAMP_CASE_HANDLE(16);
-        TRAMP_CASE_HANDLE(17);
-        TRAMP_CASE_HANDLE(18);
-        TRAMP_CASE_HANDLE(19);
-        TRAMP_CASE_HANDLE(20);
-        TRAMP_CASE_HANDLE(21);
-        TRAMP_CASE_HANDLE(22);
-        TRAMP_CASE_HANDLE(23);
-        TRAMP_CASE_HANDLE(24);
-        TRAMP_CASE_HANDLE(25);
-        TRAMP_CASE_HANDLE(26);
-        TRAMP_CASE_HANDLE(27);
-        TRAMP_CASE_HANDLE(28);
-        TRAMP_CASE_HANDLE(29);
-        TRAMP_CASE_HANDLE(30);
-        TRAMP_CASE_HANDLE(31);
-        TRAMP_CASE_HANDLE(32);
-        TRAMP_CASE_HANDLE(33);
-        TRAMP_CASE_HANDLE(34);
-        TRAMP_CASE_HANDLE(35);
-        TRAMP_CASE_HANDLE(36);
-        TRAMP_CASE_HANDLE(37);
-        TRAMP_CASE_HANDLE(38);
-        TRAMP_CASE_HANDLE(39);
-        TRAMP_CASE_HANDLE(40);
-        TRAMP_CASE_HANDLE(41);
-        TRAMP_CASE_HANDLE(42);
-        TRAMP_CASE_HANDLE(43);
-        TRAMP_CASE_HANDLE(44);
-        TRAMP_CASE_HANDLE(45);
-        TRAMP_CASE_HANDLE(46);
-        TRAMP_CASE_HANDLE(47);
-        TRAMP_CASE_HANDLE(48);
-        TRAMP_CASE_HANDLE(49);
-        TRAMP_CASE_HANDLE(50);
-        TRAMP_CASE_HANDLE(51);
-        TRAMP_CASE_HANDLE(52);
-        TRAMP_CASE_HANDLE(53);
-        TRAMP_CASE_HANDLE(54);
-        TRAMP_CASE_HANDLE(55);
-        TRAMP_CASE_HANDLE(56);
-        TRAMP_CASE_HANDLE(57);
-        TRAMP_CASE_HANDLE(58);
-        TRAMP_CASE_HANDLE(59);
-        TRAMP_CASE_HANDLE(60);
-        TRAMP_CASE_HANDLE(61);
-        TRAMP_CASE_HANDLE(62);
-        TRAMP_CASE_HANDLE(63);
-        TRAMP_CASE_HANDLE(64);
-        TRAMP_CASE_HANDLE(65);
-        TRAMP_CASE_HANDLE(66);
-        TRAMP_CASE_HANDLE(67);
-        TRAMP_CASE_HANDLE(68);
-        TRAMP_CASE_HANDLE(69);
-        TRAMP_CASE_HANDLE(70);
-        TRAMP_CASE_HANDLE(71);
-        TRAMP_CASE_HANDLE(72);
-        TRAMP_CASE_HANDLE(73);
-        TRAMP_CASE_HANDLE(74);
-        TRAMP_CASE_HANDLE(75);
-        TRAMP_CASE_HANDLE(76);
-        TRAMP_CASE_HANDLE(77);
-        TRAMP_CASE_HANDLE(78);
-        TRAMP_CASE_HANDLE(79);
-        TRAMP_CASE_HANDLE(80);
-        TRAMP_CASE_HANDLE(81);
-        TRAMP_CASE_HANDLE(82);
-        TRAMP_CASE_HANDLE(83);
-        TRAMP_CASE_HANDLE(84);
-        TRAMP_CASE_HANDLE(85);
-        TRAMP_CASE_HANDLE(86);
-        TRAMP_CASE_HANDLE(87);
-        TRAMP_CASE_HANDLE(88);
-        TRAMP_CASE_HANDLE(89);
-        TRAMP_CASE_HANDLE(90);
-        TRAMP_CASE_HANDLE(91);
-        TRAMP_CASE_HANDLE(92);
-        TRAMP_CASE_HANDLE(93);
-        TRAMP_CASE_HANDLE(94);
-        TRAMP_CASE_HANDLE(95);
-        TRAMP_CASE_HANDLE(96);
-        TRAMP_CASE_HANDLE(97);
-        TRAMP_CASE_HANDLE(98);
-        TRAMP_CASE_HANDLE(99);
-        TRAMP_CASE_HANDLE(100);
-        TRAMP_CASE_HANDLE(101);
-        TRAMP_CASE_HANDLE(102);
-        TRAMP_CASE_HANDLE(103);
-        TRAMP_CASE_HANDLE(104);
-        TRAMP_CASE_HANDLE(105);
-        TRAMP_CASE_HANDLE(106);
-        TRAMP_CASE_HANDLE(107);
-        TRAMP_CASE_HANDLE(108);
-        TRAMP_CASE_HANDLE(109);
-        TRAMP_CASE_HANDLE(110);
-        TRAMP_CASE_HANDLE(111);
-        TRAMP_CASE_HANDLE(112);
-        TRAMP_CASE_HANDLE(113);
-        TRAMP_CASE_HANDLE(114);
-        TRAMP_CASE_HANDLE(115);
-        TRAMP_CASE_HANDLE(116);
-        TRAMP_CASE_HANDLE(117);
-        TRAMP_CASE_HANDLE(118);
-        TRAMP_CASE_HANDLE(119);
-        TRAMP_CASE_HANDLE(120);
-        TRAMP_CASE_HANDLE(121);
-        TRAMP_CASE_HANDLE(122);
-        TRAMP_CASE_HANDLE(123);
-        TRAMP_CASE_HANDLE(124);
-        TRAMP_CASE_HANDLE(125);
-        TRAMP_CASE_HANDLE(126);
-        TRAMP_CASE_HANDLE(127);
-        TRAMP_CASE_HANDLE(128);
-        TRAMP_CASE_HANDLE(129);
-        TRAMP_CASE_HANDLE(130);
-        TRAMP_CASE_HANDLE(131);
-        TRAMP_CASE_HANDLE(132);
-        TRAMP_CASE_HANDLE(133);
-        TRAMP_CASE_HANDLE(134);
-        TRAMP_CASE_HANDLE(135);
-        TRAMP_CASE_HANDLE(136);
-        TRAMP_CASE_HANDLE(137);
-        TRAMP_CASE_HANDLE(138);
-        TRAMP_CASE_HANDLE(139);
-        TRAMP_CASE_HANDLE(140);
-        TRAMP_CASE_HANDLE(141);
-        TRAMP_CASE_HANDLE(142);
-        TRAMP_CASE_HANDLE(143);
-        TRAMP_CASE_HANDLE(144);
-        TRAMP_CASE_HANDLE(145);
-        TRAMP_CASE_HANDLE(146);
-        TRAMP_CASE_HANDLE(147);
-        TRAMP_CASE_HANDLE(148);
-        TRAMP_CASE_HANDLE(149);
-        TRAMP_CASE_HANDLE(150);
-        TRAMP_CASE_HANDLE(151);
-        TRAMP_CASE_HANDLE(152);
-        TRAMP_CASE_HANDLE(153);
-        TRAMP_CASE_HANDLE(154);
-        TRAMP_CASE_HANDLE(155);
-        TRAMP_CASE_HANDLE(156);
-        TRAMP_CASE_HANDLE(157);
-        TRAMP_CASE_HANDLE(158);
-        TRAMP_CASE_HANDLE(159);
-        TRAMP_CASE_HANDLE(160);
-        TRAMP_CASE_HANDLE(161);
-        TRAMP_CASE_HANDLE(162);
-        TRAMP_CASE_HANDLE(163);
-        TRAMP_CASE_HANDLE(164);
-        TRAMP_CASE_HANDLE(165);
-        TRAMP_CASE_HANDLE(166);
-        TRAMP_CASE_HANDLE(167);
-        TRAMP_CASE_HANDLE(168);
-        TRAMP_CASE_HANDLE(169);
-        TRAMP_CASE_HANDLE(170);
-        TRAMP_CASE_HANDLE(171);
-        TRAMP_CASE_HANDLE(172);
-        TRAMP_CASE_HANDLE(173);
-        TRAMP_CASE_HANDLE(174);
-        TRAMP_CASE_HANDLE(175);
-        TRAMP_CASE_HANDLE(176);
-        TRAMP_CASE_HANDLE(177);
-        TRAMP_CASE_HANDLE(178);
-        TRAMP_CASE_HANDLE(179);
-        TRAMP_CASE_HANDLE(180);
-        TRAMP_CASE_HANDLE(181);
-        TRAMP_CASE_HANDLE(182);
-        TRAMP_CASE_HANDLE(183);
-        TRAMP_CASE_HANDLE(184);
-        TRAMP_CASE_HANDLE(185);
-        TRAMP_CASE_HANDLE(186);
-        TRAMP_CASE_HANDLE(187);
-        TRAMP_CASE_HANDLE(188);
-        TRAMP_CASE_HANDLE(189);
-        TRAMP_CASE_HANDLE(190);
-        TRAMP_CASE_HANDLE(191);
-        TRAMP_CASE_HANDLE(192);
-        TRAMP_CASE_HANDLE(193);
-        TRAMP_CASE_HANDLE(194);
-        TRAMP_CASE_HANDLE(195);
-        TRAMP_CASE_HANDLE(196);
-        TRAMP_CASE_HANDLE(197);
-        TRAMP_CASE_HANDLE(198);
-        TRAMP_CASE_HANDLE(199);
-        TRAMP_CASE_HANDLE(200);
-        TRAMP_CASE_HANDLE(201);
-        TRAMP_CASE_HANDLE(202);
-        TRAMP_CASE_HANDLE(203);
-        TRAMP_CASE_HANDLE(204);
-        TRAMP_CASE_HANDLE(205);
-        TRAMP_CASE_HANDLE(206);
-        TRAMP_CASE_HANDLE(207);
-        TRAMP_CASE_HANDLE(208);
-        TRAMP_CASE_HANDLE(209);
-        TRAMP_CASE_HANDLE(210);
-        TRAMP_CASE_HANDLE(211);
-        TRAMP_CASE_HANDLE(212);
-        TRAMP_CASE_HANDLE(213);
-        TRAMP_CASE_HANDLE(214);
-        TRAMP_CASE_HANDLE(215);
-        TRAMP_CASE_HANDLE(216);
-        TRAMP_CASE_HANDLE(217);
-        TRAMP_CASE_HANDLE(218);
-        TRAMP_CASE_HANDLE(219);
-        TRAMP_CASE_HANDLE(220);
-        TRAMP_CASE_HANDLE(221);
-        TRAMP_CASE_HANDLE(222);
-        TRAMP_CASE_HANDLE(223);
-        TRAMP_CASE_HANDLE(224);
-        TRAMP_CASE_HANDLE(225);
-        TRAMP_CASE_HANDLE(226);
-        TRAMP_CASE_HANDLE(227);
-        TRAMP_CASE_HANDLE(228);
-        TRAMP_CASE_HANDLE(229);
-        TRAMP_CASE_HANDLE(230);
-        TRAMP_CASE_HANDLE(231);
-        TRAMP_CASE_HANDLE(232);
-        TRAMP_CASE_HANDLE(233);
-        TRAMP_CASE_HANDLE(234);
-        TRAMP_CASE_HANDLE(235);
-        TRAMP_CASE_HANDLE(236);
-        TRAMP_CASE_HANDLE(237);
-        TRAMP_CASE_HANDLE(238);
-        TRAMP_CASE_HANDLE(239);
-        TRAMP_CASE_HANDLE(240);
-        TRAMP_CASE_HANDLE(241);
-        TRAMP_CASE_HANDLE(242);
-        TRAMP_CASE_HANDLE(243);
-        TRAMP_CASE_HANDLE(244);
-        TRAMP_CASE_HANDLE(245);
-        TRAMP_CASE_HANDLE(246);
-        TRAMP_CASE_HANDLE(247);
-        TRAMP_CASE_HANDLE(248);
-        TRAMP_CASE_HANDLE(249);
-    }
-    return NULL;
-}
-
-void *loader_get_phys_dev_ext_termin(uint32_t index) {
-    switch (index) {
-#define TERM_CASE_HANDLE(num) case num: return vkPhysDevExtTermin##num
-        TERM_CASE_HANDLE(0);
-        TERM_CASE_HANDLE(1);
-        TERM_CASE_HANDLE(2);
-        TERM_CASE_HANDLE(3);
-        TERM_CASE_HANDLE(4);
-        TERM_CASE_HANDLE(5);
-        TERM_CASE_HANDLE(6);
-        TERM_CASE_HANDLE(7);
-        TERM_CASE_HANDLE(8);
-        TERM_CASE_HANDLE(9);
-        TERM_CASE_HANDLE(10);
-        TERM_CASE_HANDLE(11);
-        TERM_CASE_HANDLE(12);
-        TERM_CASE_HANDLE(13);
-        TERM_CASE_HANDLE(14);
-        TERM_CASE_HANDLE(15);
-        TERM_CASE_HANDLE(16);
-        TERM_CASE_HANDLE(17);
-        TERM_CASE_HANDLE(18);
-        TERM_CASE_HANDLE(19);
-        TERM_CASE_HANDLE(20);
-        TERM_CASE_HANDLE(21);
-        TERM_CASE_HANDLE(22);
-        TERM_CASE_HANDLE(23);
-        TERM_CASE_HANDLE(24);
-        TERM_CASE_HANDLE(25);
-        TERM_CASE_HANDLE(26);
-        TERM_CASE_HANDLE(27);
-        TERM_CASE_HANDLE(28);
-        TERM_CASE_HANDLE(29);
-        TERM_CASE_HANDLE(30);
-        TERM_CASE_HANDLE(31);
-        TERM_CASE_HANDLE(32);
-        TERM_CASE_HANDLE(33);
-        TERM_CASE_HANDLE(34);
-        TERM_CASE_HANDLE(35);
-        TERM_CASE_HANDLE(36);
-        TERM_CASE_HANDLE(37);
-        TERM_CASE_HANDLE(38);
-        TERM_CASE_HANDLE(39);
-        TERM_CASE_HANDLE(40);
-        TERM_CASE_HANDLE(41);
-        TERM_CASE_HANDLE(42);
-        TERM_CASE_HANDLE(43);
-        TERM_CASE_HANDLE(44);
-        TERM_CASE_HANDLE(45);
-        TERM_CASE_HANDLE(46);
-        TERM_CASE_HANDLE(47);
-        TERM_CASE_HANDLE(48);
-        TERM_CASE_HANDLE(49);
-        TERM_CASE_HANDLE(50);
-        TERM_CASE_HANDLE(51);
-        TERM_CASE_HANDLE(52);
-        TERM_CASE_HANDLE(53);
-        TERM_CASE_HANDLE(54);
-        TERM_CASE_HANDLE(55);
-        TERM_CASE_HANDLE(56);
-        TERM_CASE_HANDLE(57);
-        TERM_CASE_HANDLE(58);
-        TERM_CASE_HANDLE(59);
-        TERM_CASE_HANDLE(60);
-        TERM_CASE_HANDLE(61);
-        TERM_CASE_HANDLE(62);
-        TERM_CASE_HANDLE(63);
-        TERM_CASE_HANDLE(64);
-        TERM_CASE_HANDLE(65);
-        TERM_CASE_HANDLE(66);
-        TERM_CASE_HANDLE(67);
-        TERM_CASE_HANDLE(68);
-        TERM_CASE_HANDLE(69);
-        TERM_CASE_HANDLE(70);
-        TERM_CASE_HANDLE(71);
-        TERM_CASE_HANDLE(72);
-        TERM_CASE_HANDLE(73);
-        TERM_CASE_HANDLE(74);
-        TERM_CASE_HANDLE(75);
-        TERM_CASE_HANDLE(76);
-        TERM_CASE_HANDLE(77);
-        TERM_CASE_HANDLE(78);
-        TERM_CASE_HANDLE(79);
-        TERM_CASE_HANDLE(80);
-        TERM_CASE_HANDLE(81);
-        TERM_CASE_HANDLE(82);
-        TERM_CASE_HANDLE(83);
-        TERM_CASE_HANDLE(84);
-        TERM_CASE_HANDLE(85);
-        TERM_CASE_HANDLE(86);
-        TERM_CASE_HANDLE(87);
-        TERM_CASE_HANDLE(88);
-        TERM_CASE_HANDLE(89);
-        TERM_CASE_HANDLE(90);
-        TERM_CASE_HANDLE(91);
-        TERM_CASE_HANDLE(92);
-        TERM_CASE_HANDLE(93);
-        TERM_CASE_HANDLE(94);
-        TERM_CASE_HANDLE(95);
-        TERM_CASE_HANDLE(96);
-        TERM_CASE_HANDLE(97);
-        TERM_CASE_HANDLE(98);
-        TERM_CASE_HANDLE(99);
-        TERM_CASE_HANDLE(100);
-        TERM_CASE_HANDLE(101);
-        TERM_CASE_HANDLE(102);
-        TERM_CASE_HANDLE(103);
-        TERM_CASE_HANDLE(104);
-        TERM_CASE_HANDLE(105);
-        TERM_CASE_HANDLE(106);
-        TERM_CASE_HANDLE(107);
-        TERM_CASE_HANDLE(108);
-        TERM_CASE_HANDLE(109);
-        TERM_CASE_HANDLE(110);
-        TERM_CASE_HANDLE(111);
-        TERM_CASE_HANDLE(112);
-        TERM_CASE_HANDLE(113);
-        TERM_CASE_HANDLE(114);
-        TERM_CASE_HANDLE(115);
-        TERM_CASE_HANDLE(116);
-        TERM_CASE_HANDLE(117);
-        TERM_CASE_HANDLE(118);
-        TERM_CASE_HANDLE(119);
-        TERM_CASE_HANDLE(120);
-        TERM_CASE_HANDLE(121);
-        TERM_CASE_HANDLE(122);
-        TERM_CASE_HANDLE(123);
-        TERM_CASE_HANDLE(124);
-        TERM_CASE_HANDLE(125);
-        TERM_CASE_HANDLE(126);
-        TERM_CASE_HANDLE(127);
-        TERM_CASE_HANDLE(128);
-        TERM_CASE_HANDLE(129);
-        TERM_CASE_HANDLE(130);
-        TERM_CASE_HANDLE(131);
-        TERM_CASE_HANDLE(132);
-        TERM_CASE_HANDLE(133);
-        TERM_CASE_HANDLE(134);
-        TERM_CASE_HANDLE(135);
-        TERM_CASE_HANDLE(136);
-        TERM_CASE_HANDLE(137);
-        TERM_CASE_HANDLE(138);
-        TERM_CASE_HANDLE(139);
-        TERM_CASE_HANDLE(140);
-        TERM_CASE_HANDLE(141);
-        TERM_CASE_HANDLE(142);
-        TERM_CASE_HANDLE(143);
-        TERM_CASE_HANDLE(144);
-        TERM_CASE_HANDLE(145);
-        TERM_CASE_HANDLE(146);
-        TERM_CASE_HANDLE(147);
-        TERM_CASE_HANDLE(148);
-        TERM_CASE_HANDLE(149);
-        TERM_CASE_HANDLE(150);
-        TERM_CASE_HANDLE(151);
-        TERM_CASE_HANDLE(152);
-        TERM_CASE_HANDLE(153);
-        TERM_CASE_HANDLE(154);
-        TERM_CASE_HANDLE(155);
-        TERM_CASE_HANDLE(156);
-        TERM_CASE_HANDLE(157);
-        TERM_CASE_HANDLE(158);
-        TERM_CASE_HANDLE(159);
-        TERM_CASE_HANDLE(160);
-        TERM_CASE_HANDLE(161);
-        TERM_CASE_HANDLE(162);
-        TERM_CASE_HANDLE(163);
-        TERM_CASE_HANDLE(164);
-        TERM_CASE_HANDLE(165);
-        TERM_CASE_HANDLE(166);
-        TERM_CASE_HANDLE(167);
-        TERM_CASE_HANDLE(168);
-        TERM_CASE_HANDLE(169);
-        TERM_CASE_HANDLE(170);
-        TERM_CASE_HANDLE(171);
-        TERM_CASE_HANDLE(172);
-        TERM_CASE_HANDLE(173);
-        TERM_CASE_HANDLE(174);
-        TERM_CASE_HANDLE(175);
-        TERM_CASE_HANDLE(176);
-        TERM_CASE_HANDLE(177);
-        TERM_CASE_HANDLE(178);
-        TERM_CASE_HANDLE(179);
-        TERM_CASE_HANDLE(180);
-        TERM_CASE_HANDLE(181);
-        TERM_CASE_HANDLE(182);
-        TERM_CASE_HANDLE(183);
-        TERM_CASE_HANDLE(184);
-        TERM_CASE_HANDLE(185);
-        TERM_CASE_HANDLE(186);
-        TERM_CASE_HANDLE(187);
-        TERM_CASE_HANDLE(188);
-        TERM_CASE_HANDLE(189);
-        TERM_CASE_HANDLE(190);
-        TERM_CASE_HANDLE(191);
-        TERM_CASE_HANDLE(192);
-        TERM_CASE_HANDLE(193);
-        TERM_CASE_HANDLE(194);
-        TERM_CASE_HANDLE(195);
-        TERM_CASE_HANDLE(196);
-        TERM_CASE_HANDLE(197);
-        TERM_CASE_HANDLE(198);
-        TERM_CASE_HANDLE(199);
-        TERM_CASE_HANDLE(200);
-        TERM_CASE_HANDLE(201);
-        TERM_CASE_HANDLE(202);
-        TERM_CASE_HANDLE(203);
-        TERM_CASE_HANDLE(204);
-        TERM_CASE_HANDLE(205);
-        TERM_CASE_HANDLE(206);
-        TERM_CASE_HANDLE(207);
-        TERM_CASE_HANDLE(208);
-        TERM_CASE_HANDLE(209);
-        TERM_CASE_HANDLE(210);
-        TERM_CASE_HANDLE(211);
-        TERM_CASE_HANDLE(212);
-        TERM_CASE_HANDLE(213);
-        TERM_CASE_HANDLE(214);
-        TERM_CASE_HANDLE(215);
-        TERM_CASE_HANDLE(216);
-        TERM_CASE_HANDLE(217);
-        TERM_CASE_HANDLE(218);
-        TERM_CASE_HANDLE(219);
-        TERM_CASE_HANDLE(220);
-        TERM_CASE_HANDLE(221);
-        TERM_CASE_HANDLE(222);
-        TERM_CASE_HANDLE(223);
-        TERM_CASE_HANDLE(224);
-        TERM_CASE_HANDLE(225);
-        TERM_CASE_HANDLE(226);
-        TERM_CASE_HANDLE(227);
-        TERM_CASE_HANDLE(228);
-        TERM_CASE_HANDLE(229);
-        TERM_CASE_HANDLE(230);
-        TERM_CASE_HANDLE(231);
-        TERM_CASE_HANDLE(232);
-        TERM_CASE_HANDLE(233);
-        TERM_CASE_HANDLE(234);
-        TERM_CASE_HANDLE(235);
-        TERM_CASE_HANDLE(236);
-        TERM_CASE_HANDLE(237);
-        TERM_CASE_HANDLE(238);
-        TERM_CASE_HANDLE(239);
-        TERM_CASE_HANDLE(240);
-        TERM_CASE_HANDLE(241);
-        TERM_CASE_HANDLE(242);
-        TERM_CASE_HANDLE(243);
-        TERM_CASE_HANDLE(244);
-        TERM_CASE_HANDLE(245);
-        TERM_CASE_HANDLE(246);
-        TERM_CASE_HANDLE(247);
-        TERM_CASE_HANDLE(248);
-        TERM_CASE_HANDLE(249);
-    }
-    return NULL;
-}
diff --git a/third_party/vulkan/loader/premake5.lua b/third_party/vulkan/loader/premake5.lua
deleted file mode 100644
index 112936c27..000000000
--- a/third_party/vulkan/loader/premake5.lua
+++ /dev/null
@@ -1,41 +0,0 @@
-group("third_party")
-project("vulkan-loader")
-  uuid("07d77359-1618-43e6-8a4a-0ee9ddc5fa6a")
-  kind("StaticLib")
-  language("C")
-
-  defines({
-    "_LIB",
-    "API_NAME=\"vulkan\"",
-  })
-  removedefines({
-    "_UNICODE",
-    "UNICODE",
-  })
-  includedirs({
-    ".",
-  })
-  recursive_platform_files()
-
-  -- Included elsewhere
-  removefiles("vk_loader_extensions.c")
-
-  filter("platforms:Windows")
-    warnings("Off")  -- Too many warnings.
-    characterset("MBCS")
-    defines({
-      "VK_USE_PLATFORM_WIN32_KHR",
-    })
-    links({
-      "Cfgmgr32"
-    })
-  filter("platforms:not Windows")
-    removefiles("dirent_on_windows.c")
-  filter("platforms:Linux")
-    defines({
-      "VK_USE_PLATFORM_XCB_KHR",
-      [[SYSCONFDIR="\"/etc\""]],
-      [[FALLBACK_CONFIG_DIRS="\"/etc/xdg\""]],
-      [[DATADIR="\"/usr/share\""]],
-      [[FALLBACK_DATA_DIRS="\"/usr/share:/usr/local/share\""]],
-    })
diff --git a/third_party/vulkan/loader/trampoline.c b/third_party/vulkan/loader/trampoline.c
deleted file mode 100644
index 607085c69..000000000
--- a/third_party/vulkan/loader/trampoline.c
+++ /dev/null
@@ -1,1994 +0,0 @@
-/*
- *
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- * Copyright (C) 2015 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Tony Barbour <tony@LunarG.com>
- * Author: Chia-I Wu <olv@lunarg.com>
- */
-#define _GNU_SOURCE
-#include <stdlib.h>
-#include <string.h>
-
-#include "vk_loader_platform.h"
-#include "loader.h"
-#include "debug_report.h"
-#include "wsi.h"
-#include "vk_loader_extensions.h"
-#include "gpa_helper.h"
-
-// Trampoline entrypoints are in this file for core Vulkan commands
-
-// Get an instance level or global level entry point address.
-// @param instance
-// @param pName
-// @return
-//    If instance == NULL returns a global level functions only
-//    If instance is valid returns a trampoline entry point for all dispatchable Vulkan
-//    functions both core and extensions.
-LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName) {
-    void *addr;
-
-    addr = globalGetProcAddr(pName);
-    if (instance == VK_NULL_HANDLE || addr != NULL) {
-        return addr;
-    }
-
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (ptr_instance == NULL) return NULL;
-    // Return trampoline code for non-global entrypoints including any extensions.
-    // Device extensions are returned if a layer or ICD supports the extension.
-    // Instance extensions are returned if the extension is enabled and the
-    // loader or someone else supports the extension
-    return trampolineGetProcAddr(ptr_instance, pName);
-}
-
-// Get a device level or global level entry point address.
-// @param device
-// @param pName
-// @return
-//    If device is valid, returns a device relative entry point for device level
-//    entry points both core and extensions.
-//    Device relative means call down the device chain.
-LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName) {
-    void *addr;
-
-    // For entrypoints that loader must handle (ie non-dispatchable or create object)
-    // make sure the loader entrypoint is returned
-    addr = loader_non_passthrough_gdpa(pName);
-    if (addr) {
-        return addr;
-    }
-
-    // Although CreateDevice is on device chain it's dispatchable object isn't
-    // a VkDevice or child of VkDevice so return NULL.
-    if (!strcmp(pName, "CreateDevice")) return NULL;
-
-    // Return the dispatch table entrypoint for the fastest case
-    const VkLayerDispatchTable *disp_table = *(VkLayerDispatchTable **)device;
-    if (disp_table == NULL) return NULL;
-
-    addr = loader_lookup_device_dispatch_table(disp_table, pName);
-    if (addr) return addr;
-
-    if (disp_table->GetDeviceProcAddr == NULL) return NULL;
-    return disp_table->GetDeviceProcAddr(device, pName);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName,
-                                                                                    uint32_t *pPropertyCount,
-                                                                                    VkExtensionProperties *pProperties) {
-    tls_instance = NULL;
-    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
-
-    // We know we need to call at least the terminator
-    VkResult res = VK_SUCCESS;
-    VkEnumerateInstanceExtensionPropertiesChain chain_tail = {
-        .header =
-            {
-                .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES,
-                .version = VK_CURRENT_CHAIN_VERSION,
-                .size = sizeof(chain_tail),
-            },
-        .pfnNextLayer = &terminator_EnumerateInstanceExtensionProperties,
-        .pNextLink = NULL,
-    };
-    VkEnumerateInstanceExtensionPropertiesChain *chain_head = &chain_tail;
-
-    // Get the implicit layers
-    struct loader_layer_list layers;
-    memset(&layers, 0, sizeof(layers));
-    loader_implicit_layer_scan(NULL, &layers);
-
-    // We'll need to save the dl handles so we can close them later
-    loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count);
-    if (libs == NULL) {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    size_t lib_count = 0;
-
-    // Prepend layers onto the chain if they implment this entry point
-    for (uint32_t i = 0; i < layers.count; ++i) {
-        if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) ||
-            layers.list[i].pre_instance_functions.enumerate_instance_extension_properties[0] == '\0') {
-            continue;
-        }
-
-        loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name);
-        libs[lib_count++] = layer_lib;
-        void *pfn = loader_platform_get_proc_address(layer_lib,
-                                                     layers.list[i].pre_instance_functions.enumerate_instance_extension_properties);
-        if (pfn == NULL) {
-            loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__,
-                       layers.list[i].pre_instance_functions.enumerate_instance_extension_properties, layers.list[i].lib_name);
-            continue;
-        }
-
-        VkEnumerateInstanceExtensionPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceExtensionPropertiesChain));
-        if (chain_link == NULL) {
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            break;
-        }
-
-        chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES;
-        chain_link->header.version = VK_CURRENT_CHAIN_VERSION;
-        chain_link->header.size = sizeof(*chain_link);
-        chain_link->pfnNextLayer = pfn;
-        chain_link->pNextLink = chain_head;
-
-        chain_head = chain_link;
-    }
-
-    // Call down the chain
-    if (res == VK_SUCCESS) {
-        res = chain_head->pfnNextLayer(chain_head->pNextLink, pLayerName, pPropertyCount, pProperties);
-    }
-
-    // Free up the layers
-    loader_delete_layer_properties(NULL, &layers);
-
-    // Tear down the chain
-    while (chain_head != &chain_tail) {
-        VkEnumerateInstanceExtensionPropertiesChain *holder = chain_head;
-        chain_head = (VkEnumerateInstanceExtensionPropertiesChain *)chain_head->pNextLink;
-        free(holder);
-    }
-
-    // Close the dl handles
-    for (size_t i = 0; i < lib_count; ++i) {
-        loader_platform_close_library(libs[i]);
-    }
-    free(libs);
-
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
-                                                                                VkLayerProperties *pProperties) {
-    tls_instance = NULL;
-    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
-
-    // We know we need to call at least the terminator
-    VkResult res = VK_SUCCESS;
-    VkEnumerateInstanceLayerPropertiesChain chain_tail = {
-        .header =
-            {
-                .type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES,
-                .version = VK_CURRENT_CHAIN_VERSION,
-                .size = sizeof(chain_tail),
-            },
-        .pfnNextLayer = &terminator_EnumerateInstanceLayerProperties,
-        .pNextLink = NULL,
-    };
-    VkEnumerateInstanceLayerPropertiesChain *chain_head = &chain_tail;
-
-    // Get the implicit layers
-    struct loader_layer_list layers;
-    memset(&layers, 0, sizeof(layers));
-    loader_implicit_layer_scan(NULL, &layers);
-
-    // We'll need to save the dl handles so we can close them later
-    loader_platform_dl_handle *libs = malloc(sizeof(loader_platform_dl_handle) * layers.count);
-    if (libs == NULL) {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-    size_t lib_count = 0;
-
-    // Prepend layers onto the chain if they implment this entry point
-    for (uint32_t i = 0; i < layers.count; ++i) {
-        if (!loader_is_implicit_layer_enabled(NULL, layers.list + i) ||
-            layers.list[i].pre_instance_functions.enumerate_instance_layer_properties[0] == '\0') {
-            continue;
-        }
-
-        loader_platform_dl_handle layer_lib = loader_platform_open_library(layers.list[i].lib_name);
-        libs[lib_count++] = layer_lib;
-        void *pfn =
-            loader_platform_get_proc_address(layer_lib, layers.list[i].pre_instance_functions.enumerate_instance_layer_properties);
-        if (pfn == NULL) {
-            loader_log(NULL, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0,
-                       "%s: Unable to resolve symbol \"%s\" in implicit layer library \"%s\"", __FUNCTION__,
-                       layers.list[i].pre_instance_functions.enumerate_instance_layer_properties, layers.list[i].lib_name);
-            continue;
-        }
-
-        VkEnumerateInstanceLayerPropertiesChain *chain_link = malloc(sizeof(VkEnumerateInstanceLayerPropertiesChain));
-        if (chain_link == NULL) {
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            break;
-        }
-
-        chain_link->header.type = VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES;
-        chain_link->header.version = VK_CURRENT_CHAIN_VERSION;
-        chain_link->header.size = sizeof(*chain_link);
-        chain_link->pfnNextLayer = pfn;
-        chain_link->pNextLink = chain_head;
-
-        chain_head = chain_link;
-    }
-
-    // Call down the chain
-    if (res == VK_SUCCESS) {
-        res = chain_head->pfnNextLayer(chain_head->pNextLink, pPropertyCount, pProperties);
-    }
-
-    // Free up the layers
-    loader_delete_layer_properties(NULL, &layers);
-
-    // Tear down the chain
-    while (chain_head != &chain_tail) {
-        VkEnumerateInstanceLayerPropertiesChain *holder = chain_head;
-        chain_head = (VkEnumerateInstanceLayerPropertiesChain *)chain_head->pNextLink;
-        free(holder);
-    }
-
-    // Close the dl handles
-    for (size_t i = 0; i < lib_count; ++i) {
-        loader_platform_close_library(libs[i]);
-    }
-    free(libs);
-
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkInstance *pInstance) {
-    struct loader_instance *ptr_instance = NULL;
-    VkInstance created_instance = VK_NULL_HANDLE;
-    bool loaderLocked = false;
-    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
-
-    LOADER_PLATFORM_THREAD_ONCE(&once_init, loader_initialize);
-
-    // Fail if the requested Vulkan apiVersion is > 1.0 since the loader only supports 1.0.
-    // Having pCreateInfo == NULL, pCreateInfo->pApplication == NULL, or
-    // pCreateInfo->pApplicationInfo->apiVersion == 0 all indicate that the application is
-    // only requesting a 1.0 instance, which this loader will always support.
-    uint32_t loader_major_version = 1;
-    uint32_t loader_minor_version = 0;
-    if (NULL != pCreateInfo && NULL != pCreateInfo->pApplicationInfo &&
-        pCreateInfo->pApplicationInfo->apiVersion >= VK_MAKE_VERSION(loader_major_version, loader_minor_version + 1, 0)) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateInstance:  Called with invalid API version %d.%d.  Loader only supports %d.%d",
-                   VK_VERSION_MAJOR(pCreateInfo->pApplicationInfo->apiVersion),
-                   VK_VERSION_MINOR(pCreateInfo->pApplicationInfo->apiVersion), loader_major_version, loader_minor_version);
-        res = VK_ERROR_INCOMPATIBLE_DRIVER;
-        goto out;
-    }
-
-#if (DEBUG_DISABLE_APP_ALLOCATORS == 1)
-    {
-#else
-    if (pAllocator) {
-        ptr_instance = (struct loader_instance *)pAllocator->pfnAllocation(pAllocator->pUserData, sizeof(struct loader_instance),
-                                                                           sizeof(int *), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    } else {
-#endif
-        ptr_instance = (struct loader_instance *)malloc(sizeof(struct loader_instance));
-    }
-
-    VkInstanceCreateInfo ici = *pCreateInfo;
-
-    if (ptr_instance == NULL) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    tls_instance = ptr_instance;
-    loader_platform_thread_lock_mutex(&loader_lock);
-    loaderLocked = true;
-    memset(ptr_instance, 0, sizeof(struct loader_instance));
-    if (pAllocator) {
-        ptr_instance->alloc_callbacks = *pAllocator;
-    }
-
-    // Look for one or more debug report create info structures
-    // and setup a callback(s) for each one found.
-    ptr_instance->num_tmp_callbacks = 0;
-    ptr_instance->tmp_dbg_create_infos = NULL;
-    ptr_instance->tmp_callbacks = NULL;
-    if (util_CopyDebugReportCreateInfos(pCreateInfo->pNext, pAllocator, &ptr_instance->num_tmp_callbacks,
-                                        &ptr_instance->tmp_dbg_create_infos, &ptr_instance->tmp_callbacks)) {
-        // One or more were found, but allocation failed.  Therefore, clean up
-        // and fail this function:
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    } else if (ptr_instance->num_tmp_callbacks > 0) {
-        // Setup the temporary callback(s) here to catch early issues:
-        if (util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
-                                            ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
-            // Failure of setting up one or more of the callback.  Therefore,
-            // clean up and fail this function:
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-    }
-
-    // Due to implicit layers need to get layer list even if
-    // enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
-    // get layer list via loader_layer_scan().
-    memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
-    loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list);
-
-    // Validate the app requested layers to be enabled
-    if (pCreateInfo->enabledLayerCount > 0) {
-        res = loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames,
-                                     &ptr_instance->instance_layer_list);
-        if (res != VK_SUCCESS) {
-            goto out;
-        }
-    }
-
-    // Scan/discover all ICD libraries
-    memset(&ptr_instance->icd_tramp_list, 0, sizeof(ptr_instance->icd_tramp_list));
-    res = loader_icd_scan(ptr_instance, &ptr_instance->icd_tramp_list);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-
-    // Get extensions from all ICD's, merge so no duplicates, then validate
-    res = loader_get_icd_loader_instance_extensions(ptr_instance, &ptr_instance->icd_tramp_list, &ptr_instance->ext_list);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-    res = loader_validate_instance_extensions(ptr_instance, &ptr_instance->ext_list, &ptr_instance->instance_layer_list, &ici);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-
-    ptr_instance->disp = loader_instance_heap_alloc(ptr_instance, sizeof(struct loader_instance_dispatch_table),
-                                                    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
-    if (ptr_instance->disp == NULL) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkCreateInstance:  Failed to allocate Loader's full Instance dispatch table.");
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-    memcpy(&ptr_instance->disp->layer_inst_disp, &instance_disp, sizeof(instance_disp));
-
-    ptr_instance->next = loader.instances;
-    loader.instances = ptr_instance;
-
-    // Activate any layers on instance chain
-    res = loader_enable_instance_layers(ptr_instance, &ici, &ptr_instance->instance_layer_list);
-    if (res != VK_SUCCESS) {
-        goto out;
-    }
-
-    created_instance = (VkInstance)ptr_instance;
-    res = loader_create_instance_chain(&ici, pAllocator, ptr_instance, &created_instance);
-
-    if (res == VK_SUCCESS) {
-        memset(ptr_instance->enabled_known_extensions.padding, 0, sizeof(uint64_t) * 4);
-
-        wsi_create_instance(ptr_instance, &ici);
-        debug_report_create_instance(ptr_instance, &ici);
-        extensions_create_instance(ptr_instance, &ici);
-
-        *pInstance = created_instance;
-
-        // Finally have the layers in place and everyone has seen
-        // the CreateInstance command go by. This allows the layer's
-        // GetInstanceProcAddr functions to return valid extension functions
-        // if enabled.
-        loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
-    }
-
-out:
-
-    if (NULL != ptr_instance) {
-        if (res != VK_SUCCESS) {
-            if (NULL != ptr_instance->next) {
-                loader.instances = ptr_instance->next;
-            }
-            if (NULL != ptr_instance->disp) {
-                loader_instance_heap_free(ptr_instance, ptr_instance->disp);
-            }
-            if (ptr_instance->num_tmp_callbacks > 0) {
-                util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
-                                                 ptr_instance->tmp_callbacks);
-                util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
-            }
-
-            if (NULL != ptr_instance->expanded_activated_layer_list.list) {
-                loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list);
-            }
-            if (NULL != ptr_instance->app_activated_layer_list.list) {
-                loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list);
-            }
-
-            loader_delete_layer_properties(ptr_instance, &ptr_instance->instance_layer_list);
-            loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_tramp_list);
-            loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)&ptr_instance->ext_list);
-
-            loader_instance_heap_free(ptr_instance, ptr_instance);
-        } else {
-            // Remove temporary debug_report callback
-            util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
-                                             ptr_instance->tmp_callbacks);
-        }
-
-        if (loaderLocked) {
-            loader_platform_thread_unlock_mutex(&loader_lock);
-        }
-    }
-
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
-    const VkLayerInstanceDispatchTable *disp;
-    struct loader_instance *ptr_instance = NULL;
-    bool callback_setup = false;
-
-    if (instance == VK_NULL_HANDLE) {
-        return;
-    }
-
-    disp = loader_get_instance_layer_dispatch(instance);
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    ptr_instance = loader_get_instance(instance);
-
-    if (pAllocator) {
-        ptr_instance->alloc_callbacks = *pAllocator;
-    }
-
-    if (ptr_instance->num_tmp_callbacks > 0) {
-        // Setup the temporary callback(s) here to catch cleanup issues:
-        if (!util_CreateDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks,
-                                             ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks)) {
-            callback_setup = true;
-        }
-    }
-
-    disp->DestroyInstance(instance, pAllocator);
-
-    if (NULL != ptr_instance->expanded_activated_layer_list.list) {
-        loader_deactivate_layers(ptr_instance, NULL, &ptr_instance->expanded_activated_layer_list);
-    }
-    if (NULL != ptr_instance->app_activated_layer_list.list) {
-        loader_destroy_layer_list(ptr_instance, NULL, &ptr_instance->app_activated_layer_list);
-    }
-
-    if (ptr_instance->phys_devs_tramp) {
-        for (uint32_t i = 0; i < ptr_instance->phys_dev_count_tramp; i++) {
-            loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp[i]);
-        }
-        loader_instance_heap_free(ptr_instance, ptr_instance->phys_devs_tramp);
-    }
-
-    if (ptr_instance->phys_dev_groups_tramp) {
-        for (uint32_t i = 0; i < ptr_instance->phys_dev_group_count_tramp; i++) {
-            loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp[i]);
-        }
-        loader_instance_heap_free(ptr_instance, ptr_instance->phys_dev_groups_tramp);
-    }
-
-    if (callback_setup) {
-        util_DestroyDebugReportCallbacks(ptr_instance, pAllocator, ptr_instance->num_tmp_callbacks, ptr_instance->tmp_callbacks);
-        util_FreeDebugReportCreateInfos(pAllocator, ptr_instance->tmp_dbg_create_infos, ptr_instance->tmp_callbacks);
-    }
-    loader_instance_heap_free(ptr_instance, ptr_instance->disp);
-    loader_instance_heap_free(ptr_instance, ptr_instance);
-    loader_platform_thread_unlock_mutex(&loader_lock);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
-                                                                        VkPhysicalDevice *pPhysicalDevices) {
-    VkResult res = VK_SUCCESS;
-    uint32_t count;
-    uint32_t i;
-    struct loader_instance *inst;
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    inst = loader_get_instance(instance);
-    if (NULL == inst) {
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    if (NULL == pPhysicalDeviceCount) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "vkEnumeratePhysicalDevices: Received NULL pointer for physical device count return value.");
-        res = VK_ERROR_INITIALIZATION_FAILED;
-        goto out;
-    }
-
-    // Setup the trampoline loader physical devices.  This will actually
-    // call down and setup the terminator loader physical devices during the
-    // process.
-    VkResult setup_res = setupLoaderTrampPhysDevs(instance);
-    if (setup_res != VK_SUCCESS && setup_res != VK_INCOMPLETE) {
-        res = setup_res;
-        goto out;
-    }
-
-    count = inst->phys_dev_count_tramp;
-
-    // Wrap the PhysDev object for loader usage, return wrapped objects
-    if (NULL != pPhysicalDevices) {
-        if (inst->phys_dev_count_tramp > *pPhysicalDeviceCount) {
-            loader_log(inst, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, 0,
-                       "vkEnumeratePhysicalDevices: Trimming device count down"
-                       " by application request from %d to %d physical devices",
-                       inst->phys_dev_count_tramp, *pPhysicalDeviceCount);
-            count = *pPhysicalDeviceCount;
-            res = VK_INCOMPLETE;
-        }
-        for (i = 0; i < count; i++) {
-            pPhysicalDevices[i] = (VkPhysicalDevice)inst->phys_devs_tramp[i];
-        }
-    }
-
-    *pPhysicalDeviceCount = count;
-
-out:
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
-                                                                     VkPhysicalDeviceFeatures *pFeatures) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
-                                                                             VkFormatProperties *pFormatInfo) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_pd = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage,
-    VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDeviceImageFormatProperties(unwrapped_phys_dev, format, type, tiling, usage, flags,
-                                                        pImageFormatProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
-                                                                       VkPhysicalDeviceProperties *pProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
-                                                                                  uint32_t *pQueueFamilyPropertyCount,
-                                                                                  VkQueueFamilyProperties *pQueueProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceQueueFamilyProperties(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
-                                                                             VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev, pMemoryProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
-                                                            const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
-    VkResult res;
-    struct loader_physical_device_tramp *phys_dev = NULL;
-    struct loader_device *dev = NULL;
-    struct loader_instance *inst = NULL;
-
-    assert(pCreateInfo->queueCreateInfoCount >= 1);
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
-    inst = (struct loader_instance *)phys_dev->this_instance;
-
-    // Get the physical device (ICD) extensions
-    struct loader_extension_list icd_exts;
-    icd_exts.list = NULL;
-    res = loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts, sizeof(VkExtensionProperties));
-    if (VK_SUCCESS != res) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create ICD extension list");
-        goto out;
-    }
-
-    res = loader_add_device_extensions(inst, inst->disp->layer_inst_disp.EnumerateDeviceExtensionProperties, phys_dev->phys_dev,
-                                       "Unknown", &icd_exts);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to add extensions to list");
-        goto out;
-    }
-
-    // Make sure requested extensions to be enabled are supported
-    res = loader_validate_device_extensions(phys_dev, &inst->expanded_activated_layer_list, &icd_exts, pCreateInfo);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to validate extensions in list");
-        goto out;
-    }
-
-    dev = loader_create_logical_device(inst, pAllocator);
-    if (dev == NULL) {
-        res = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    // Copy the application enabled instance layer list into the device
-    if (NULL != inst->app_activated_layer_list.list) {
-        dev->app_activated_layer_list.capacity = inst->app_activated_layer_list.capacity;
-        dev->app_activated_layer_list.count = inst->app_activated_layer_list.count;
-        dev->app_activated_layer_list.list =
-            loader_device_heap_alloc(dev, inst->app_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
-        if (dev->app_activated_layer_list.list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "vkCreateDevice:  Failed to allocate application activated layer list of size %d.",
-                       inst->app_activated_layer_list.capacity);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        memcpy(dev->app_activated_layer_list.list, inst->app_activated_layer_list.list,
-               sizeof(*dev->app_activated_layer_list.list) * dev->app_activated_layer_list.count);
-    } else {
-        dev->app_activated_layer_list.capacity = 0;
-        dev->app_activated_layer_list.count = 0;
-        dev->app_activated_layer_list.list = NULL;
-    }
-
-    // Copy the expanded enabled instance layer list into the device
-    if (NULL != inst->expanded_activated_layer_list.list) {
-        dev->expanded_activated_layer_list.capacity = inst->expanded_activated_layer_list.capacity;
-        dev->expanded_activated_layer_list.count = inst->expanded_activated_layer_list.count;
-        dev->expanded_activated_layer_list.list =
-            loader_device_heap_alloc(dev, inst->expanded_activated_layer_list.capacity, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
-        if (dev->expanded_activated_layer_list.list == NULL) {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "vkCreateDevice:  Failed to allocate expanded activated layer list of size %d.",
-                       inst->expanded_activated_layer_list.capacity);
-            res = VK_ERROR_OUT_OF_HOST_MEMORY;
-            goto out;
-        }
-        memcpy(dev->expanded_activated_layer_list.list, inst->expanded_activated_layer_list.list,
-               sizeof(*dev->expanded_activated_layer_list.list) * dev->expanded_activated_layer_list.count);
-    } else {
-        dev->expanded_activated_layer_list.capacity = 0;
-        dev->expanded_activated_layer_list.count = 0;
-        dev->expanded_activated_layer_list.list = NULL;
-    }
-
-    res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, dev);
-    if (res != VK_SUCCESS) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "vkCreateDevice:  Failed to create device chain.");
-        goto out;
-    }
-
-    *pDevice = dev->chain_device;
-
-    // Initialize any device extension dispatch entry's from the instance list
-    loader_init_dispatch_dev_ext(inst, dev);
-
-    // Initialize WSI device extensions as part of core dispatch since loader
-    // has dedicated trampoline code for these*/
-    loader_init_device_extension_dispatch_table(&dev->loader_dispatch, dev->loader_dispatch.core_dispatch.GetDeviceProcAddr,
-                                                *pDevice);
-
-out:
-
-    // Failure cleanup
-    if (VK_SUCCESS != res) {
-        if (NULL != dev) {
-            loader_destroy_logical_device(inst, dev, pAllocator);
-        }
-    }
-
-    if (NULL != icd_exts.list) {
-        loader_destroy_generic_list(inst, (struct loader_generic_list *)&icd_exts);
-    }
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-    struct loader_device *dev;
-
-    if (device == VK_NULL_HANDLE) {
-        return;
-    }
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, NULL);
-    const struct loader_instance *inst = icd_term->this_instance;
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyDevice(device, pAllocator);
-    dev->chain_device = NULL;
-    dev->icd_device = NULL;
-    loader_remove_logical_device(inst, icd_term, dev, pAllocator);
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                                                  const char *pLayerName, uint32_t *pPropertyCount,
-                                                                                  VkExtensionProperties *pProperties) {
-    VkResult res = VK_SUCCESS;
-    struct loader_physical_device_tramp *phys_dev;
-    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
-
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    // If pLayerName == NULL, then querying ICD extensions, pass this call
-    // down the instance chain which will terminate in the ICD. This allows
-    // layers to filter the extensions coming back up the chain.
-    // If pLayerName != NULL then get layer extensions from manifest file.
-    if (pLayerName == NULL || strlen(pLayerName) == 0) {
-        const VkLayerInstanceDispatchTable *disp;
-
-        disp = loader_get_instance_layer_dispatch(physicalDevice);
-        res = disp->EnumerateDeviceExtensionProperties(phys_dev->phys_dev, NULL, pPropertyCount, pProperties);
-    } else {
-        uint32_t count;
-        uint32_t copy_size;
-        const struct loader_instance *inst = phys_dev->this_instance;
-        struct loader_device_extension_list *dev_ext_list = NULL;
-        struct loader_device_extension_list local_ext_list;
-        memset(&local_ext_list, 0, sizeof(local_ext_list));
-        if (vk_string_validate(MaxLoaderStringLength, pLayerName) == VK_STRING_ERROR_NONE) {
-            for (uint32_t i = 0; i < inst->instance_layer_list.count; i++) {
-                struct loader_layer_properties *props = &inst->instance_layer_list.list[i];
-                if (strcmp(props->info.layerName, pLayerName) == 0) {
-                    dev_ext_list = &props->device_extension_list;
-                }
-            }
-
-            count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
-            if (pProperties == NULL) {
-                *pPropertyCount = count;
-                loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
-                loader_platform_thread_unlock_mutex(&loader_lock);
-                return VK_SUCCESS;
-            }
-
-            copy_size = *pPropertyCount < count ? *pPropertyCount : count;
-            for (uint32_t i = 0; i < copy_size; i++) {
-                memcpy(&pProperties[i], &dev_ext_list->list[i].props, sizeof(VkExtensionProperties));
-            }
-            *pPropertyCount = copy_size;
-
-            loader_destroy_generic_list(inst, (struct loader_generic_list *)&local_ext_list);
-            if (copy_size < count) {
-                loader_platform_thread_unlock_mutex(&loader_lock);
-                return VK_INCOMPLETE;
-            }
-        } else {
-            loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                       "vkEnumerateDeviceExtensionProperties:  pLayerName "
-                       "is too long or is badly formed");
-            loader_platform_thread_unlock_mutex(&loader_lock);
-            return VK_ERROR_EXTENSION_NOT_PRESENT;
-        }
-    }
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
-                                                                              uint32_t *pPropertyCount,
-                                                                              VkLayerProperties *pProperties) {
-    uint32_t copy_size;
-    struct loader_physical_device_tramp *phys_dev;
-    struct loader_layer_list *enabled_layers, layers_list;
-    memset(&layers_list, 0, sizeof(layers_list));
-    loader_platform_thread_lock_mutex(&loader_lock);
-
-    // Don't dispatch this call down the instance chain, want all device layers
-    // enumerated and instance chain may not contain all device layers
-    // TODO re-evaluate the above statement we maybe able to start calling
-    // down the chain
-
-    phys_dev = (struct loader_physical_device_tramp *)physicalDevice;
-    const struct loader_instance *inst = phys_dev->this_instance;
-
-    uint32_t count = inst->app_activated_layer_list.count;
-    if (count == 0 || pProperties == NULL) {
-        *pPropertyCount = count;
-        loader_platform_thread_unlock_mutex(&loader_lock);
-        return VK_SUCCESS;
-    }
-    enabled_layers = (struct loader_layer_list *)&inst->app_activated_layer_list;
-
-    copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
-    for (uint32_t i = 0; i < copy_size; i++) {
-        memcpy(&pProperties[i], &(enabled_layers->list[i].info), sizeof(VkLayerProperties));
-    }
-    *pPropertyCount = copy_size;
-
-    if (copy_size < count) {
-        loader_platform_thread_unlock_mutex(&loader_lock);
-        return VK_INCOMPLETE;
-    }
-
-    loader_platform_thread_unlock_mutex(&loader_lock);
-    return VK_SUCCESS;
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
-                                                          VkQueue *pQueue) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
-    loader_set_dispatch(*pQueue, disp);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
-                                                           VkFence fence) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(queue);
-
-    return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(queue);
-
-    return disp->QueueWaitIdle(queue);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->DeviceWaitIdle(device);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem,
-                                                      const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->FreeMemory(device, mem, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
-                                                         VkDeviceSize size, VkFlags flags, void **ppData) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->MapMemory(device, mem, offset, size, flags, ppData);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->UnmapMemory(device, mem);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                                                                       const VkMappedMemoryRange *pMemoryRanges) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                                                                            const VkMappedMemoryRange *pMemoryRanges) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
-                                                                     VkDeviceSize *pCommittedMemoryInBytes) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
-                                                                VkDeviceSize offset) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->BindBufferMemory(device, buffer, mem, offset);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
-                                                               VkDeviceSize offset) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->BindImageMemory(device, image, mem, offset);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
-                                                                       VkMemoryRequirements *pMemoryRequirements) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image,
-                                                                      VkMemoryRequirements *pMemoryRequirements) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
-vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
-                                   VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage,
-    VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-
-    disp->GetPhysicalDeviceSparseImageFormatProperties(unwrapped_phys_dev, format, type, samples, usage, tiling, pPropertyCount,
-                                                       pProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
-                                                               const VkBindSparseInfo *pBindInfo, VkFence fence) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(queue);
-
-    return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
-                                                           const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyFence(device, fence, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->ResetFences(device, fenceCount, pFences);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->GetFenceStatus(device, fence);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
-                                                             VkBool32 waitAll, uint64_t timeout) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
-                                                            const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroySemaphore(device, semaphore, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
-                                                           const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyEvent(device, event, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->GetEventStatus(device, event);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->SetEvent(device, event);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->ResetEvent(device, event);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
-                                                            const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyQueryPool(device, queryPool, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
-                                                                   uint32_t queryCount, size_t dataSize, void *pData,
-                                                                   VkDeviceSize stride, VkQueryResultFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
-                                                            const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer,
-                                                         const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyBuffer(device, buffer, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
-                                                                const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
-                                                             const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyBufferView(device, bufferView, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
-                                                           const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyImage(device, image, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image,
-                                                                     const VkImageSubresource *pSubresource,
-                                                                     VkSubresourceLayout *pLayout) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView,
-                                                            const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyImageView(device, imageView, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
-                                                                  const VkAllocationCallbacks *pAllocator,
-                                                                  VkShaderModule *pShader) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
-                                                               const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyShaderModule(device, shaderModule, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
-                                                                   const VkAllocationCallbacks *pAllocator,
-                                                                   VkPipelineCache *pPipelineCache) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
-                                                                const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
-                                                                    size_t *pDataSize, void *pData) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
-                                                                   uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
-                                                                       uint32_t createInfoCount,
-                                                                       const VkGraphicsPipelineCreateInfo *pCreateInfos,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkPipeline *pPipelines) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
-                                                                      uint32_t createInfoCount,
-                                                                      const VkComputePipelineCreateInfo *pCreateInfos,
-                                                                      const VkAllocationCallbacks *pAllocator,
-                                                                      VkPipeline *pPipelines) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
-                                                           const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyPipeline(device, pipeline, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkPipelineLayout *pPipelineLayout) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
-                                                                 const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
-                                                             const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler,
-                                                          const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroySampler(device, sampler, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device,
-                                                                         const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
-                                                                         const VkAllocationCallbacks *pAllocator,
-                                                                         VkDescriptorSetLayout *pSetLayout) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
-                                                                      const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkDescriptorPool *pDescriptorPool) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                                                                 const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                                                                   VkDescriptorPoolResetFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->ResetDescriptorPool(device, descriptorPool, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device,
-                                                                      const VkDescriptorSetAllocateInfo *pAllocateInfo,
-                                                                      VkDescriptorSet *pDescriptorSets) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
-                                                                  uint32_t descriptorSetCount,
-                                                                  const VkDescriptorSet *pDescriptorSets) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
-                                                                const VkWriteDescriptorSet *pDescriptorWrites,
-                                                                uint32_t descriptorCopyCount,
-                                                                const VkCopyDescriptorSet *pDescriptorCopies) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
-                                                                 const VkAllocationCallbacks *pAllocator,
-                                                                 VkFramebuffer *pFramebuffer) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
-                                                              const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyFramebuffer(device, framebuffer, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
-                                                                const VkAllocationCallbacks *pAllocator,
-                                                                VkRenderPass *pRenderPass) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
-                                                             const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyRenderPass(device, renderPass, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
-                                                                    VkExtent2D *pGranularity) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
-                                                                 const VkAllocationCallbacks *pAllocator,
-                                                                 VkCommandPool *pCommandPool) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
-                                                              const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->DestroyCommandPool(device, commandPool, pAllocator);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
-                                                                VkCommandPoolResetFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->ResetCommandPool(device, commandPool, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device,
-                                                                      const VkCommandBufferAllocateInfo *pAllocateInfo,
-                                                                      VkCommandBuffer *pCommandBuffers) {
-    const VkLayerDispatchTable *disp;
-    VkResult res;
-
-    disp = loader_get_dispatch(device);
-
-    res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
-    if (res == VK_SUCCESS) {
-        for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
-            if (pCommandBuffers[i]) {
-                loader_init_dispatch(pCommandBuffers[i], disp);
-            }
-        }
-    }
-
-    return res;
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
-                                                              uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
-                                                                  const VkCommandBufferBeginInfo *pBeginInfo) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    return disp->EndCommandBuffer(commandBuffer);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    return disp->ResetCommandBuffer(commandBuffer, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
-                                                           VkPipeline pipeline) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
-                                                          uint32_t viewportCount, const VkViewport *pViewports) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
-                                                         uint32_t scissorCount, const VkRect2D *pScissors) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetLineWidth(commandBuffer, lineWidth);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
-                                                           float depthBiasClamp, float depthBiasSlopeFactor) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetBlendConstants(commandBuffer, blendConstants);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
-                                                             float maxDepthBounds) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
-                                                                    uint32_t compareMask) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
-                                                                  uint32_t writeMask) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
-                                                                  uint32_t reference) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer,
-                                                                 VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
-                                                                 uint32_t firstSet, uint32_t descriptorSetCount,
-                                                                 const VkDescriptorSet *pDescriptorSets,
-                                                                 uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets,
-                                dynamicOffsetCount, pDynamicOffsets);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                              VkIndexType indexType) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                                                                uint32_t bindingCount, const VkBuffer *pBuffers,
-                                                                const VkDeviceSize *pOffsets) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
-                                                   uint32_t firstVertex, uint32_t firstInstance) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
-                                                          uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
-                                                          uint32_t firstInstance) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                           uint32_t drawCount, uint32_t stride) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                                                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDispatch(commandBuffer, x, y, z);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                                               VkDeviceSize offset) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
-                                                         uint32_t regionCount, const VkBufferCopy *pRegions) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                                        VkImageLayout srcImageLayout, VkImage dstImage,
-                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
-                                                        const VkImageCopy *pRegions) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                                        VkImageLayout srcImageLayout, VkImage dstImage,
-                                                        VkImageLayout dstImageLayout, uint32_t regionCount,
-                                                        const VkImageBlit *pRegions, VkFilter filter) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
-                                                                VkImageLayout dstImageLayout, uint32_t regionCount,
-                                                                const VkBufferImageCopy *pRegions) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                                                VkImageLayout srcImageLayout, VkBuffer dstBuffer,
-                                                                uint32_t regionCount, const VkBufferImageCopy *pRegions) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                                                           VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                                                         VkDeviceSize size, uint32_t data) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
-                                                              VkImageLayout imageLayout, const VkClearColorValue *pColor,
-                                                              uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
-                                                                     VkImageLayout imageLayout,
-                                                                     const VkClearDepthStencilValue *pDepthStencil,
-                                                                     uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
-                                                               const VkClearAttachment *pAttachments, uint32_t rectCount,
-                                                               const VkClearRect *pRects) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                                           VkImageLayout srcImageLayout, VkImage dstImage,
-                                                           VkImageLayout dstImageLayout, uint32_t regionCount,
-                                                           const VkImageResolve *pRegions) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                                                       VkPipelineStageFlags stageMask) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdSetEvent(commandBuffer, event, stageMask);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                                                         VkPipelineStageFlags stageMask) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdResetEvent(commandBuffer, event, stageMask);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents,
-                                                         VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask,
-                                                         uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
-                                                         uint32_t bufferMemoryBarrierCount,
-                                                         const VkBufferMemoryBarrier *pBufferMemoryBarriers,
-                                                         uint32_t imageMemoryBarrierCount,
-                                                         const VkImageMemoryBarrier *pImageMemoryBarriers) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
-                        bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 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 VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
-                             bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot,
-                                                         VkFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdEndQuery(commandBuffer, queryPool, slot);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                                             uint32_t firstQuery, uint32_t queryCount) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
-                                                             VkQueryPool queryPool, uint32_t slot) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                                                   uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
-                                                                   VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
-                                                            VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
-                                                            const void *pValues) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
-                                                              const VkRenderPassBeginInfo *pRenderPassBegin,
-                                                              VkSubpassContents contents) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdNextSubpass(commandBuffer, contents);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdEndRenderPass(commandBuffer);
-}
-
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
-                                                              const VkCommandBuffer *pCommandBuffers) {
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(commandBuffer);
-
-    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
-}
diff --git a/third_party/vulkan/loader/unknown_ext_chain.c b/third_party/vulkan/loader/unknown_ext_chain.c
deleted file mode 100644
index 1c8560dd6..000000000
--- a/third_party/vulkan/loader/unknown_ext_chain.c
+++ /dev/null
@@ -1,819 +0,0 @@
-/*
- * Copyright (c) 2017 The Khronos Group Inc.
- * Copyright (c) 2017 Valve Corporation
- * Copyright (c) 2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author Jon Ashburn <jon@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- */
-
- // This code is used to pass on physical device extensions through the call chain. It must do this without creating a stack frame,
- // because the actual parameters of the call are not known. Since the first parameter is known to be a VkPhysicalDevice, it can
-// unwrap the physical device, overwriting the wrapped device, and then jump to the next function in the call chain. This code
-// attempts to accomplish this by relying on tail-call optimizations, but there is no guarantee that this will work. As a result,
-// this code is only compiled on systems where an assembly alternative has not been written.
-
- #include "vk_loader_platform.h"
- #include "loader.h"
-
- #if defined(__GNUC__) && !defined(__clang__)
- #pragma GCC optimize(3)  // force gcc to use tail-calls
- #endif
-
- // Trampoline function macro for unknown physical device extension command.
- #define PhysDevExtTramp(num)                                                              \
-     VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTramp##num(VkPhysicalDevice physical_device) { \
-         const struct loader_instance_dispatch_table *disp;                                \
-         disp = loader_get_instance_dispatch(physical_device);                             \
-         disp->phys_dev_ext[num](loader_unwrap_physical_device(physical_device));          \
-     }
-
-// Terminator function macro for unknown physical device extension command.
-#define PhysDevExtTermin(num)                                                                                         \
-    VKAPI_ATTR void VKAPI_CALL vkPhysDevExtTermin##num(VkPhysicalDevice physical_device) {                            \
-         struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physical_device;    \
-         struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;                                              \
-         struct loader_instance *inst = (struct loader_instance *)icd_term->this_instance;                             \
-         if (NULL == icd_term->phys_dev_ext[num]) {                                                                    \
-             loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, "Extension %s not supported for this physical device", \
-                        inst->phys_dev_ext_disp_hash[num].func_name);                                                  \
-         }                                                                                                             \
-         icd_term->phys_dev_ext[num](phys_dev_term->phys_dev);                                                         \
-    }
-
-// Trampoline function macro for unknown physical device extension command.
-#define DevExtTramp(num)                                                          \
-   VKAPI_ATTR void VKAPI_CALL vkdev_ext##num(VkDevice device) {                   \
-           const struct loader_dev_dispatch_table *disp;                          \
-           disp = loader_get_dev_dispatch(device);                                \
-           disp->ext_dispatch.dev_ext[num](device);                               \
-       }
-
-
-// Instantiations of the trampoline
-PhysDevExtTramp(0)
-PhysDevExtTramp(1)
-PhysDevExtTramp(2)
-PhysDevExtTramp(3)
-PhysDevExtTramp(4)
-PhysDevExtTramp(5)
-PhysDevExtTramp(6)
-PhysDevExtTramp(7)
-PhysDevExtTramp(8)
-PhysDevExtTramp(9)
-PhysDevExtTramp(10)
-PhysDevExtTramp(11)
-PhysDevExtTramp(12)
-PhysDevExtTramp(13)
-PhysDevExtTramp(14)
-PhysDevExtTramp(15)
-PhysDevExtTramp(16)
-PhysDevExtTramp(17)
-PhysDevExtTramp(18)
-PhysDevExtTramp(19)
-PhysDevExtTramp(20)
-PhysDevExtTramp(21)
-PhysDevExtTramp(22)
-PhysDevExtTramp(23)
-PhysDevExtTramp(24)
-PhysDevExtTramp(25)
-PhysDevExtTramp(26)
-PhysDevExtTramp(27)
-PhysDevExtTramp(28)
-PhysDevExtTramp(29)
-PhysDevExtTramp(30)
-PhysDevExtTramp(31)
-PhysDevExtTramp(32)
-PhysDevExtTramp(33)
-PhysDevExtTramp(34)
-PhysDevExtTramp(35)
-PhysDevExtTramp(36)
-PhysDevExtTramp(37)
-PhysDevExtTramp(38)
-PhysDevExtTramp(39)
-PhysDevExtTramp(40)
-PhysDevExtTramp(41)
-PhysDevExtTramp(42)
-PhysDevExtTramp(43)
-PhysDevExtTramp(44)
-PhysDevExtTramp(45)
-PhysDevExtTramp(46)
-PhysDevExtTramp(47)
-PhysDevExtTramp(48)
-PhysDevExtTramp(49)
-PhysDevExtTramp(50)
-PhysDevExtTramp(51)
-PhysDevExtTramp(52)
-PhysDevExtTramp(53)
-PhysDevExtTramp(54)
-PhysDevExtTramp(55)
-PhysDevExtTramp(56)
-PhysDevExtTramp(57)
-PhysDevExtTramp(58)
-PhysDevExtTramp(59)
-PhysDevExtTramp(60)
-PhysDevExtTramp(61)
-PhysDevExtTramp(62)
-PhysDevExtTramp(63)
-PhysDevExtTramp(64)
-PhysDevExtTramp(65)
-PhysDevExtTramp(66)
-PhysDevExtTramp(67)
-PhysDevExtTramp(68)
-PhysDevExtTramp(69)
-PhysDevExtTramp(70)
-PhysDevExtTramp(71)
-PhysDevExtTramp(72)
-PhysDevExtTramp(73)
-PhysDevExtTramp(74)
-PhysDevExtTramp(75)
-PhysDevExtTramp(76)
-PhysDevExtTramp(77)
-PhysDevExtTramp(78)
-PhysDevExtTramp(79)
-PhysDevExtTramp(80)
-PhysDevExtTramp(81)
-PhysDevExtTramp(82)
-PhysDevExtTramp(83)
-PhysDevExtTramp(84)
-PhysDevExtTramp(85)
-PhysDevExtTramp(86)
-PhysDevExtTramp(87)
-PhysDevExtTramp(88)
-PhysDevExtTramp(89)
-PhysDevExtTramp(90)
-PhysDevExtTramp(91)
-PhysDevExtTramp(92)
-PhysDevExtTramp(93)
-PhysDevExtTramp(94)
-PhysDevExtTramp(95)
-PhysDevExtTramp(96)
-PhysDevExtTramp(97)
-PhysDevExtTramp(98)
-PhysDevExtTramp(99)
-PhysDevExtTramp(100)
-PhysDevExtTramp(101)
-PhysDevExtTramp(102)
-PhysDevExtTramp(103)
-PhysDevExtTramp(104)
-PhysDevExtTramp(105)
-PhysDevExtTramp(106)
-PhysDevExtTramp(107)
-PhysDevExtTramp(108)
-PhysDevExtTramp(109)
-PhysDevExtTramp(110)
-PhysDevExtTramp(111)
-PhysDevExtTramp(112)
-PhysDevExtTramp(113)
-PhysDevExtTramp(114)
-PhysDevExtTramp(115)
-PhysDevExtTramp(116)
-PhysDevExtTramp(117)
-PhysDevExtTramp(118)
-PhysDevExtTramp(119)
-PhysDevExtTramp(120)
-PhysDevExtTramp(121)
-PhysDevExtTramp(122)
-PhysDevExtTramp(123)
-PhysDevExtTramp(124)
-PhysDevExtTramp(125)
-PhysDevExtTramp(126)
-PhysDevExtTramp(127)
-PhysDevExtTramp(128)
-PhysDevExtTramp(129)
-PhysDevExtTramp(130)
-PhysDevExtTramp(131)
-PhysDevExtTramp(132)
-PhysDevExtTramp(133)
-PhysDevExtTramp(134)
-PhysDevExtTramp(135)
-PhysDevExtTramp(136)
-PhysDevExtTramp(137)
-PhysDevExtTramp(138)
-PhysDevExtTramp(139)
-PhysDevExtTramp(140)
-PhysDevExtTramp(141)
-PhysDevExtTramp(142)
-PhysDevExtTramp(143)
-PhysDevExtTramp(144)
-PhysDevExtTramp(145)
-PhysDevExtTramp(146)
-PhysDevExtTramp(147)
-PhysDevExtTramp(148)
-PhysDevExtTramp(149)
-PhysDevExtTramp(150)
-PhysDevExtTramp(151)
-PhysDevExtTramp(152)
-PhysDevExtTramp(153)
-PhysDevExtTramp(154)
-PhysDevExtTramp(155)
-PhysDevExtTramp(156)
-PhysDevExtTramp(157)
-PhysDevExtTramp(158)
-PhysDevExtTramp(159)
-PhysDevExtTramp(160)
-PhysDevExtTramp(161)
-PhysDevExtTramp(162)
-PhysDevExtTramp(163)
-PhysDevExtTramp(164)
-PhysDevExtTramp(165)
-PhysDevExtTramp(166)
-PhysDevExtTramp(167)
-PhysDevExtTramp(168)
-PhysDevExtTramp(169)
-PhysDevExtTramp(170)
-PhysDevExtTramp(171)
-PhysDevExtTramp(172)
-PhysDevExtTramp(173)
-PhysDevExtTramp(174)
-PhysDevExtTramp(175)
-PhysDevExtTramp(176)
-PhysDevExtTramp(177)
-PhysDevExtTramp(178)
-PhysDevExtTramp(179)
-PhysDevExtTramp(180)
-PhysDevExtTramp(181)
-PhysDevExtTramp(182)
-PhysDevExtTramp(183)
-PhysDevExtTramp(184)
-PhysDevExtTramp(185)
-PhysDevExtTramp(186)
-PhysDevExtTramp(187)
-PhysDevExtTramp(188)
-PhysDevExtTramp(189)
-PhysDevExtTramp(190)
-PhysDevExtTramp(191)
-PhysDevExtTramp(192)
-PhysDevExtTramp(193)
-PhysDevExtTramp(194)
-PhysDevExtTramp(195)
-PhysDevExtTramp(196)
-PhysDevExtTramp(197)
-PhysDevExtTramp(198)
-PhysDevExtTramp(199)
-PhysDevExtTramp(200)
-PhysDevExtTramp(201)
-PhysDevExtTramp(202)
-PhysDevExtTramp(203)
-PhysDevExtTramp(204)
-PhysDevExtTramp(205)
-PhysDevExtTramp(206)
-PhysDevExtTramp(207)
-PhysDevExtTramp(208)
-PhysDevExtTramp(209)
-PhysDevExtTramp(210)
-PhysDevExtTramp(211)
-PhysDevExtTramp(212)
-PhysDevExtTramp(213)
-PhysDevExtTramp(214)
-PhysDevExtTramp(215)
-PhysDevExtTramp(216)
-PhysDevExtTramp(217)
-PhysDevExtTramp(218)
-PhysDevExtTramp(219)
-PhysDevExtTramp(220)
-PhysDevExtTramp(221)
-PhysDevExtTramp(222)
-PhysDevExtTramp(223)
-PhysDevExtTramp(224)
-PhysDevExtTramp(225)
-PhysDevExtTramp(226)
-PhysDevExtTramp(227)
-PhysDevExtTramp(228)
-PhysDevExtTramp(229)
-PhysDevExtTramp(230)
-PhysDevExtTramp(231)
-PhysDevExtTramp(232)
-PhysDevExtTramp(233)
-PhysDevExtTramp(234)
-PhysDevExtTramp(235)
-PhysDevExtTramp(236)
-PhysDevExtTramp(237)
-PhysDevExtTramp(238)
-PhysDevExtTramp(239)
-PhysDevExtTramp(240)
-PhysDevExtTramp(241)
-PhysDevExtTramp(242)
-PhysDevExtTramp(243)
-PhysDevExtTramp(244)
-PhysDevExtTramp(245)
-PhysDevExtTramp(246)
-PhysDevExtTramp(247)
-PhysDevExtTramp(248)
-PhysDevExtTramp(249)
-
-// Instantiations of the terminator
-PhysDevExtTermin(0)
-PhysDevExtTermin(1)
-PhysDevExtTermin(2)
-PhysDevExtTermin(3)
-PhysDevExtTermin(4)
-PhysDevExtTermin(5)
-PhysDevExtTermin(6)
-PhysDevExtTermin(7)
-PhysDevExtTermin(8)
-PhysDevExtTermin(9)
-PhysDevExtTermin(10)
-PhysDevExtTermin(11)
-PhysDevExtTermin(12)
-PhysDevExtTermin(13)
-PhysDevExtTermin(14)
-PhysDevExtTermin(15)
-PhysDevExtTermin(16)
-PhysDevExtTermin(17)
-PhysDevExtTermin(18)
-PhysDevExtTermin(19)
-PhysDevExtTermin(20)
-PhysDevExtTermin(21)
-PhysDevExtTermin(22)
-PhysDevExtTermin(23)
-PhysDevExtTermin(24)
-PhysDevExtTermin(25)
-PhysDevExtTermin(26)
-PhysDevExtTermin(27)
-PhysDevExtTermin(28)
-PhysDevExtTermin(29)
-PhysDevExtTermin(30)
-PhysDevExtTermin(31)
-PhysDevExtTermin(32)
-PhysDevExtTermin(33)
-PhysDevExtTermin(34)
-PhysDevExtTermin(35)
-PhysDevExtTermin(36)
-PhysDevExtTermin(37)
-PhysDevExtTermin(38)
-PhysDevExtTermin(39)
-PhysDevExtTermin(40)
-PhysDevExtTermin(41)
-PhysDevExtTermin(42)
-PhysDevExtTermin(43)
-PhysDevExtTermin(44)
-PhysDevExtTermin(45)
-PhysDevExtTermin(46)
-PhysDevExtTermin(47)
-PhysDevExtTermin(48)
-PhysDevExtTermin(49)
-PhysDevExtTermin(50)
-PhysDevExtTermin(51)
-PhysDevExtTermin(52)
-PhysDevExtTermin(53)
-PhysDevExtTermin(54)
-PhysDevExtTermin(55)
-PhysDevExtTermin(56)
-PhysDevExtTermin(57)
-PhysDevExtTermin(58)
-PhysDevExtTermin(59)
-PhysDevExtTermin(60)
-PhysDevExtTermin(61)
-PhysDevExtTermin(62)
-PhysDevExtTermin(63)
-PhysDevExtTermin(64)
-PhysDevExtTermin(65)
-PhysDevExtTermin(66)
-PhysDevExtTermin(67)
-PhysDevExtTermin(68)
-PhysDevExtTermin(69)
-PhysDevExtTermin(70)
-PhysDevExtTermin(71)
-PhysDevExtTermin(72)
-PhysDevExtTermin(73)
-PhysDevExtTermin(74)
-PhysDevExtTermin(75)
-PhysDevExtTermin(76)
-PhysDevExtTermin(77)
-PhysDevExtTermin(78)
-PhysDevExtTermin(79)
-PhysDevExtTermin(80)
-PhysDevExtTermin(81)
-PhysDevExtTermin(82)
-PhysDevExtTermin(83)
-PhysDevExtTermin(84)
-PhysDevExtTermin(85)
-PhysDevExtTermin(86)
-PhysDevExtTermin(87)
-PhysDevExtTermin(88)
-PhysDevExtTermin(89)
-PhysDevExtTermin(90)
-PhysDevExtTermin(91)
-PhysDevExtTermin(92)
-PhysDevExtTermin(93)
-PhysDevExtTermin(94)
-PhysDevExtTermin(95)
-PhysDevExtTermin(96)
-PhysDevExtTermin(97)
-PhysDevExtTermin(98)
-PhysDevExtTermin(99)
-PhysDevExtTermin(100)
-PhysDevExtTermin(101)
-PhysDevExtTermin(102)
-PhysDevExtTermin(103)
-PhysDevExtTermin(104)
-PhysDevExtTermin(105)
-PhysDevExtTermin(106)
-PhysDevExtTermin(107)
-PhysDevExtTermin(108)
-PhysDevExtTermin(109)
-PhysDevExtTermin(110)
-PhysDevExtTermin(111)
-PhysDevExtTermin(112)
-PhysDevExtTermin(113)
-PhysDevExtTermin(114)
-PhysDevExtTermin(115)
-PhysDevExtTermin(116)
-PhysDevExtTermin(117)
-PhysDevExtTermin(118)
-PhysDevExtTermin(119)
-PhysDevExtTermin(120)
-PhysDevExtTermin(121)
-PhysDevExtTermin(122)
-PhysDevExtTermin(123)
-PhysDevExtTermin(124)
-PhysDevExtTermin(125)
-PhysDevExtTermin(126)
-PhysDevExtTermin(127)
-PhysDevExtTermin(128)
-PhysDevExtTermin(129)
-PhysDevExtTermin(130)
-PhysDevExtTermin(131)
-PhysDevExtTermin(132)
-PhysDevExtTermin(133)
-PhysDevExtTermin(134)
-PhysDevExtTermin(135)
-PhysDevExtTermin(136)
-PhysDevExtTermin(137)
-PhysDevExtTermin(138)
-PhysDevExtTermin(139)
-PhysDevExtTermin(140)
-PhysDevExtTermin(141)
-PhysDevExtTermin(142)
-PhysDevExtTermin(143)
-PhysDevExtTermin(144)
-PhysDevExtTermin(145)
-PhysDevExtTermin(146)
-PhysDevExtTermin(147)
-PhysDevExtTermin(148)
-PhysDevExtTermin(149)
-PhysDevExtTermin(150)
-PhysDevExtTermin(151)
-PhysDevExtTermin(152)
-PhysDevExtTermin(153)
-PhysDevExtTermin(154)
-PhysDevExtTermin(155)
-PhysDevExtTermin(156)
-PhysDevExtTermin(157)
-PhysDevExtTermin(158)
-PhysDevExtTermin(159)
-PhysDevExtTermin(160)
-PhysDevExtTermin(161)
-PhysDevExtTermin(162)
-PhysDevExtTermin(163)
-PhysDevExtTermin(164)
-PhysDevExtTermin(165)
-PhysDevExtTermin(166)
-PhysDevExtTermin(167)
-PhysDevExtTermin(168)
-PhysDevExtTermin(169)
-PhysDevExtTermin(170)
-PhysDevExtTermin(171)
-PhysDevExtTermin(172)
-PhysDevExtTermin(173)
-PhysDevExtTermin(174)
-PhysDevExtTermin(175)
-PhysDevExtTermin(176)
-PhysDevExtTermin(177)
-PhysDevExtTermin(178)
-PhysDevExtTermin(179)
-PhysDevExtTermin(180)
-PhysDevExtTermin(181)
-PhysDevExtTermin(182)
-PhysDevExtTermin(183)
-PhysDevExtTermin(184)
-PhysDevExtTermin(185)
-PhysDevExtTermin(186)
-PhysDevExtTermin(187)
-PhysDevExtTermin(188)
-PhysDevExtTermin(189)
-PhysDevExtTermin(190)
-PhysDevExtTermin(191)
-PhysDevExtTermin(192)
-PhysDevExtTermin(193)
-PhysDevExtTermin(194)
-PhysDevExtTermin(195)
-PhysDevExtTermin(196)
-PhysDevExtTermin(197)
-PhysDevExtTermin(198)
-PhysDevExtTermin(199)
-PhysDevExtTermin(200)
-PhysDevExtTermin(201)
-PhysDevExtTermin(202)
-PhysDevExtTermin(203)
-PhysDevExtTermin(204)
-PhysDevExtTermin(205)
-PhysDevExtTermin(206)
-PhysDevExtTermin(207)
-PhysDevExtTermin(208)
-PhysDevExtTermin(209)
-PhysDevExtTermin(210)
-PhysDevExtTermin(211)
-PhysDevExtTermin(212)
-PhysDevExtTermin(213)
-PhysDevExtTermin(214)
-PhysDevExtTermin(215)
-PhysDevExtTermin(216)
-PhysDevExtTermin(217)
-PhysDevExtTermin(218)
-PhysDevExtTermin(219)
-PhysDevExtTermin(220)
-PhysDevExtTermin(221)
-PhysDevExtTermin(222)
-PhysDevExtTermin(223)
-PhysDevExtTermin(224)
-PhysDevExtTermin(225)
-PhysDevExtTermin(226)
-PhysDevExtTermin(227)
-PhysDevExtTermin(228)
-PhysDevExtTermin(229)
-PhysDevExtTermin(230)
-PhysDevExtTermin(231)
-PhysDevExtTermin(232)
-PhysDevExtTermin(233)
-PhysDevExtTermin(234)
-PhysDevExtTermin(235)
-PhysDevExtTermin(236)
-PhysDevExtTermin(237)
-PhysDevExtTermin(238)
-PhysDevExtTermin(239)
-PhysDevExtTermin(240)
-PhysDevExtTermin(241)
-PhysDevExtTermin(242)
-PhysDevExtTermin(243)
-PhysDevExtTermin(244)
-PhysDevExtTermin(245)
-PhysDevExtTermin(246)
-PhysDevExtTermin(247)
-PhysDevExtTermin(248)
-PhysDevExtTermin(249)
-
-// Instantiations of the device trampoline
-DevExtTramp(0)
-DevExtTramp(1)
-DevExtTramp(2)
-DevExtTramp(3)
-DevExtTramp(4)
-DevExtTramp(5)
-DevExtTramp(6)
-DevExtTramp(7)
-DevExtTramp(8)
-DevExtTramp(9)
-DevExtTramp(10)
-DevExtTramp(11)
-DevExtTramp(12)
-DevExtTramp(13)
-DevExtTramp(14)
-DevExtTramp(15)
-DevExtTramp(16)
-DevExtTramp(17)
-DevExtTramp(18)
-DevExtTramp(19)
-DevExtTramp(20)
-DevExtTramp(21)
-DevExtTramp(22)
-DevExtTramp(23)
-DevExtTramp(24)
-DevExtTramp(25)
-DevExtTramp(26)
-DevExtTramp(27)
-DevExtTramp(28)
-DevExtTramp(29)
-DevExtTramp(30)
-DevExtTramp(31)
-DevExtTramp(32)
-DevExtTramp(33)
-DevExtTramp(34)
-DevExtTramp(35)
-DevExtTramp(36)
-DevExtTramp(37)
-DevExtTramp(38)
-DevExtTramp(39)
-DevExtTramp(40)
-DevExtTramp(41)
-DevExtTramp(42)
-DevExtTramp(43)
-DevExtTramp(44)
-DevExtTramp(45)
-DevExtTramp(46)
-DevExtTramp(47)
-DevExtTramp(48)
-DevExtTramp(49)
-DevExtTramp(50)
-DevExtTramp(51)
-DevExtTramp(52)
-DevExtTramp(53)
-DevExtTramp(54)
-DevExtTramp(55)
-DevExtTramp(56)
-DevExtTramp(57)
-DevExtTramp(58)
-DevExtTramp(59)
-DevExtTramp(60)
-DevExtTramp(61)
-DevExtTramp(62)
-DevExtTramp(63)
-DevExtTramp(64)
-DevExtTramp(65)
-DevExtTramp(66)
-DevExtTramp(67)
-DevExtTramp(68)
-DevExtTramp(69)
-DevExtTramp(70)
-DevExtTramp(71)
-DevExtTramp(72)
-DevExtTramp(73)
-DevExtTramp(74)
-DevExtTramp(75)
-DevExtTramp(76)
-DevExtTramp(77)
-DevExtTramp(78)
-DevExtTramp(79)
-DevExtTramp(80)
-DevExtTramp(81)
-DevExtTramp(82)
-DevExtTramp(83)
-DevExtTramp(84)
-DevExtTramp(85)
-DevExtTramp(86)
-DevExtTramp(87)
-DevExtTramp(88)
-DevExtTramp(89)
-DevExtTramp(90)
-DevExtTramp(91)
-DevExtTramp(92)
-DevExtTramp(93)
-DevExtTramp(94)
-DevExtTramp(95)
-DevExtTramp(96)
-DevExtTramp(97)
-DevExtTramp(98)
-DevExtTramp(99)
-DevExtTramp(100)
-DevExtTramp(101)
-DevExtTramp(102)
-DevExtTramp(103)
-DevExtTramp(104)
-DevExtTramp(105)
-DevExtTramp(106)
-DevExtTramp(107)
-DevExtTramp(108)
-DevExtTramp(109)
-DevExtTramp(110)
-DevExtTramp(111)
-DevExtTramp(112)
-DevExtTramp(113)
-DevExtTramp(114)
-DevExtTramp(115)
-DevExtTramp(116)
-DevExtTramp(117)
-DevExtTramp(118)
-DevExtTramp(119)
-DevExtTramp(120)
-DevExtTramp(121)
-DevExtTramp(122)
-DevExtTramp(123)
-DevExtTramp(124)
-DevExtTramp(125)
-DevExtTramp(126)
-DevExtTramp(127)
-DevExtTramp(128)
-DevExtTramp(129)
-DevExtTramp(130)
-DevExtTramp(131)
-DevExtTramp(132)
-DevExtTramp(133)
-DevExtTramp(134)
-DevExtTramp(135)
-DevExtTramp(136)
-DevExtTramp(137)
-DevExtTramp(138)
-DevExtTramp(139)
-DevExtTramp(140)
-DevExtTramp(141)
-DevExtTramp(142)
-DevExtTramp(143)
-DevExtTramp(144)
-DevExtTramp(145)
-DevExtTramp(146)
-DevExtTramp(147)
-DevExtTramp(148)
-DevExtTramp(149)
-DevExtTramp(150)
-DevExtTramp(151)
-DevExtTramp(152)
-DevExtTramp(153)
-DevExtTramp(154)
-DevExtTramp(155)
-DevExtTramp(156)
-DevExtTramp(157)
-DevExtTramp(158)
-DevExtTramp(159)
-DevExtTramp(160)
-DevExtTramp(161)
-DevExtTramp(162)
-DevExtTramp(163)
-DevExtTramp(164)
-DevExtTramp(165)
-DevExtTramp(166)
-DevExtTramp(167)
-DevExtTramp(168)
-DevExtTramp(169)
-DevExtTramp(170)
-DevExtTramp(171)
-DevExtTramp(172)
-DevExtTramp(173)
-DevExtTramp(174)
-DevExtTramp(175)
-DevExtTramp(176)
-DevExtTramp(177)
-DevExtTramp(178)
-DevExtTramp(179)
-DevExtTramp(180)
-DevExtTramp(181)
-DevExtTramp(182)
-DevExtTramp(183)
-DevExtTramp(184)
-DevExtTramp(185)
-DevExtTramp(186)
-DevExtTramp(187)
-DevExtTramp(188)
-DevExtTramp(189)
-DevExtTramp(190)
-DevExtTramp(191)
-DevExtTramp(192)
-DevExtTramp(193)
-DevExtTramp(194)
-DevExtTramp(195)
-DevExtTramp(196)
-DevExtTramp(197)
-DevExtTramp(198)
-DevExtTramp(199)
-DevExtTramp(200)
-DevExtTramp(201)
-DevExtTramp(202)
-DevExtTramp(203)
-DevExtTramp(204)
-DevExtTramp(205)
-DevExtTramp(206)
-DevExtTramp(207)
-DevExtTramp(208)
-DevExtTramp(209)
-DevExtTramp(210)
-DevExtTramp(211)
-DevExtTramp(212)
-DevExtTramp(213)
-DevExtTramp(214)
-DevExtTramp(215)
-DevExtTramp(216)
-DevExtTramp(217)
-DevExtTramp(218)
-DevExtTramp(219)
-DevExtTramp(220)
-DevExtTramp(221)
-DevExtTramp(222)
-DevExtTramp(223)
-DevExtTramp(224)
-DevExtTramp(225)
-DevExtTramp(226)
-DevExtTramp(227)
-DevExtTramp(228)
-DevExtTramp(229)
-DevExtTramp(230)
-DevExtTramp(231)
-DevExtTramp(232)
-DevExtTramp(233)
-DevExtTramp(234)
-DevExtTramp(235)
-DevExtTramp(236)
-DevExtTramp(237)
-DevExtTramp(238)
-DevExtTramp(239)
-DevExtTramp(240)
-DevExtTramp(241)
-DevExtTramp(242)
-DevExtTramp(243)
-DevExtTramp(244)
-DevExtTramp(245)
-DevExtTramp(246)
-DevExtTramp(247)
-DevExtTramp(248)
-DevExtTramp(249)
diff --git a/third_party/vulkan/loader/unknown_ext_chain_gas.asm b/third_party/vulkan/loader/unknown_ext_chain_gas.asm
deleted file mode 100644
index aca92ea5b..000000000
--- a/third_party/vulkan/loader/unknown_ext_chain_gas.asm
+++ /dev/null
@@ -1,873 +0,0 @@
-#
-# Copyright (c) 2017 The Khronos Group Inc.
-# Copyright (c) 2017 Valve Corporation
-# Copyright (c) 2017 LunarG, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# Author: Lenny Komow <lenny@lunarg.com>
-#
-
-# This code is used to pass on device (including physical device) extensions through the call chain. It must do this without
-# creating a stack frame, because the actual parameters of the call are not known. Since the first parameter is known to be a
-# VkPhysicalDevice or a dispatchable object it can unwrap the object, possibly overwriting the wrapped physical device, and then
-# jump to the next function in the call chain
-
-.intel_syntax noprefix
-.include "gen_defines.asm"
-
-.ifdef X86_64
-
-.macro PhysDevExtTramp num
-.global vkPhysDevExtTramp\num
-vkPhysDevExtTramp\num:
-    mov     rax, [rdi]
-    mov     rdi, [rdi + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP]
-    jmp     [rax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * \num))]
-.endm
-
-.macro PhysDevExtTermin num
-.global vkPhysDevExtTermin\num
-vkPhysDevExtTermin\num:
-    mov     rax, [rdi + ICD_TERM_OFFSET_PHYS_DEV_TERM]                          # Store the loader_icd_term* in rax
-    cmp     qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))], 0 # Check if the next function in the chain is NULL
-    je      terminError\num                                                     # Go to the error section if it is NULL
-    mov     rdi, [rdi + PHYS_DEV_OFFSET_PHYS_DEV_TERM]                          # Load the unwrapped VkPhysicalDevice into the first arg
-    jmp     [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))]              # Jump to the next function in the chain
-terminError\num:
-    sub     rsp, 56                                                             # Create the stack frame
-    mov     rdi, [rax + INSTANCE_OFFSET_ICD_TERM]                               # Load the loader_instance into rdi (first arg)
-    mov     r8, [rdi + (HASH_OFFSET_INSTANCE + (HASH_SIZE * \num) + FUNC_NAME_OFFSET_HASH)] # Load the func name into r8 (fifth arg)
-    lea     rcx, termin_error_string@GOTPCREL                                   # Load the error string into rcx (fourth arg)
-    xor     edx, edx                                                            # Set rdx to zero (third arg)
-    lea     esi, [rdx + VK_DEBUG_REPORT_ERROR_BIT_EXT]                          # Write the error logging bit to rsi (second arg)
-    call    loader_log                                                          # Log the error message before we crash
-    add     rsp, 56                                                             # Clean up the stack frame
-    mov     rax, 0
-    jmp     rax                                                                 # Crash intentionally by jumping to address zero
-.endm
-
-.macro DevExtTramp num
-.global vkdev_ext\num
-vkdev_ext\num:
-    mov     rax, [rdi]                                                          # Dereference the handle to get the dispatch table
-    jmp     [rax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * \num))]            # Jump to the appropriate call chain
-.endm
-
-.else
-
-.macro PhysDevExtTramp num
-.global vkPhysDevExtTramp\num
-vkPhysDevExtTramp\num:
-    mov     eax, [esp + 4]                              # Load the wrapped VkPhysicalDevice into eax
-    mov     ecx, [eax + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP] # Load the unwrapped VkPhysicalDevice into ecx
-    mov     [esp + 4], ecx                              # Overwrite the wrapped VkPhysicalDevice with the unwrapped one (on the stack)
-    mov     eax, [eax]                                  # Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax
-    jmp     [eax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * \num))] # Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax
-.endm
-
-.macro PhysDevExtTermin num
-.global vkPhysDevExtTermin\num
-vkPhysDevExtTermin\num:
-    mov     ecx, [esp + 4]                                                      # Move the wrapped VkPhysicalDevice into ecx
-    mov     eax, [ecx + ICD_TERM_OFFSET_PHYS_DEV_TERM]                          # Store the loader_icd_term* in eax
-    cmp     dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))], 0 # Check if the next function in the chain is NULL
-    je      terminError\num                                                     # Go to the error section if it is NULL
-    mov     ecx, [ecx + PHYS_DEV_OFFSET_PHYS_DEV_TERM]                          # Unwrap the VkPhysicalDevice in ecx
-    mov     [esp + 4], ecx                                                      # Copy the unwrapped VkPhysicalDevice into the first arg
-    jmp     [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * \num))]              # Jump to the next function in the chain
-terminError\num:
-    mov     eax, [eax + INSTANCE_OFFSET_ICD_TERM]                               # Load the loader_instance into eax
-    push    [eax + (HASH_OFFSET_INSTANCE + (HASH_SIZE * \num) + FUNC_NAME_OFFSET_HASH)] # Push the func name (fifth arg)
-    push    offset termin_error_string@GOT                                      # Push the error string (fourth arg)
-    push    0                                                                   # Push zero (third arg)
-    push    VK_DEBUG_REPORT_ERROR_BIT_EXT                                       # Push the error logging bit (second arg)
-    push    eax                                                                 # Push the loader_instance (first arg)
-    call    loader_log                                                          # Log the error message before we crash
-    add     esp, 20                                                             # Clean up the args
-    mov     eax, 0
-    jmp     eax                                                                 # Crash intentionally by jumping to address zero
-.endm
-
-.macro DevExtTramp num
-.global vkdev_ext\num
-vkdev_ext\num:
-    mov     eax, [esp + 4]                                                      # Dereference the handle to get the dispatch table
-    jmp     [eax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * \num))]            # Jump to the appropriate call chain
-.endm
-
-.endif
-
-#if defined(__ELF__)
-.section .note.GNU-stack,"",%progbits
-#endif
-
-.data
-
-termin_error_string:
-.string "Extension %s not supported for this physical device"
-
-.text
-
-    PhysDevExtTramp 0
-    PhysDevExtTramp 1
-    PhysDevExtTramp 2
-    PhysDevExtTramp 3
-    PhysDevExtTramp 4
-    PhysDevExtTramp 5
-    PhysDevExtTramp 6
-    PhysDevExtTramp 7
-    PhysDevExtTramp 8
-    PhysDevExtTramp 9
-    PhysDevExtTramp 10
-    PhysDevExtTramp 11
-    PhysDevExtTramp 12
-    PhysDevExtTramp 13
-    PhysDevExtTramp 14
-    PhysDevExtTramp 15
-    PhysDevExtTramp 16
-    PhysDevExtTramp 17
-    PhysDevExtTramp 18
-    PhysDevExtTramp 19
-    PhysDevExtTramp 20
-    PhysDevExtTramp 21
-    PhysDevExtTramp 22
-    PhysDevExtTramp 23
-    PhysDevExtTramp 24
-    PhysDevExtTramp 25
-    PhysDevExtTramp 26
-    PhysDevExtTramp 27
-    PhysDevExtTramp 28
-    PhysDevExtTramp 29
-    PhysDevExtTramp 30
-    PhysDevExtTramp 31
-    PhysDevExtTramp 32
-    PhysDevExtTramp 33
-    PhysDevExtTramp 34
-    PhysDevExtTramp 35
-    PhysDevExtTramp 36
-    PhysDevExtTramp 37
-    PhysDevExtTramp 38
-    PhysDevExtTramp 39
-    PhysDevExtTramp 40
-    PhysDevExtTramp 41
-    PhysDevExtTramp 42
-    PhysDevExtTramp 43
-    PhysDevExtTramp 44
-    PhysDevExtTramp 45
-    PhysDevExtTramp 46
-    PhysDevExtTramp 47
-    PhysDevExtTramp 48
-    PhysDevExtTramp 49
-    PhysDevExtTramp 50
-    PhysDevExtTramp 51
-    PhysDevExtTramp 52
-    PhysDevExtTramp 53
-    PhysDevExtTramp 54
-    PhysDevExtTramp 55
-    PhysDevExtTramp 56
-    PhysDevExtTramp 57
-    PhysDevExtTramp 58
-    PhysDevExtTramp 59
-    PhysDevExtTramp 60
-    PhysDevExtTramp 61
-    PhysDevExtTramp 62
-    PhysDevExtTramp 63
-    PhysDevExtTramp 64
-    PhysDevExtTramp 65
-    PhysDevExtTramp 66
-    PhysDevExtTramp 67
-    PhysDevExtTramp 68
-    PhysDevExtTramp 69
-    PhysDevExtTramp 70
-    PhysDevExtTramp 71
-    PhysDevExtTramp 72
-    PhysDevExtTramp 73
-    PhysDevExtTramp 74
-    PhysDevExtTramp 75
-    PhysDevExtTramp 76
-    PhysDevExtTramp 77
-    PhysDevExtTramp 78
-    PhysDevExtTramp 79
-    PhysDevExtTramp 80
-    PhysDevExtTramp 81
-    PhysDevExtTramp 82
-    PhysDevExtTramp 83
-    PhysDevExtTramp 84
-    PhysDevExtTramp 85
-    PhysDevExtTramp 86
-    PhysDevExtTramp 87
-    PhysDevExtTramp 88
-    PhysDevExtTramp 89
-    PhysDevExtTramp 90
-    PhysDevExtTramp 91
-    PhysDevExtTramp 92
-    PhysDevExtTramp 93
-    PhysDevExtTramp 94
-    PhysDevExtTramp 95
-    PhysDevExtTramp 96
-    PhysDevExtTramp 97
-    PhysDevExtTramp 98
-    PhysDevExtTramp 99
-    PhysDevExtTramp 100
-    PhysDevExtTramp 101
-    PhysDevExtTramp 102
-    PhysDevExtTramp 103
-    PhysDevExtTramp 104
-    PhysDevExtTramp 105
-    PhysDevExtTramp 106
-    PhysDevExtTramp 107
-    PhysDevExtTramp 108
-    PhysDevExtTramp 109
-    PhysDevExtTramp 110
-    PhysDevExtTramp 111
-    PhysDevExtTramp 112
-    PhysDevExtTramp 113
-    PhysDevExtTramp 114
-    PhysDevExtTramp 115
-    PhysDevExtTramp 116
-    PhysDevExtTramp 117
-    PhysDevExtTramp 118
-    PhysDevExtTramp 119
-    PhysDevExtTramp 120
-    PhysDevExtTramp 121
-    PhysDevExtTramp 122
-    PhysDevExtTramp 123
-    PhysDevExtTramp 124
-    PhysDevExtTramp 125
-    PhysDevExtTramp 126
-    PhysDevExtTramp 127
-    PhysDevExtTramp 128
-    PhysDevExtTramp 129
-    PhysDevExtTramp 130
-    PhysDevExtTramp 131
-    PhysDevExtTramp 132
-    PhysDevExtTramp 133
-    PhysDevExtTramp 134
-    PhysDevExtTramp 135
-    PhysDevExtTramp 136
-    PhysDevExtTramp 137
-    PhysDevExtTramp 138
-    PhysDevExtTramp 139
-    PhysDevExtTramp 140
-    PhysDevExtTramp 141
-    PhysDevExtTramp 142
-    PhysDevExtTramp 143
-    PhysDevExtTramp 144
-    PhysDevExtTramp 145
-    PhysDevExtTramp 146
-    PhysDevExtTramp 147
-    PhysDevExtTramp 148
-    PhysDevExtTramp 149
-    PhysDevExtTramp 150
-    PhysDevExtTramp 151
-    PhysDevExtTramp 152
-    PhysDevExtTramp 153
-    PhysDevExtTramp 154
-    PhysDevExtTramp 155
-    PhysDevExtTramp 156
-    PhysDevExtTramp 157
-    PhysDevExtTramp 158
-    PhysDevExtTramp 159
-    PhysDevExtTramp 160
-    PhysDevExtTramp 161
-    PhysDevExtTramp 162
-    PhysDevExtTramp 163
-    PhysDevExtTramp 164
-    PhysDevExtTramp 165
-    PhysDevExtTramp 166
-    PhysDevExtTramp 167
-    PhysDevExtTramp 168
-    PhysDevExtTramp 169
-    PhysDevExtTramp 170
-    PhysDevExtTramp 171
-    PhysDevExtTramp 172
-    PhysDevExtTramp 173
-    PhysDevExtTramp 174
-    PhysDevExtTramp 175
-    PhysDevExtTramp 176
-    PhysDevExtTramp 177
-    PhysDevExtTramp 178
-    PhysDevExtTramp 179
-    PhysDevExtTramp 180
-    PhysDevExtTramp 181
-    PhysDevExtTramp 182
-    PhysDevExtTramp 183
-    PhysDevExtTramp 184
-    PhysDevExtTramp 185
-    PhysDevExtTramp 186
-    PhysDevExtTramp 187
-    PhysDevExtTramp 188
-    PhysDevExtTramp 189
-    PhysDevExtTramp 190
-    PhysDevExtTramp 191
-    PhysDevExtTramp 192
-    PhysDevExtTramp 193
-    PhysDevExtTramp 194
-    PhysDevExtTramp 195
-    PhysDevExtTramp 196
-    PhysDevExtTramp 197
-    PhysDevExtTramp 198
-    PhysDevExtTramp 199
-    PhysDevExtTramp 200
-    PhysDevExtTramp 201
-    PhysDevExtTramp 202
-    PhysDevExtTramp 203
-    PhysDevExtTramp 204
-    PhysDevExtTramp 205
-    PhysDevExtTramp 206
-    PhysDevExtTramp 207
-    PhysDevExtTramp 208
-    PhysDevExtTramp 209
-    PhysDevExtTramp 210
-    PhysDevExtTramp 211
-    PhysDevExtTramp 212
-    PhysDevExtTramp 213
-    PhysDevExtTramp 214
-    PhysDevExtTramp 215
-    PhysDevExtTramp 216
-    PhysDevExtTramp 217
-    PhysDevExtTramp 218
-    PhysDevExtTramp 219
-    PhysDevExtTramp 220
-    PhysDevExtTramp 221
-    PhysDevExtTramp 222
-    PhysDevExtTramp 223
-    PhysDevExtTramp 224
-    PhysDevExtTramp 225
-    PhysDevExtTramp 226
-    PhysDevExtTramp 227
-    PhysDevExtTramp 228
-    PhysDevExtTramp 229
-    PhysDevExtTramp 230
-    PhysDevExtTramp 231
-    PhysDevExtTramp 232
-    PhysDevExtTramp 233
-    PhysDevExtTramp 234
-    PhysDevExtTramp 235
-    PhysDevExtTramp 236
-    PhysDevExtTramp 237
-    PhysDevExtTramp 238
-    PhysDevExtTramp 239
-    PhysDevExtTramp 240
-    PhysDevExtTramp 241
-    PhysDevExtTramp 242
-    PhysDevExtTramp 243
-    PhysDevExtTramp 244
-    PhysDevExtTramp 245
-    PhysDevExtTramp 246
-    PhysDevExtTramp 247
-    PhysDevExtTramp 248
-    PhysDevExtTramp 249
-
-    PhysDevExtTermin 0
-    PhysDevExtTermin 1
-    PhysDevExtTermin 2
-    PhysDevExtTermin 3
-    PhysDevExtTermin 4
-    PhysDevExtTermin 5
-    PhysDevExtTermin 6
-    PhysDevExtTermin 7
-    PhysDevExtTermin 8
-    PhysDevExtTermin 9
-    PhysDevExtTermin 10
-    PhysDevExtTermin 11
-    PhysDevExtTermin 12
-    PhysDevExtTermin 13
-    PhysDevExtTermin 14
-    PhysDevExtTermin 15
-    PhysDevExtTermin 16
-    PhysDevExtTermin 17
-    PhysDevExtTermin 18
-    PhysDevExtTermin 19
-    PhysDevExtTermin 20
-    PhysDevExtTermin 21
-    PhysDevExtTermin 22
-    PhysDevExtTermin 23
-    PhysDevExtTermin 24
-    PhysDevExtTermin 25
-    PhysDevExtTermin 26
-    PhysDevExtTermin 27
-    PhysDevExtTermin 28
-    PhysDevExtTermin 29
-    PhysDevExtTermin 30
-    PhysDevExtTermin 31
-    PhysDevExtTermin 32
-    PhysDevExtTermin 33
-    PhysDevExtTermin 34
-    PhysDevExtTermin 35
-    PhysDevExtTermin 36
-    PhysDevExtTermin 37
-    PhysDevExtTermin 38
-    PhysDevExtTermin 39
-    PhysDevExtTermin 40
-    PhysDevExtTermin 41
-    PhysDevExtTermin 42
-    PhysDevExtTermin 43
-    PhysDevExtTermin 44
-    PhysDevExtTermin 45
-    PhysDevExtTermin 46
-    PhysDevExtTermin 47
-    PhysDevExtTermin 48
-    PhysDevExtTermin 49
-    PhysDevExtTermin 50
-    PhysDevExtTermin 51
-    PhysDevExtTermin 52
-    PhysDevExtTermin 53
-    PhysDevExtTermin 54
-    PhysDevExtTermin 55
-    PhysDevExtTermin 56
-    PhysDevExtTermin 57
-    PhysDevExtTermin 58
-    PhysDevExtTermin 59
-    PhysDevExtTermin 60
-    PhysDevExtTermin 61
-    PhysDevExtTermin 62
-    PhysDevExtTermin 63
-    PhysDevExtTermin 64
-    PhysDevExtTermin 65
-    PhysDevExtTermin 66
-    PhysDevExtTermin 67
-    PhysDevExtTermin 68
-    PhysDevExtTermin 69
-    PhysDevExtTermin 70
-    PhysDevExtTermin 71
-    PhysDevExtTermin 72
-    PhysDevExtTermin 73
-    PhysDevExtTermin 74
-    PhysDevExtTermin 75
-    PhysDevExtTermin 76
-    PhysDevExtTermin 77
-    PhysDevExtTermin 78
-    PhysDevExtTermin 79
-    PhysDevExtTermin 80
-    PhysDevExtTermin 81
-    PhysDevExtTermin 82
-    PhysDevExtTermin 83
-    PhysDevExtTermin 84
-    PhysDevExtTermin 85
-    PhysDevExtTermin 86
-    PhysDevExtTermin 87
-    PhysDevExtTermin 88
-    PhysDevExtTermin 89
-    PhysDevExtTermin 90
-    PhysDevExtTermin 91
-    PhysDevExtTermin 92
-    PhysDevExtTermin 93
-    PhysDevExtTermin 94
-    PhysDevExtTermin 95
-    PhysDevExtTermin 96
-    PhysDevExtTermin 97
-    PhysDevExtTermin 98
-    PhysDevExtTermin 99
-    PhysDevExtTermin 100
-    PhysDevExtTermin 101
-    PhysDevExtTermin 102
-    PhysDevExtTermin 103
-    PhysDevExtTermin 104
-    PhysDevExtTermin 105
-    PhysDevExtTermin 106
-    PhysDevExtTermin 107
-    PhysDevExtTermin 108
-    PhysDevExtTermin 109
-    PhysDevExtTermin 110
-    PhysDevExtTermin 111
-    PhysDevExtTermin 112
-    PhysDevExtTermin 113
-    PhysDevExtTermin 114
-    PhysDevExtTermin 115
-    PhysDevExtTermin 116
-    PhysDevExtTermin 117
-    PhysDevExtTermin 118
-    PhysDevExtTermin 119
-    PhysDevExtTermin 120
-    PhysDevExtTermin 121
-    PhysDevExtTermin 122
-    PhysDevExtTermin 123
-    PhysDevExtTermin 124
-    PhysDevExtTermin 125
-    PhysDevExtTermin 126
-    PhysDevExtTermin 127
-    PhysDevExtTermin 128
-    PhysDevExtTermin 129
-    PhysDevExtTermin 130
-    PhysDevExtTermin 131
-    PhysDevExtTermin 132
-    PhysDevExtTermin 133
-    PhysDevExtTermin 134
-    PhysDevExtTermin 135
-    PhysDevExtTermin 136
-    PhysDevExtTermin 137
-    PhysDevExtTermin 138
-    PhysDevExtTermin 139
-    PhysDevExtTermin 140
-    PhysDevExtTermin 141
-    PhysDevExtTermin 142
-    PhysDevExtTermin 143
-    PhysDevExtTermin 144
-    PhysDevExtTermin 145
-    PhysDevExtTermin 146
-    PhysDevExtTermin 147
-    PhysDevExtTermin 148
-    PhysDevExtTermin 149
-    PhysDevExtTermin 150
-    PhysDevExtTermin 151
-    PhysDevExtTermin 152
-    PhysDevExtTermin 153
-    PhysDevExtTermin 154
-    PhysDevExtTermin 155
-    PhysDevExtTermin 156
-    PhysDevExtTermin 157
-    PhysDevExtTermin 158
-    PhysDevExtTermin 159
-    PhysDevExtTermin 160
-    PhysDevExtTermin 161
-    PhysDevExtTermin 162
-    PhysDevExtTermin 163
-    PhysDevExtTermin 164
-    PhysDevExtTermin 165
-    PhysDevExtTermin 166
-    PhysDevExtTermin 167
-    PhysDevExtTermin 168
-    PhysDevExtTermin 169
-    PhysDevExtTermin 170
-    PhysDevExtTermin 171
-    PhysDevExtTermin 172
-    PhysDevExtTermin 173
-    PhysDevExtTermin 174
-    PhysDevExtTermin 175
-    PhysDevExtTermin 176
-    PhysDevExtTermin 177
-    PhysDevExtTermin 178
-    PhysDevExtTermin 179
-    PhysDevExtTermin 180
-    PhysDevExtTermin 181
-    PhysDevExtTermin 182
-    PhysDevExtTermin 183
-    PhysDevExtTermin 184
-    PhysDevExtTermin 185
-    PhysDevExtTermin 186
-    PhysDevExtTermin 187
-    PhysDevExtTermin 188
-    PhysDevExtTermin 189
-    PhysDevExtTermin 190
-    PhysDevExtTermin 191
-    PhysDevExtTermin 192
-    PhysDevExtTermin 193
-    PhysDevExtTermin 194
-    PhysDevExtTermin 195
-    PhysDevExtTermin 196
-    PhysDevExtTermin 197
-    PhysDevExtTermin 198
-    PhysDevExtTermin 199
-    PhysDevExtTermin 200
-    PhysDevExtTermin 201
-    PhysDevExtTermin 202
-    PhysDevExtTermin 203
-    PhysDevExtTermin 204
-    PhysDevExtTermin 205
-    PhysDevExtTermin 206
-    PhysDevExtTermin 207
-    PhysDevExtTermin 208
-    PhysDevExtTermin 209
-    PhysDevExtTermin 210
-    PhysDevExtTermin 211
-    PhysDevExtTermin 212
-    PhysDevExtTermin 213
-    PhysDevExtTermin 214
-    PhysDevExtTermin 215
-    PhysDevExtTermin 216
-    PhysDevExtTermin 217
-    PhysDevExtTermin 218
-    PhysDevExtTermin 219
-    PhysDevExtTermin 220
-    PhysDevExtTermin 221
-    PhysDevExtTermin 222
-    PhysDevExtTermin 223
-    PhysDevExtTermin 224
-    PhysDevExtTermin 225
-    PhysDevExtTermin 226
-    PhysDevExtTermin 227
-    PhysDevExtTermin 228
-    PhysDevExtTermin 229
-    PhysDevExtTermin 230
-    PhysDevExtTermin 231
-    PhysDevExtTermin 232
-    PhysDevExtTermin 233
-    PhysDevExtTermin 234
-    PhysDevExtTermin 235
-    PhysDevExtTermin 236
-    PhysDevExtTermin 237
-    PhysDevExtTermin 238
-    PhysDevExtTermin 239
-    PhysDevExtTermin 240
-    PhysDevExtTermin 241
-    PhysDevExtTermin 242
-    PhysDevExtTermin 243
-    PhysDevExtTermin 244
-    PhysDevExtTermin 245
-    PhysDevExtTermin 246
-    PhysDevExtTermin 247
-    PhysDevExtTermin 248
-    PhysDevExtTermin 249
-
-    DevExtTramp 0
-    DevExtTramp 1
-    DevExtTramp 2
-    DevExtTramp 3
-    DevExtTramp 4
-    DevExtTramp 5
-    DevExtTramp 6
-    DevExtTramp 7
-    DevExtTramp 8
-    DevExtTramp 9
-    DevExtTramp 10
-    DevExtTramp 11
-    DevExtTramp 12
-    DevExtTramp 13
-    DevExtTramp 14
-    DevExtTramp 15
-    DevExtTramp 16
-    DevExtTramp 17
-    DevExtTramp 18
-    DevExtTramp 19
-    DevExtTramp 20
-    DevExtTramp 21
-    DevExtTramp 22
-    DevExtTramp 23
-    DevExtTramp 24
-    DevExtTramp 25
-    DevExtTramp 26
-    DevExtTramp 27
-    DevExtTramp 28
-    DevExtTramp 29
-    DevExtTramp 30
-    DevExtTramp 31
-    DevExtTramp 32
-    DevExtTramp 33
-    DevExtTramp 34
-    DevExtTramp 35
-    DevExtTramp 36
-    DevExtTramp 37
-    DevExtTramp 38
-    DevExtTramp 39
-    DevExtTramp 40
-    DevExtTramp 41
-    DevExtTramp 42
-    DevExtTramp 43
-    DevExtTramp 44
-    DevExtTramp 45
-    DevExtTramp 46
-    DevExtTramp 47
-    DevExtTramp 48
-    DevExtTramp 49
-    DevExtTramp 50
-    DevExtTramp 51
-    DevExtTramp 52
-    DevExtTramp 53
-    DevExtTramp 54
-    DevExtTramp 55
-    DevExtTramp 56
-    DevExtTramp 57
-    DevExtTramp 58
-    DevExtTramp 59
-    DevExtTramp 60
-    DevExtTramp 61
-    DevExtTramp 62
-    DevExtTramp 63
-    DevExtTramp 64
-    DevExtTramp 65
-    DevExtTramp 66
-    DevExtTramp 67
-    DevExtTramp 68
-    DevExtTramp 69
-    DevExtTramp 70
-    DevExtTramp 71
-    DevExtTramp 72
-    DevExtTramp 73
-    DevExtTramp 74
-    DevExtTramp 75
-    DevExtTramp 76
-    DevExtTramp 77
-    DevExtTramp 78
-    DevExtTramp 79
-    DevExtTramp 80
-    DevExtTramp 81
-    DevExtTramp 82
-    DevExtTramp 83
-    DevExtTramp 84
-    DevExtTramp 85
-    DevExtTramp 86
-    DevExtTramp 87
-    DevExtTramp 88
-    DevExtTramp 89
-    DevExtTramp 90
-    DevExtTramp 91
-    DevExtTramp 92
-    DevExtTramp 93
-    DevExtTramp 94
-    DevExtTramp 95
-    DevExtTramp 96
-    DevExtTramp 97
-    DevExtTramp 98
-    DevExtTramp 99
-    DevExtTramp 100
-    DevExtTramp 101
-    DevExtTramp 102
-    DevExtTramp 103
-    DevExtTramp 104
-    DevExtTramp 105
-    DevExtTramp 106
-    DevExtTramp 107
-    DevExtTramp 108
-    DevExtTramp 109
-    DevExtTramp 110
-    DevExtTramp 111
-    DevExtTramp 112
-    DevExtTramp 113
-    DevExtTramp 114
-    DevExtTramp 115
-    DevExtTramp 116
-    DevExtTramp 117
-    DevExtTramp 118
-    DevExtTramp 119
-    DevExtTramp 120
-    DevExtTramp 121
-    DevExtTramp 122
-    DevExtTramp 123
-    DevExtTramp 124
-    DevExtTramp 125
-    DevExtTramp 126
-    DevExtTramp 127
-    DevExtTramp 128
-    DevExtTramp 129
-    DevExtTramp 130
-    DevExtTramp 131
-    DevExtTramp 132
-    DevExtTramp 133
-    DevExtTramp 134
-    DevExtTramp 135
-    DevExtTramp 136
-    DevExtTramp 137
-    DevExtTramp 138
-    DevExtTramp 139
-    DevExtTramp 140
-    DevExtTramp 141
-    DevExtTramp 142
-    DevExtTramp 143
-    DevExtTramp 144
-    DevExtTramp 145
-    DevExtTramp 146
-    DevExtTramp 147
-    DevExtTramp 148
-    DevExtTramp 149
-    DevExtTramp 150
-    DevExtTramp 151
-    DevExtTramp 152
-    DevExtTramp 153
-    DevExtTramp 154
-    DevExtTramp 155
-    DevExtTramp 156
-    DevExtTramp 157
-    DevExtTramp 158
-    DevExtTramp 159
-    DevExtTramp 160
-    DevExtTramp 161
-    DevExtTramp 162
-    DevExtTramp 163
-    DevExtTramp 164
-    DevExtTramp 165
-    DevExtTramp 166
-    DevExtTramp 167
-    DevExtTramp 168
-    DevExtTramp 169
-    DevExtTramp 170
-    DevExtTramp 171
-    DevExtTramp 172
-    DevExtTramp 173
-    DevExtTramp 174
-    DevExtTramp 175
-    DevExtTramp 176
-    DevExtTramp 177
-    DevExtTramp 178
-    DevExtTramp 179
-    DevExtTramp 180
-    DevExtTramp 181
-    DevExtTramp 182
-    DevExtTramp 183
-    DevExtTramp 184
-    DevExtTramp 185
-    DevExtTramp 186
-    DevExtTramp 187
-    DevExtTramp 188
-    DevExtTramp 189
-    DevExtTramp 190
-    DevExtTramp 191
-    DevExtTramp 192
-    DevExtTramp 193
-    DevExtTramp 194
-    DevExtTramp 195
-    DevExtTramp 196
-    DevExtTramp 197
-    DevExtTramp 198
-    DevExtTramp 199
-    DevExtTramp 200
-    DevExtTramp 201
-    DevExtTramp 202
-    DevExtTramp 203
-    DevExtTramp 204
-    DevExtTramp 205
-    DevExtTramp 206
-    DevExtTramp 207
-    DevExtTramp 208
-    DevExtTramp 209
-    DevExtTramp 210
-    DevExtTramp 211
-    DevExtTramp 212
-    DevExtTramp 213
-    DevExtTramp 214
-    DevExtTramp 215
-    DevExtTramp 216
-    DevExtTramp 217
-    DevExtTramp 218
-    DevExtTramp 219
-    DevExtTramp 220
-    DevExtTramp 221
-    DevExtTramp 222
-    DevExtTramp 223
-    DevExtTramp 224
-    DevExtTramp 225
-    DevExtTramp 226
-    DevExtTramp 227
-    DevExtTramp 228
-    DevExtTramp 229
-    DevExtTramp 230
-    DevExtTramp 231
-    DevExtTramp 232
-    DevExtTramp 233
-    DevExtTramp 234
-    DevExtTramp 235
-    DevExtTramp 236
-    DevExtTramp 237
-    DevExtTramp 238
-    DevExtTramp 239
-    DevExtTramp 240
-    DevExtTramp 241
-    DevExtTramp 242
-    DevExtTramp 243
-    DevExtTramp 244
-    DevExtTramp 245
-    DevExtTramp 246
-    DevExtTramp 247
-    DevExtTramp 248
-    DevExtTramp 249
diff --git a/third_party/vulkan/loader/unknown_ext_chain_masm.asm b/third_party/vulkan/loader/unknown_ext_chain_masm.asm
deleted file mode 100644
index 34bc7c2fc..000000000
--- a/third_party/vulkan/loader/unknown_ext_chain_masm.asm
+++ /dev/null
@@ -1,883 +0,0 @@
-;
-; Copyright (c) 2017 The Khronos Group Inc.
-; Copyright (c) 2017 Valve Corporation
-; Copyright (c) 2017 LunarG, Inc.
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-;     http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS,
-; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-; See the License for the specific language governing permissions and
-; limitations under the License.
-;
-; Author: Lenny Komow <lenny@lunarg.com>
-;
-
-; This code is used to pass on device (including physical device) extensions through the call chain. It must do this without
-; creating a stack frame, because the actual parameters of the call are not known. Since the first parameter is known to be a
-; VkPhysicalDevice or a dispatchable object it can unwrap the object, possibly overwriting the wrapped physical device, and then
-; jump to the next function in the call chain
-
-; Codegen defines a number of values, chiefly offsets of members within structs and sizes of data types within gen_defines.asm.
-; Struct member offsets are defined in the format "XX_OFFSET_YY" where XX indicates the member within the struct and YY indicates
-; the struct type that it is a member of. Data type sizes are defined in the format "XX_SIZE" where XX indicates the data type.
-INCLUDE gen_defines.asm
-
-; 64-bit values and macro
-IFDEF rax
-
-PhysDevExtTramp macro num:req
-public vkPhysDevExtTramp&num&
-vkPhysDevExtTramp&num&:
-    mov     rax, qword ptr [rcx]                            ; Dereference the wrapped VkPhysicalDevice to get the dispatch table in rax
-    mov     rcx, qword ptr [rcx + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP]   ; Load the unwrapped VkPhysicalDevice into rcx
-    jmp     qword ptr [rax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * num))] ; Jump to the next function in the chain, preserving the args in other registers
-endm
-
-PhysDevExtTermin macro num
-public vkPhysDevExtTermin&num&
-vkPhysDevExtTermin&num&:
-    mov     rax, qword ptr [rcx + ICD_TERM_OFFSET_PHYS_DEV_TERM]                ; Store the loader_icd_term* in rax
-    cmp     qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))], 0  ; Check if the next function in the chain is NULL
-    je      terminError&num&                                                    ; Go to the error section if it is NULL
-    mov     rcx, qword ptr [rcx + PHYS_DEV_OFFSET_PHYS_DEV_TERM]                ; Load the unwrapped VkPhysicalDevice into the first arg
-    jmp     qword ptr [rax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))]     ; Jump to the next function in the chain
-terminError&num&:
-    sub     rsp, 56                                                             ; Create the stack frame
-    mov     rcx, qword ptr [rax + INSTANCE_OFFSET_ICD_TERM]                     ; Load the loader_instance into rcx (first arg)
-    mov     rax, qword ptr [rcx + (HASH_OFFSET_INSTANCE + (HASH_SIZE * num) + FUNC_NAME_OFFSET_HASH)] ; Load the func name into rax
-    lea     r9, termin_error_string                                             ; Load the error string into r9 (fourth arg)
-    xor     r8d, r8d                                                            ; Set r8 to zero (third arg)
-    mov     qword ptr [rsp + 32], rax                                           ; Move the func name onto the stack (fifth arg)
-    lea     edx, [r8 + VK_DEBUG_REPORT_ERROR_BIT_EXT]                           ; Write the error logging bit to rdx (second arg)
-    call    loader_log                                                          ; Log the error message before we crash
-    add     rsp, 56                                                             ; Clean up the stack frame
-    mov     rax, 0
-    jmp     rax                                                                 ; Crash intentionally by jumping to address zero
-endm
-
-DevExtTramp macro num
-public vkdev_ext&num&
-vkdev_ext&num&:
-    mov     rax, qword ptr [rcx]                                               ; Dereference the handle to get the dispatch table
-    jmp     qword ptr [rax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * num))]  ; Jump to the appropriate call chain
-endm
-
-; 32-bit values and macro
-ELSE
-
-PhysDevExtTramp macro num
-public _vkPhysDevExtTramp&num&@4
-_vkPhysDevExtTramp&num&@4:
-    mov     eax, dword ptr [esp + 4]                        ; Load the wrapped VkPhysicalDevice into eax
-    mov     ecx, [eax + PHYS_DEV_OFFSET_PHYS_DEV_TRAMP]     ; Load the unwrapped VkPhysicalDevice into ecx
-    mov     [esp + 4], ecx                                  ; Overwrite the wrapped VkPhysicalDevice with the unwrapped one (on the stack)
-    mov     eax, [eax]                                      ; Dereference the wrapped VkPhysicalDevice to get the dispatch table in eax
-    jmp     dword ptr [eax + (PHYS_DEV_OFFSET_INST_DISPATCH + (PTR_SIZE * num))] ; Jump to the next function in the chain, preserving the args on the stack
-endm
-
-PhysDevExtTermin macro num
-public _vkPhysDevExtTermin&num&@4
-_vkPhysDevExtTermin&num&@4:
-    mov     ecx, dword ptr [esp + 4]                                            ; Move the wrapped VkPhysicalDevice into ecx
-    mov     eax, dword ptr [ecx + ICD_TERM_OFFSET_PHYS_DEV_TERM]                ; Store the loader_icd_term* in eax
-    cmp     dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))], 0  ; Check if the next function in the chain is NULL
-    je      terminError&num&                                                    ; Go to the error section if it is NULL
-    mov     ecx, dword ptr [ecx + PHYS_DEV_OFFSET_PHYS_DEV_TERM]                ; Unwrap the VkPhysicalDevice in ecx
-    mov     dword ptr [esp + 4], ecx                                            ; Copy the unwrapped VkPhysicalDevice into the first arg
-    jmp     dword ptr [eax + (DISPATCH_OFFSET_ICD_TERM + (PTR_SIZE * num))]     ; Jump to the next function in the chain
-terminError&num&:
-    mov     eax, dword ptr [eax + INSTANCE_OFFSET_ICD_TERM]                     ; Load the loader_instance into eax
-    push    dword ptr [eax + (HASH_OFFSET_INSTANCE + (HASH_SIZE * num) + FUNC_NAME_OFFSET_HASH)] ; Push the func name (fifth arg)
-    push    offset termin_error_string                                          ; Push the error string (fourth arg)
-    push    0                                                                   ; Push zero (third arg)
-    push    VK_DEBUG_REPORT_ERROR_BIT_EXT                                       ; Push the error logging bit (second arg)
-    push    eax                                                                 ; Push the loader_instance (first arg)
-    call    _loader_log                                                         ; Log the error message before we crash
-    add     esp, 20                                                             ; Clean up the args
-    mov     eax, 0
-    jmp     eax                                                                 ; Crash intentionally by jumping to address zero
-endm
-
-DevExtTramp macro num
-public _vkdev_ext&num&@4
-_vkdev_ext&num&@4:
-    mov     eax, dword ptr [esp + 4]                                           ; Dereference the handle to get the dispatch table
-    jmp     dword ptr [eax + (EXT_OFFSET_DEVICE_DISPATCH + (PTR_SIZE * num))]  ; Jump to the appropriate call chain
-endm
-
-; This is also needed for 32-bit only
-.model flat
-
-ENDIF
-
-.const
-    termin_error_string db 'Extension %s not supported for this physical device', 0
-
-.code
-
-IFDEF rax
-extrn loader_log:near
-ELSE
-extrn _loader_log:near
-ENDIF
-
-    PhysDevExtTramp 0
-    PhysDevExtTramp 1
-    PhysDevExtTramp 2
-    PhysDevExtTramp 3
-    PhysDevExtTramp 4
-    PhysDevExtTramp 5
-    PhysDevExtTramp 6
-    PhysDevExtTramp 7
-    PhysDevExtTramp 8
-    PhysDevExtTramp 9
-    PhysDevExtTramp 10
-    PhysDevExtTramp 11
-    PhysDevExtTramp 12
-    PhysDevExtTramp 13
-    PhysDevExtTramp 14
-    PhysDevExtTramp 15
-    PhysDevExtTramp 16
-    PhysDevExtTramp 17
-    PhysDevExtTramp 18
-    PhysDevExtTramp 19
-    PhysDevExtTramp 20
-    PhysDevExtTramp 21
-    PhysDevExtTramp 22
-    PhysDevExtTramp 23
-    PhysDevExtTramp 24
-    PhysDevExtTramp 25
-    PhysDevExtTramp 26
-    PhysDevExtTramp 27
-    PhysDevExtTramp 28
-    PhysDevExtTramp 29
-    PhysDevExtTramp 30
-    PhysDevExtTramp 31
-    PhysDevExtTramp 32
-    PhysDevExtTramp 33
-    PhysDevExtTramp 34
-    PhysDevExtTramp 35
-    PhysDevExtTramp 36
-    PhysDevExtTramp 37
-    PhysDevExtTramp 38
-    PhysDevExtTramp 39
-    PhysDevExtTramp 40
-    PhysDevExtTramp 41
-    PhysDevExtTramp 42
-    PhysDevExtTramp 43
-    PhysDevExtTramp 44
-    PhysDevExtTramp 45
-    PhysDevExtTramp 46
-    PhysDevExtTramp 47
-    PhysDevExtTramp 48
-    PhysDevExtTramp 49
-    PhysDevExtTramp 50
-    PhysDevExtTramp 51
-    PhysDevExtTramp 52
-    PhysDevExtTramp 53
-    PhysDevExtTramp 54
-    PhysDevExtTramp 55
-    PhysDevExtTramp 56
-    PhysDevExtTramp 57
-    PhysDevExtTramp 58
-    PhysDevExtTramp 59
-    PhysDevExtTramp 60
-    PhysDevExtTramp 61
-    PhysDevExtTramp 62
-    PhysDevExtTramp 63
-    PhysDevExtTramp 64
-    PhysDevExtTramp 65
-    PhysDevExtTramp 66
-    PhysDevExtTramp 67
-    PhysDevExtTramp 68
-    PhysDevExtTramp 69
-    PhysDevExtTramp 70
-    PhysDevExtTramp 71
-    PhysDevExtTramp 72
-    PhysDevExtTramp 73
-    PhysDevExtTramp 74
-    PhysDevExtTramp 75
-    PhysDevExtTramp 76
-    PhysDevExtTramp 77
-    PhysDevExtTramp 78
-    PhysDevExtTramp 79
-    PhysDevExtTramp 80
-    PhysDevExtTramp 81
-    PhysDevExtTramp 82
-    PhysDevExtTramp 83
-    PhysDevExtTramp 84
-    PhysDevExtTramp 85
-    PhysDevExtTramp 86
-    PhysDevExtTramp 87
-    PhysDevExtTramp 88
-    PhysDevExtTramp 89
-    PhysDevExtTramp 90
-    PhysDevExtTramp 91
-    PhysDevExtTramp 92
-    PhysDevExtTramp 93
-    PhysDevExtTramp 94
-    PhysDevExtTramp 95
-    PhysDevExtTramp 96
-    PhysDevExtTramp 97
-    PhysDevExtTramp 98
-    PhysDevExtTramp 99
-    PhysDevExtTramp 100
-    PhysDevExtTramp 101
-    PhysDevExtTramp 102
-    PhysDevExtTramp 103
-    PhysDevExtTramp 104
-    PhysDevExtTramp 105
-    PhysDevExtTramp 106
-    PhysDevExtTramp 107
-    PhysDevExtTramp 108
-    PhysDevExtTramp 109
-    PhysDevExtTramp 110
-    PhysDevExtTramp 111
-    PhysDevExtTramp 112
-    PhysDevExtTramp 113
-    PhysDevExtTramp 114
-    PhysDevExtTramp 115
-    PhysDevExtTramp 116
-    PhysDevExtTramp 117
-    PhysDevExtTramp 118
-    PhysDevExtTramp 119
-    PhysDevExtTramp 120
-    PhysDevExtTramp 121
-    PhysDevExtTramp 122
-    PhysDevExtTramp 123
-    PhysDevExtTramp 124
-    PhysDevExtTramp 125
-    PhysDevExtTramp 126
-    PhysDevExtTramp 127
-    PhysDevExtTramp 128
-    PhysDevExtTramp 129
-    PhysDevExtTramp 130
-    PhysDevExtTramp 131
-    PhysDevExtTramp 132
-    PhysDevExtTramp 133
-    PhysDevExtTramp 134
-    PhysDevExtTramp 135
-    PhysDevExtTramp 136
-    PhysDevExtTramp 137
-    PhysDevExtTramp 138
-    PhysDevExtTramp 139
-    PhysDevExtTramp 140
-    PhysDevExtTramp 141
-    PhysDevExtTramp 142
-    PhysDevExtTramp 143
-    PhysDevExtTramp 144
-    PhysDevExtTramp 145
-    PhysDevExtTramp 146
-    PhysDevExtTramp 147
-    PhysDevExtTramp 148
-    PhysDevExtTramp 149
-    PhysDevExtTramp 150
-    PhysDevExtTramp 151
-    PhysDevExtTramp 152
-    PhysDevExtTramp 153
-    PhysDevExtTramp 154
-    PhysDevExtTramp 155
-    PhysDevExtTramp 156
-    PhysDevExtTramp 157
-    PhysDevExtTramp 158
-    PhysDevExtTramp 159
-    PhysDevExtTramp 160
-    PhysDevExtTramp 161
-    PhysDevExtTramp 162
-    PhysDevExtTramp 163
-    PhysDevExtTramp 164
-    PhysDevExtTramp 165
-    PhysDevExtTramp 166
-    PhysDevExtTramp 167
-    PhysDevExtTramp 168
-    PhysDevExtTramp 169
-    PhysDevExtTramp 170
-    PhysDevExtTramp 171
-    PhysDevExtTramp 172
-    PhysDevExtTramp 173
-    PhysDevExtTramp 174
-    PhysDevExtTramp 175
-    PhysDevExtTramp 176
-    PhysDevExtTramp 177
-    PhysDevExtTramp 178
-    PhysDevExtTramp 179
-    PhysDevExtTramp 180
-    PhysDevExtTramp 181
-    PhysDevExtTramp 182
-    PhysDevExtTramp 183
-    PhysDevExtTramp 184
-    PhysDevExtTramp 185
-    PhysDevExtTramp 186
-    PhysDevExtTramp 187
-    PhysDevExtTramp 188
-    PhysDevExtTramp 189
-    PhysDevExtTramp 190
-    PhysDevExtTramp 191
-    PhysDevExtTramp 192
-    PhysDevExtTramp 193
-    PhysDevExtTramp 194
-    PhysDevExtTramp 195
-    PhysDevExtTramp 196
-    PhysDevExtTramp 197
-    PhysDevExtTramp 198
-    PhysDevExtTramp 199
-    PhysDevExtTramp 200
-    PhysDevExtTramp 201
-    PhysDevExtTramp 202
-    PhysDevExtTramp 203
-    PhysDevExtTramp 204
-    PhysDevExtTramp 205
-    PhysDevExtTramp 206
-    PhysDevExtTramp 207
-    PhysDevExtTramp 208
-    PhysDevExtTramp 209
-    PhysDevExtTramp 210
-    PhysDevExtTramp 211
-    PhysDevExtTramp 212
-    PhysDevExtTramp 213
-    PhysDevExtTramp 214
-    PhysDevExtTramp 215
-    PhysDevExtTramp 216
-    PhysDevExtTramp 217
-    PhysDevExtTramp 218
-    PhysDevExtTramp 219
-    PhysDevExtTramp 220
-    PhysDevExtTramp 221
-    PhysDevExtTramp 222
-    PhysDevExtTramp 223
-    PhysDevExtTramp 224
-    PhysDevExtTramp 225
-    PhysDevExtTramp 226
-    PhysDevExtTramp 227
-    PhysDevExtTramp 228
-    PhysDevExtTramp 229
-    PhysDevExtTramp 230
-    PhysDevExtTramp 231
-    PhysDevExtTramp 232
-    PhysDevExtTramp 233
-    PhysDevExtTramp 234
-    PhysDevExtTramp 235
-    PhysDevExtTramp 236
-    PhysDevExtTramp 237
-    PhysDevExtTramp 238
-    PhysDevExtTramp 239
-    PhysDevExtTramp 240
-    PhysDevExtTramp 241
-    PhysDevExtTramp 242
-    PhysDevExtTramp 243
-    PhysDevExtTramp 244
-    PhysDevExtTramp 245
-    PhysDevExtTramp 246
-    PhysDevExtTramp 247
-    PhysDevExtTramp 248
-    PhysDevExtTramp 249
-
-    PhysDevExtTermin 0
-    PhysDevExtTermin 1
-    PhysDevExtTermin 2
-    PhysDevExtTermin 3
-    PhysDevExtTermin 4
-    PhysDevExtTermin 5
-    PhysDevExtTermin 6
-    PhysDevExtTermin 7
-    PhysDevExtTermin 8
-    PhysDevExtTermin 9
-    PhysDevExtTermin 10
-    PhysDevExtTermin 11
-    PhysDevExtTermin 12
-    PhysDevExtTermin 13
-    PhysDevExtTermin 14
-    PhysDevExtTermin 15
-    PhysDevExtTermin 16
-    PhysDevExtTermin 17
-    PhysDevExtTermin 18
-    PhysDevExtTermin 19
-    PhysDevExtTermin 20
-    PhysDevExtTermin 21
-    PhysDevExtTermin 22
-    PhysDevExtTermin 23
-    PhysDevExtTermin 24
-    PhysDevExtTermin 25
-    PhysDevExtTermin 26
-    PhysDevExtTermin 27
-    PhysDevExtTermin 28
-    PhysDevExtTermin 29
-    PhysDevExtTermin 30
-    PhysDevExtTermin 31
-    PhysDevExtTermin 32
-    PhysDevExtTermin 33
-    PhysDevExtTermin 34
-    PhysDevExtTermin 35
-    PhysDevExtTermin 36
-    PhysDevExtTermin 37
-    PhysDevExtTermin 38
-    PhysDevExtTermin 39
-    PhysDevExtTermin 40
-    PhysDevExtTermin 41
-    PhysDevExtTermin 42
-    PhysDevExtTermin 43
-    PhysDevExtTermin 44
-    PhysDevExtTermin 45
-    PhysDevExtTermin 46
-    PhysDevExtTermin 47
-    PhysDevExtTermin 48
-    PhysDevExtTermin 49
-    PhysDevExtTermin 50
-    PhysDevExtTermin 51
-    PhysDevExtTermin 52
-    PhysDevExtTermin 53
-    PhysDevExtTermin 54
-    PhysDevExtTermin 55
-    PhysDevExtTermin 56
-    PhysDevExtTermin 57
-    PhysDevExtTermin 58
-    PhysDevExtTermin 59
-    PhysDevExtTermin 60
-    PhysDevExtTermin 61
-    PhysDevExtTermin 62
-    PhysDevExtTermin 63
-    PhysDevExtTermin 64
-    PhysDevExtTermin 65
-    PhysDevExtTermin 66
-    PhysDevExtTermin 67
-    PhysDevExtTermin 68
-    PhysDevExtTermin 69
-    PhysDevExtTermin 70
-    PhysDevExtTermin 71
-    PhysDevExtTermin 72
-    PhysDevExtTermin 73
-    PhysDevExtTermin 74
-    PhysDevExtTermin 75
-    PhysDevExtTermin 76
-    PhysDevExtTermin 77
-    PhysDevExtTermin 78
-    PhysDevExtTermin 79
-    PhysDevExtTermin 80
-    PhysDevExtTermin 81
-    PhysDevExtTermin 82
-    PhysDevExtTermin 83
-    PhysDevExtTermin 84
-    PhysDevExtTermin 85
-    PhysDevExtTermin 86
-    PhysDevExtTermin 87
-    PhysDevExtTermin 88
-    PhysDevExtTermin 89
-    PhysDevExtTermin 90
-    PhysDevExtTermin 91
-    PhysDevExtTermin 92
-    PhysDevExtTermin 93
-    PhysDevExtTermin 94
-    PhysDevExtTermin 95
-    PhysDevExtTermin 96
-    PhysDevExtTermin 97
-    PhysDevExtTermin 98
-    PhysDevExtTermin 99
-    PhysDevExtTermin 100
-    PhysDevExtTermin 101
-    PhysDevExtTermin 102
-    PhysDevExtTermin 103
-    PhysDevExtTermin 104
-    PhysDevExtTermin 105
-    PhysDevExtTermin 106
-    PhysDevExtTermin 107
-    PhysDevExtTermin 108
-    PhysDevExtTermin 109
-    PhysDevExtTermin 110
-    PhysDevExtTermin 111
-    PhysDevExtTermin 112
-    PhysDevExtTermin 113
-    PhysDevExtTermin 114
-    PhysDevExtTermin 115
-    PhysDevExtTermin 116
-    PhysDevExtTermin 117
-    PhysDevExtTermin 118
-    PhysDevExtTermin 119
-    PhysDevExtTermin 120
-    PhysDevExtTermin 121
-    PhysDevExtTermin 122
-    PhysDevExtTermin 123
-    PhysDevExtTermin 124
-    PhysDevExtTermin 125
-    PhysDevExtTermin 126
-    PhysDevExtTermin 127
-    PhysDevExtTermin 128
-    PhysDevExtTermin 129
-    PhysDevExtTermin 130
-    PhysDevExtTermin 131
-    PhysDevExtTermin 132
-    PhysDevExtTermin 133
-    PhysDevExtTermin 134
-    PhysDevExtTermin 135
-    PhysDevExtTermin 136
-    PhysDevExtTermin 137
-    PhysDevExtTermin 138
-    PhysDevExtTermin 139
-    PhysDevExtTermin 140
-    PhysDevExtTermin 141
-    PhysDevExtTermin 142
-    PhysDevExtTermin 143
-    PhysDevExtTermin 144
-    PhysDevExtTermin 145
-    PhysDevExtTermin 146
-    PhysDevExtTermin 147
-    PhysDevExtTermin 148
-    PhysDevExtTermin 149
-    PhysDevExtTermin 150
-    PhysDevExtTermin 151
-    PhysDevExtTermin 152
-    PhysDevExtTermin 153
-    PhysDevExtTermin 154
-    PhysDevExtTermin 155
-    PhysDevExtTermin 156
-    PhysDevExtTermin 157
-    PhysDevExtTermin 158
-    PhysDevExtTermin 159
-    PhysDevExtTermin 160
-    PhysDevExtTermin 161
-    PhysDevExtTermin 162
-    PhysDevExtTermin 163
-    PhysDevExtTermin 164
-    PhysDevExtTermin 165
-    PhysDevExtTermin 166
-    PhysDevExtTermin 167
-    PhysDevExtTermin 168
-    PhysDevExtTermin 169
-    PhysDevExtTermin 170
-    PhysDevExtTermin 171
-    PhysDevExtTermin 172
-    PhysDevExtTermin 173
-    PhysDevExtTermin 174
-    PhysDevExtTermin 175
-    PhysDevExtTermin 176
-    PhysDevExtTermin 177
-    PhysDevExtTermin 178
-    PhysDevExtTermin 179
-    PhysDevExtTermin 180
-    PhysDevExtTermin 181
-    PhysDevExtTermin 182
-    PhysDevExtTermin 183
-    PhysDevExtTermin 184
-    PhysDevExtTermin 185
-    PhysDevExtTermin 186
-    PhysDevExtTermin 187
-    PhysDevExtTermin 188
-    PhysDevExtTermin 189
-    PhysDevExtTermin 190
-    PhysDevExtTermin 191
-    PhysDevExtTermin 192
-    PhysDevExtTermin 193
-    PhysDevExtTermin 194
-    PhysDevExtTermin 195
-    PhysDevExtTermin 196
-    PhysDevExtTermin 197
-    PhysDevExtTermin 198
-    PhysDevExtTermin 199
-    PhysDevExtTermin 200
-    PhysDevExtTermin 201
-    PhysDevExtTermin 202
-    PhysDevExtTermin 203
-    PhysDevExtTermin 204
-    PhysDevExtTermin 205
-    PhysDevExtTermin 206
-    PhysDevExtTermin 207
-    PhysDevExtTermin 208
-    PhysDevExtTermin 209
-    PhysDevExtTermin 210
-    PhysDevExtTermin 211
-    PhysDevExtTermin 212
-    PhysDevExtTermin 213
-    PhysDevExtTermin 214
-    PhysDevExtTermin 215
-    PhysDevExtTermin 216
-    PhysDevExtTermin 217
-    PhysDevExtTermin 218
-    PhysDevExtTermin 219
-    PhysDevExtTermin 220
-    PhysDevExtTermin 221
-    PhysDevExtTermin 222
-    PhysDevExtTermin 223
-    PhysDevExtTermin 224
-    PhysDevExtTermin 225
-    PhysDevExtTermin 226
-    PhysDevExtTermin 227
-    PhysDevExtTermin 228
-    PhysDevExtTermin 229
-    PhysDevExtTermin 230
-    PhysDevExtTermin 231
-    PhysDevExtTermin 232
-    PhysDevExtTermin 233
-    PhysDevExtTermin 234
-    PhysDevExtTermin 235
-    PhysDevExtTermin 236
-    PhysDevExtTermin 237
-    PhysDevExtTermin 238
-    PhysDevExtTermin 239
-    PhysDevExtTermin 240
-    PhysDevExtTermin 241
-    PhysDevExtTermin 242
-    PhysDevExtTermin 243
-    PhysDevExtTermin 244
-    PhysDevExtTermin 245
-    PhysDevExtTermin 246
-    PhysDevExtTermin 247
-    PhysDevExtTermin 248
-    PhysDevExtTermin 249
-
-    DevExtTramp 0
-    DevExtTramp 1
-    DevExtTramp 2
-    DevExtTramp 3
-    DevExtTramp 4
-    DevExtTramp 5
-    DevExtTramp 6
-    DevExtTramp 7
-    DevExtTramp 8
-    DevExtTramp 9
-    DevExtTramp 10
-    DevExtTramp 11
-    DevExtTramp 12
-    DevExtTramp 13
-    DevExtTramp 14
-    DevExtTramp 15
-    DevExtTramp 16
-    DevExtTramp 17
-    DevExtTramp 18
-    DevExtTramp 19
-    DevExtTramp 20
-    DevExtTramp 21
-    DevExtTramp 22
-    DevExtTramp 23
-    DevExtTramp 24
-    DevExtTramp 25
-    DevExtTramp 26
-    DevExtTramp 27
-    DevExtTramp 28
-    DevExtTramp 29
-    DevExtTramp 30
-    DevExtTramp 31
-    DevExtTramp 32
-    DevExtTramp 33
-    DevExtTramp 34
-    DevExtTramp 35
-    DevExtTramp 36
-    DevExtTramp 37
-    DevExtTramp 38
-    DevExtTramp 39
-    DevExtTramp 40
-    DevExtTramp 41
-    DevExtTramp 42
-    DevExtTramp 43
-    DevExtTramp 44
-    DevExtTramp 45
-    DevExtTramp 46
-    DevExtTramp 47
-    DevExtTramp 48
-    DevExtTramp 49
-    DevExtTramp 50
-    DevExtTramp 51
-    DevExtTramp 52
-    DevExtTramp 53
-    DevExtTramp 54
-    DevExtTramp 55
-    DevExtTramp 56
-    DevExtTramp 57
-    DevExtTramp 58
-    DevExtTramp 59
-    DevExtTramp 60
-    DevExtTramp 61
-    DevExtTramp 62
-    DevExtTramp 63
-    DevExtTramp 64
-    DevExtTramp 65
-    DevExtTramp 66
-    DevExtTramp 67
-    DevExtTramp 68
-    DevExtTramp 69
-    DevExtTramp 70
-    DevExtTramp 71
-    DevExtTramp 72
-    DevExtTramp 73
-    DevExtTramp 74
-    DevExtTramp 75
-    DevExtTramp 76
-    DevExtTramp 77
-    DevExtTramp 78
-    DevExtTramp 79
-    DevExtTramp 80
-    DevExtTramp 81
-    DevExtTramp 82
-    DevExtTramp 83
-    DevExtTramp 84
-    DevExtTramp 85
-    DevExtTramp 86
-    DevExtTramp 87
-    DevExtTramp 88
-    DevExtTramp 89
-    DevExtTramp 90
-    DevExtTramp 91
-    DevExtTramp 92
-    DevExtTramp 93
-    DevExtTramp 94
-    DevExtTramp 95
-    DevExtTramp 96
-    DevExtTramp 97
-    DevExtTramp 98
-    DevExtTramp 99
-    DevExtTramp 100
-    DevExtTramp 101
-    DevExtTramp 102
-    DevExtTramp 103
-    DevExtTramp 104
-    DevExtTramp 105
-    DevExtTramp 106
-    DevExtTramp 107
-    DevExtTramp 108
-    DevExtTramp 109
-    DevExtTramp 110
-    DevExtTramp 111
-    DevExtTramp 112
-    DevExtTramp 113
-    DevExtTramp 114
-    DevExtTramp 115
-    DevExtTramp 116
-    DevExtTramp 117
-    DevExtTramp 118
-    DevExtTramp 119
-    DevExtTramp 120
-    DevExtTramp 121
-    DevExtTramp 122
-    DevExtTramp 123
-    DevExtTramp 124
-    DevExtTramp 125
-    DevExtTramp 126
-    DevExtTramp 127
-    DevExtTramp 128
-    DevExtTramp 129
-    DevExtTramp 130
-    DevExtTramp 131
-    DevExtTramp 132
-    DevExtTramp 133
-    DevExtTramp 134
-    DevExtTramp 135
-    DevExtTramp 136
-    DevExtTramp 137
-    DevExtTramp 138
-    DevExtTramp 139
-    DevExtTramp 140
-    DevExtTramp 141
-    DevExtTramp 142
-    DevExtTramp 143
-    DevExtTramp 144
-    DevExtTramp 145
-    DevExtTramp 146
-    DevExtTramp 147
-    DevExtTramp 148
-    DevExtTramp 149
-    DevExtTramp 150
-    DevExtTramp 151
-    DevExtTramp 152
-    DevExtTramp 153
-    DevExtTramp 154
-    DevExtTramp 155
-    DevExtTramp 156
-    DevExtTramp 157
-    DevExtTramp 158
-    DevExtTramp 159
-    DevExtTramp 160
-    DevExtTramp 161
-    DevExtTramp 162
-    DevExtTramp 163
-    DevExtTramp 164
-    DevExtTramp 165
-    DevExtTramp 166
-    DevExtTramp 167
-    DevExtTramp 168
-    DevExtTramp 169
-    DevExtTramp 170
-    DevExtTramp 171
-    DevExtTramp 172
-    DevExtTramp 173
-    DevExtTramp 174
-    DevExtTramp 175
-    DevExtTramp 176
-    DevExtTramp 177
-    DevExtTramp 178
-    DevExtTramp 179
-    DevExtTramp 180
-    DevExtTramp 181
-    DevExtTramp 182
-    DevExtTramp 183
-    DevExtTramp 184
-    DevExtTramp 185
-    DevExtTramp 186
-    DevExtTramp 187
-    DevExtTramp 188
-    DevExtTramp 189
-    DevExtTramp 190
-    DevExtTramp 191
-    DevExtTramp 192
-    DevExtTramp 193
-    DevExtTramp 194
-    DevExtTramp 195
-    DevExtTramp 196
-    DevExtTramp 197
-    DevExtTramp 198
-    DevExtTramp 199
-    DevExtTramp 200
-    DevExtTramp 201
-    DevExtTramp 202
-    DevExtTramp 203
-    DevExtTramp 204
-    DevExtTramp 205
-    DevExtTramp 206
-    DevExtTramp 207
-    DevExtTramp 208
-    DevExtTramp 209
-    DevExtTramp 210
-    DevExtTramp 211
-    DevExtTramp 212
-    DevExtTramp 213
-    DevExtTramp 214
-    DevExtTramp 215
-    DevExtTramp 216
-    DevExtTramp 217
-    DevExtTramp 218
-    DevExtTramp 219
-    DevExtTramp 220
-    DevExtTramp 221
-    DevExtTramp 222
-    DevExtTramp 223
-    DevExtTramp 224
-    DevExtTramp 225
-    DevExtTramp 226
-    DevExtTramp 227
-    DevExtTramp 228
-    DevExtTramp 229
-    DevExtTramp 230
-    DevExtTramp 231
-    DevExtTramp 232
-    DevExtTramp 233
-    DevExtTramp 234
-    DevExtTramp 235
-    DevExtTramp 236
-    DevExtTramp 237
-    DevExtTramp 238
-    DevExtTramp 239
-    DevExtTramp 240
-    DevExtTramp 241
-    DevExtTramp 242
-    DevExtTramp 243
-    DevExtTramp 244
-    DevExtTramp 245
-    DevExtTramp 246
-    DevExtTramp 247
-    DevExtTramp 248
-    DevExtTramp 249
-
-end
diff --git a/third_party/vulkan/loader/vk_loader_extensions.c b/third_party/vulkan/loader/vk_loader_extensions.c
deleted file mode 100644
index 38692e53a..000000000
--- a/third_party/vulkan/loader/vk_loader_extensions.c
+++ /dev/null
@@ -1,2760 +0,0 @@
-// *** THIS FILE IS GENERATED - DO NOT EDIT ***
-// See loader_extension_generator.py for modifications
-
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Lobodzinski <mark@lunarg.com>
- * Author: Mark Young <marky@lunarg.com>
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "vk_loader_platform.h"
-#include "loader.h"
-#include "vk_loader_extensions.h"
-#include <vulkan/vk_icd.h>
-#include "wsi.h"
-#include "debug_report.h"
-#include "extension_manual.h"
-
-// Device extension error function
-VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev) {
-    struct loader_device *found_dev;
-    // The device going in is a trampoline device
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(dev, &found_dev, NULL);
-
-    if (icd_term)
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "Bad destination in loader trampoline dispatch,"
-                   "Are layers and extensions that you are calling enabled?");
-    return VK_ERROR_EXTENSION_NOT_PRESENT;
-}
-
-VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
-                                                   const PFN_vkGetInstanceProcAddr fp_gipa) {
-
-#define LOOKUP_GIPA(func, required)                                                        \
-    do {                                                                                   \
-        icd_term->dispatch.func = (PFN_vk##func)fp_gipa(inst, "vk" #func);                 \
-        if (!icd_term->dispatch.func && required) {                                        \
-            loader_log((struct loader_instance *)inst, VK_DEBUG_REPORT_WARNING_BIT_EXT, 0, \
-                       loader_platform_get_proc_address_error("vk" #func));                \
-            return false;                                                                  \
-        }                                                                                  \
-    } while (0)
-
-
-    // ---- Core 1_0
-    LOOKUP_GIPA(DestroyInstance, true);
-    LOOKUP_GIPA(EnumeratePhysicalDevices, true);
-    LOOKUP_GIPA(GetPhysicalDeviceFeatures, true);
-    LOOKUP_GIPA(GetPhysicalDeviceFormatProperties, true);
-    LOOKUP_GIPA(GetPhysicalDeviceImageFormatProperties, true);
-    LOOKUP_GIPA(GetPhysicalDeviceProperties, true);
-    LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties, true);
-    LOOKUP_GIPA(GetPhysicalDeviceMemoryProperties, true);
-    LOOKUP_GIPA(GetDeviceProcAddr, true);
-    LOOKUP_GIPA(CreateDevice, true);
-    LOOKUP_GIPA(EnumerateDeviceExtensionProperties, true);
-    LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties, true);
-
-    // ---- VK_KHR_surface extension commands
-    LOOKUP_GIPA(DestroySurfaceKHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportKHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilitiesKHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormatsKHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfacePresentModesKHR, false);
-
-    // ---- VK_KHR_swapchain extension commands
-    LOOKUP_GIPA(CreateSwapchainKHR, false);
-
-    // ---- VK_KHR_display extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceDisplayPropertiesKHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceDisplayPlanePropertiesKHR, false);
-    LOOKUP_GIPA(GetDisplayPlaneSupportedDisplaysKHR, false);
-    LOOKUP_GIPA(GetDisplayModePropertiesKHR, false);
-    LOOKUP_GIPA(CreateDisplayModeKHR, false);
-    LOOKUP_GIPA(GetDisplayPlaneCapabilitiesKHR, false);
-    LOOKUP_GIPA(CreateDisplayPlaneSurfaceKHR, false);
-
-    // ---- VK_KHR_display_swapchain extension commands
-    LOOKUP_GIPA(CreateSharedSwapchainsKHR, false);
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    LOOKUP_GIPA(CreateXlibSurfaceKHR, false);
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    LOOKUP_GIPA(GetPhysicalDeviceXlibPresentationSupportKHR, false);
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    LOOKUP_GIPA(CreateXcbSurfaceKHR, false);
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    LOOKUP_GIPA(GetPhysicalDeviceXcbPresentationSupportKHR, false);
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    LOOKUP_GIPA(CreateWaylandSurfaceKHR, false);
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    LOOKUP_GIPA(GetPhysicalDeviceWaylandPresentationSupportKHR, false);
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    LOOKUP_GIPA(CreateMirSurfaceKHR, false);
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    LOOKUP_GIPA(GetPhysicalDeviceMirPresentationSupportKHR, false);
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    LOOKUP_GIPA(CreateAndroidSurfaceKHR, false);
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    LOOKUP_GIPA(CreateWin32SurfaceKHR, false);
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    LOOKUP_GIPA(GetPhysicalDeviceWin32PresentationSupportKHR, false);
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceFeatures2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceProperties2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceFormatProperties2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceImageFormatProperties2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceMemoryProperties2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties2KHR, false);
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceExternalBufferPropertiesKHR, false);
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceExternalSemaphorePropertiesKHR, false);
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceExternalFencePropertiesKHR, false);
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilities2KHR, false);
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormats2KHR, false);
-
-    // ---- VK_EXT_debug_report extension commands
-    LOOKUP_GIPA(CreateDebugReportCallbackEXT, false);
-    LOOKUP_GIPA(DestroyDebugReportCallbackEXT, false);
-    LOOKUP_GIPA(DebugReportMessageEXT, false);
-
-    // ---- VK_EXT_debug_marker extension commands
-    LOOKUP_GIPA(DebugMarkerSetObjectTagEXT, false);
-    LOOKUP_GIPA(DebugMarkerSetObjectNameEXT, false);
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceExternalImageFormatPropertiesNV, false);
-
-    // ---- VK_KHX_device_group extension commands
-    LOOKUP_GIPA(GetDeviceGroupSurfacePresentModesKHX, false);
-    LOOKUP_GIPA(GetPhysicalDevicePresentRectanglesKHX, false);
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    LOOKUP_GIPA(CreateViSurfaceNN, false);
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    LOOKUP_GIPA(EnumeratePhysicalDeviceGroupsKHX, false);
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceGeneratedCommandsPropertiesNVX, false);
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    LOOKUP_GIPA(ReleaseDisplayEXT, false);
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    LOOKUP_GIPA(AcquireXlibDisplayEXT, false);
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    LOOKUP_GIPA(GetRandROutputDisplayEXT, false);
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilities2EXT, false);
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    LOOKUP_GIPA(CreateIOSSurfaceMVK, false);
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    LOOKUP_GIPA(CreateMacOSSurfaceMVK, false);
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    LOOKUP_GIPA(GetPhysicalDeviceMultisamplePropertiesEXT, false);
-
-#undef LOOKUP_GIPA
-
-    return true;
-};
-
-// Init Device function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
-                                                             VkDevice dev) {
-    VkLayerDispatchTable *table = &dev_table->core_dispatch;
-    for (uint32_t i = 0; i < MAX_NUM_UNKNOWN_EXTS; i++) dev_table->ext_dispatch.dev_ext[i] = (PFN_vkDevExt)vkDevExtError;
-
-    // ---- Core 1_0 commands
-    table->GetDeviceProcAddr = gpa;
-    table->DestroyDevice = (PFN_vkDestroyDevice)gpa(dev, "vkDestroyDevice");
-    table->GetDeviceQueue = (PFN_vkGetDeviceQueue)gpa(dev, "vkGetDeviceQueue");
-    table->QueueSubmit = (PFN_vkQueueSubmit)gpa(dev, "vkQueueSubmit");
-    table->QueueWaitIdle = (PFN_vkQueueWaitIdle)gpa(dev, "vkQueueWaitIdle");
-    table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle)gpa(dev, "vkDeviceWaitIdle");
-    table->AllocateMemory = (PFN_vkAllocateMemory)gpa(dev, "vkAllocateMemory");
-    table->FreeMemory = (PFN_vkFreeMemory)gpa(dev, "vkFreeMemory");
-    table->MapMemory = (PFN_vkMapMemory)gpa(dev, "vkMapMemory");
-    table->UnmapMemory = (PFN_vkUnmapMemory)gpa(dev, "vkUnmapMemory");
-    table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges)gpa(dev, "vkFlushMappedMemoryRanges");
-    table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges)gpa(dev, "vkInvalidateMappedMemoryRanges");
-    table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment)gpa(dev, "vkGetDeviceMemoryCommitment");
-    table->BindBufferMemory = (PFN_vkBindBufferMemory)gpa(dev, "vkBindBufferMemory");
-    table->BindImageMemory = (PFN_vkBindImageMemory)gpa(dev, "vkBindImageMemory");
-    table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements)gpa(dev, "vkGetBufferMemoryRequirements");
-    table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements)gpa(dev, "vkGetImageMemoryRequirements");
-    table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements)gpa(dev, "vkGetImageSparseMemoryRequirements");
-    table->QueueBindSparse = (PFN_vkQueueBindSparse)gpa(dev, "vkQueueBindSparse");
-    table->CreateFence = (PFN_vkCreateFence)gpa(dev, "vkCreateFence");
-    table->DestroyFence = (PFN_vkDestroyFence)gpa(dev, "vkDestroyFence");
-    table->ResetFences = (PFN_vkResetFences)gpa(dev, "vkResetFences");
-    table->GetFenceStatus = (PFN_vkGetFenceStatus)gpa(dev, "vkGetFenceStatus");
-    table->WaitForFences = (PFN_vkWaitForFences)gpa(dev, "vkWaitForFences");
-    table->CreateSemaphore = (PFN_vkCreateSemaphore)gpa(dev, "vkCreateSemaphore");
-    table->DestroySemaphore = (PFN_vkDestroySemaphore)gpa(dev, "vkDestroySemaphore");
-    table->CreateEvent = (PFN_vkCreateEvent)gpa(dev, "vkCreateEvent");
-    table->DestroyEvent = (PFN_vkDestroyEvent)gpa(dev, "vkDestroyEvent");
-    table->GetEventStatus = (PFN_vkGetEventStatus)gpa(dev, "vkGetEventStatus");
-    table->SetEvent = (PFN_vkSetEvent)gpa(dev, "vkSetEvent");
-    table->ResetEvent = (PFN_vkResetEvent)gpa(dev, "vkResetEvent");
-    table->CreateQueryPool = (PFN_vkCreateQueryPool)gpa(dev, "vkCreateQueryPool");
-    table->DestroyQueryPool = (PFN_vkDestroyQueryPool)gpa(dev, "vkDestroyQueryPool");
-    table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults)gpa(dev, "vkGetQueryPoolResults");
-    table->CreateBuffer = (PFN_vkCreateBuffer)gpa(dev, "vkCreateBuffer");
-    table->DestroyBuffer = (PFN_vkDestroyBuffer)gpa(dev, "vkDestroyBuffer");
-    table->CreateBufferView = (PFN_vkCreateBufferView)gpa(dev, "vkCreateBufferView");
-    table->DestroyBufferView = (PFN_vkDestroyBufferView)gpa(dev, "vkDestroyBufferView");
-    table->CreateImage = (PFN_vkCreateImage)gpa(dev, "vkCreateImage");
-    table->DestroyImage = (PFN_vkDestroyImage)gpa(dev, "vkDestroyImage");
-    table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout)gpa(dev, "vkGetImageSubresourceLayout");
-    table->CreateImageView = (PFN_vkCreateImageView)gpa(dev, "vkCreateImageView");
-    table->DestroyImageView = (PFN_vkDestroyImageView)gpa(dev, "vkDestroyImageView");
-    table->CreateShaderModule = (PFN_vkCreateShaderModule)gpa(dev, "vkCreateShaderModule");
-    table->DestroyShaderModule = (PFN_vkDestroyShaderModule)gpa(dev, "vkDestroyShaderModule");
-    table->CreatePipelineCache = (PFN_vkCreatePipelineCache)gpa(dev, "vkCreatePipelineCache");
-    table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache)gpa(dev, "vkDestroyPipelineCache");
-    table->GetPipelineCacheData = (PFN_vkGetPipelineCacheData)gpa(dev, "vkGetPipelineCacheData");
-    table->MergePipelineCaches = (PFN_vkMergePipelineCaches)gpa(dev, "vkMergePipelineCaches");
-    table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines)gpa(dev, "vkCreateGraphicsPipelines");
-    table->CreateComputePipelines = (PFN_vkCreateComputePipelines)gpa(dev, "vkCreateComputePipelines");
-    table->DestroyPipeline = (PFN_vkDestroyPipeline)gpa(dev, "vkDestroyPipeline");
-    table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout)gpa(dev, "vkCreatePipelineLayout");
-    table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout)gpa(dev, "vkDestroyPipelineLayout");
-    table->CreateSampler = (PFN_vkCreateSampler)gpa(dev, "vkCreateSampler");
-    table->DestroySampler = (PFN_vkDestroySampler)gpa(dev, "vkDestroySampler");
-    table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout)gpa(dev, "vkCreateDescriptorSetLayout");
-    table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout)gpa(dev, "vkDestroyDescriptorSetLayout");
-    table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool)gpa(dev, "vkCreateDescriptorPool");
-    table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool)gpa(dev, "vkDestroyDescriptorPool");
-    table->ResetDescriptorPool = (PFN_vkResetDescriptorPool)gpa(dev, "vkResetDescriptorPool");
-    table->AllocateDescriptorSets = (PFN_vkAllocateDescriptorSets)gpa(dev, "vkAllocateDescriptorSets");
-    table->FreeDescriptorSets = (PFN_vkFreeDescriptorSets)gpa(dev, "vkFreeDescriptorSets");
-    table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets)gpa(dev, "vkUpdateDescriptorSets");
-    table->CreateFramebuffer = (PFN_vkCreateFramebuffer)gpa(dev, "vkCreateFramebuffer");
-    table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer)gpa(dev, "vkDestroyFramebuffer");
-    table->CreateRenderPass = (PFN_vkCreateRenderPass)gpa(dev, "vkCreateRenderPass");
-    table->DestroyRenderPass = (PFN_vkDestroyRenderPass)gpa(dev, "vkDestroyRenderPass");
-    table->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity)gpa(dev, "vkGetRenderAreaGranularity");
-    table->CreateCommandPool = (PFN_vkCreateCommandPool)gpa(dev, "vkCreateCommandPool");
-    table->DestroyCommandPool = (PFN_vkDestroyCommandPool)gpa(dev, "vkDestroyCommandPool");
-    table->ResetCommandPool = (PFN_vkResetCommandPool)gpa(dev, "vkResetCommandPool");
-    table->AllocateCommandBuffers = (PFN_vkAllocateCommandBuffers)gpa(dev, "vkAllocateCommandBuffers");
-    table->FreeCommandBuffers = (PFN_vkFreeCommandBuffers)gpa(dev, "vkFreeCommandBuffers");
-    table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer)gpa(dev, "vkBeginCommandBuffer");
-    table->EndCommandBuffer = (PFN_vkEndCommandBuffer)gpa(dev, "vkEndCommandBuffer");
-    table->ResetCommandBuffer = (PFN_vkResetCommandBuffer)gpa(dev, "vkResetCommandBuffer");
-    table->CmdBindPipeline = (PFN_vkCmdBindPipeline)gpa(dev, "vkCmdBindPipeline");
-    table->CmdSetViewport = (PFN_vkCmdSetViewport)gpa(dev, "vkCmdSetViewport");
-    table->CmdSetScissor = (PFN_vkCmdSetScissor)gpa(dev, "vkCmdSetScissor");
-    table->CmdSetLineWidth = (PFN_vkCmdSetLineWidth)gpa(dev, "vkCmdSetLineWidth");
-    table->CmdSetDepthBias = (PFN_vkCmdSetDepthBias)gpa(dev, "vkCmdSetDepthBias");
-    table->CmdSetBlendConstants = (PFN_vkCmdSetBlendConstants)gpa(dev, "vkCmdSetBlendConstants");
-    table->CmdSetDepthBounds = (PFN_vkCmdSetDepthBounds)gpa(dev, "vkCmdSetDepthBounds");
-    table->CmdSetStencilCompareMask = (PFN_vkCmdSetStencilCompareMask)gpa(dev, "vkCmdSetStencilCompareMask");
-    table->CmdSetStencilWriteMask = (PFN_vkCmdSetStencilWriteMask)gpa(dev, "vkCmdSetStencilWriteMask");
-    table->CmdSetStencilReference = (PFN_vkCmdSetStencilReference)gpa(dev, "vkCmdSetStencilReference");
-    table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets)gpa(dev, "vkCmdBindDescriptorSets");
-    table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer)gpa(dev, "vkCmdBindIndexBuffer");
-    table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers)gpa(dev, "vkCmdBindVertexBuffers");
-    table->CmdDraw = (PFN_vkCmdDraw)gpa(dev, "vkCmdDraw");
-    table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed)gpa(dev, "vkCmdDrawIndexed");
-    table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect)gpa(dev, "vkCmdDrawIndirect");
-    table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect)gpa(dev, "vkCmdDrawIndexedIndirect");
-    table->CmdDispatch = (PFN_vkCmdDispatch)gpa(dev, "vkCmdDispatch");
-    table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect)gpa(dev, "vkCmdDispatchIndirect");
-    table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer)gpa(dev, "vkCmdCopyBuffer");
-    table->CmdCopyImage = (PFN_vkCmdCopyImage)gpa(dev, "vkCmdCopyImage");
-    table->CmdBlitImage = (PFN_vkCmdBlitImage)gpa(dev, "vkCmdBlitImage");
-    table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage)gpa(dev, "vkCmdCopyBufferToImage");
-    table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer)gpa(dev, "vkCmdCopyImageToBuffer");
-    table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer)gpa(dev, "vkCmdUpdateBuffer");
-    table->CmdFillBuffer = (PFN_vkCmdFillBuffer)gpa(dev, "vkCmdFillBuffer");
-    table->CmdClearColorImage = (PFN_vkCmdClearColorImage)gpa(dev, "vkCmdClearColorImage");
-    table->CmdClearDepthStencilImage = (PFN_vkCmdClearDepthStencilImage)gpa(dev, "vkCmdClearDepthStencilImage");
-    table->CmdClearAttachments = (PFN_vkCmdClearAttachments)gpa(dev, "vkCmdClearAttachments");
-    table->CmdResolveImage = (PFN_vkCmdResolveImage)gpa(dev, "vkCmdResolveImage");
-    table->CmdSetEvent = (PFN_vkCmdSetEvent)gpa(dev, "vkCmdSetEvent");
-    table->CmdResetEvent = (PFN_vkCmdResetEvent)gpa(dev, "vkCmdResetEvent");
-    table->CmdWaitEvents = (PFN_vkCmdWaitEvents)gpa(dev, "vkCmdWaitEvents");
-    table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier)gpa(dev, "vkCmdPipelineBarrier");
-    table->CmdBeginQuery = (PFN_vkCmdBeginQuery)gpa(dev, "vkCmdBeginQuery");
-    table->CmdEndQuery = (PFN_vkCmdEndQuery)gpa(dev, "vkCmdEndQuery");
-    table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool)gpa(dev, "vkCmdResetQueryPool");
-    table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp)gpa(dev, "vkCmdWriteTimestamp");
-    table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults)gpa(dev, "vkCmdCopyQueryPoolResults");
-    table->CmdPushConstants = (PFN_vkCmdPushConstants)gpa(dev, "vkCmdPushConstants");
-    table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass)gpa(dev, "vkCmdBeginRenderPass");
-    table->CmdNextSubpass = (PFN_vkCmdNextSubpass)gpa(dev, "vkCmdNextSubpass");
-    table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass)gpa(dev, "vkCmdEndRenderPass");
-    table->CmdExecuteCommands = (PFN_vkCmdExecuteCommands)gpa(dev, "vkCmdExecuteCommands");
-}
-
-// Init Device function pointer dispatch table with extension commands
-VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,
-                                                                       PFN_vkGetDeviceProcAddr gpa, VkDevice dev) {
-    VkLayerDispatchTable *table = &dev_table->core_dispatch;
-
-    // ---- VK_KHR_swapchain extension commands
-    table->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR)gpa(dev, "vkCreateSwapchainKHR");
-    table->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR)gpa(dev, "vkDestroySwapchainKHR");
-    table->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR)gpa(dev, "vkGetSwapchainImagesKHR");
-    table->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR)gpa(dev, "vkAcquireNextImageKHR");
-    table->QueuePresentKHR = (PFN_vkQueuePresentKHR)gpa(dev, "vkQueuePresentKHR");
-
-    // ---- VK_KHR_display_swapchain extension commands
-    table->CreateSharedSwapchainsKHR = (PFN_vkCreateSharedSwapchainsKHR)gpa(dev, "vkCreateSharedSwapchainsKHR");
-
-    // ---- VK_KHR_maintenance1 extension commands
-    table->TrimCommandPoolKHR = (PFN_vkTrimCommandPoolKHR)gpa(dev, "vkTrimCommandPoolKHR");
-
-    // ---- VK_KHR_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetMemoryWin32HandleKHR = (PFN_vkGetMemoryWin32HandleKHR)gpa(dev, "vkGetMemoryWin32HandleKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetMemoryWin32HandlePropertiesKHR = (PFN_vkGetMemoryWin32HandlePropertiesKHR)gpa(dev, "vkGetMemoryWin32HandlePropertiesKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_memory_fd extension commands
-    table->GetMemoryFdKHR = (PFN_vkGetMemoryFdKHR)gpa(dev, "vkGetMemoryFdKHR");
-    table->GetMemoryFdPropertiesKHR = (PFN_vkGetMemoryFdPropertiesKHR)gpa(dev, "vkGetMemoryFdPropertiesKHR");
-
-    // ---- VK_KHR_external_semaphore_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->ImportSemaphoreWin32HandleKHR = (PFN_vkImportSemaphoreWin32HandleKHR)gpa(dev, "vkImportSemaphoreWin32HandleKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetSemaphoreWin32HandleKHR = (PFN_vkGetSemaphoreWin32HandleKHR)gpa(dev, "vkGetSemaphoreWin32HandleKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_semaphore_fd extension commands
-    table->ImportSemaphoreFdKHR = (PFN_vkImportSemaphoreFdKHR)gpa(dev, "vkImportSemaphoreFdKHR");
-    table->GetSemaphoreFdKHR = (PFN_vkGetSemaphoreFdKHR)gpa(dev, "vkGetSemaphoreFdKHR");
-
-    // ---- VK_KHR_push_descriptor extension commands
-    table->CmdPushDescriptorSetKHR = (PFN_vkCmdPushDescriptorSetKHR)gpa(dev, "vkCmdPushDescriptorSetKHR");
-
-    // ---- VK_KHR_descriptor_update_template extension commands
-    table->CreateDescriptorUpdateTemplateKHR = (PFN_vkCreateDescriptorUpdateTemplateKHR)gpa(dev, "vkCreateDescriptorUpdateTemplateKHR");
-    table->DestroyDescriptorUpdateTemplateKHR = (PFN_vkDestroyDescriptorUpdateTemplateKHR)gpa(dev, "vkDestroyDescriptorUpdateTemplateKHR");
-    table->UpdateDescriptorSetWithTemplateKHR = (PFN_vkUpdateDescriptorSetWithTemplateKHR)gpa(dev, "vkUpdateDescriptorSetWithTemplateKHR");
-    table->CmdPushDescriptorSetWithTemplateKHR = (PFN_vkCmdPushDescriptorSetWithTemplateKHR)gpa(dev, "vkCmdPushDescriptorSetWithTemplateKHR");
-
-    // ---- VK_KHR_shared_presentable_image extension commands
-    table->GetSwapchainStatusKHR = (PFN_vkGetSwapchainStatusKHR)gpa(dev, "vkGetSwapchainStatusKHR");
-
-    // ---- VK_KHR_external_fence_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->ImportFenceWin32HandleKHR = (PFN_vkImportFenceWin32HandleKHR)gpa(dev, "vkImportFenceWin32HandleKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetFenceWin32HandleKHR = (PFN_vkGetFenceWin32HandleKHR)gpa(dev, "vkGetFenceWin32HandleKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_fence_fd extension commands
-    table->ImportFenceFdKHR = (PFN_vkImportFenceFdKHR)gpa(dev, "vkImportFenceFdKHR");
-    table->GetFenceFdKHR = (PFN_vkGetFenceFdKHR)gpa(dev, "vkGetFenceFdKHR");
-
-    // ---- VK_KHR_get_memory_requirements2 extension commands
-    table->GetImageMemoryRequirements2KHR = (PFN_vkGetImageMemoryRequirements2KHR)gpa(dev, "vkGetImageMemoryRequirements2KHR");
-    table->GetBufferMemoryRequirements2KHR = (PFN_vkGetBufferMemoryRequirements2KHR)gpa(dev, "vkGetBufferMemoryRequirements2KHR");
-    table->GetImageSparseMemoryRequirements2KHR = (PFN_vkGetImageSparseMemoryRequirements2KHR)gpa(dev, "vkGetImageSparseMemoryRequirements2KHR");
-
-    // ---- VK_KHR_sampler_ycbcr_conversion extension commands
-    table->CreateSamplerYcbcrConversionKHR = (PFN_vkCreateSamplerYcbcrConversionKHR)gpa(dev, "vkCreateSamplerYcbcrConversionKHR");
-    table->DestroySamplerYcbcrConversionKHR = (PFN_vkDestroySamplerYcbcrConversionKHR)gpa(dev, "vkDestroySamplerYcbcrConversionKHR");
-
-    // ---- VK_KHR_bind_memory2 extension commands
-    table->BindBufferMemory2KHR = (PFN_vkBindBufferMemory2KHR)gpa(dev, "vkBindBufferMemory2KHR");
-    table->BindImageMemory2KHR = (PFN_vkBindImageMemory2KHR)gpa(dev, "vkBindImageMemory2KHR");
-
-    // ---- VK_EXT_debug_marker extension commands
-    table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)gpa(dev, "vkDebugMarkerSetObjectTagEXT");
-    table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT)gpa(dev, "vkDebugMarkerSetObjectNameEXT");
-    table->CmdDebugMarkerBeginEXT = (PFN_vkCmdDebugMarkerBeginEXT)gpa(dev, "vkCmdDebugMarkerBeginEXT");
-    table->CmdDebugMarkerEndEXT = (PFN_vkCmdDebugMarkerEndEXT)gpa(dev, "vkCmdDebugMarkerEndEXT");
-    table->CmdDebugMarkerInsertEXT = (PFN_vkCmdDebugMarkerInsertEXT)gpa(dev, "vkCmdDebugMarkerInsertEXT");
-
-    // ---- VK_AMD_draw_indirect_count extension commands
-    table->CmdDrawIndirectCountAMD = (PFN_vkCmdDrawIndirectCountAMD)gpa(dev, "vkCmdDrawIndirectCountAMD");
-    table->CmdDrawIndexedIndirectCountAMD = (PFN_vkCmdDrawIndexedIndirectCountAMD)gpa(dev, "vkCmdDrawIndexedIndirectCountAMD");
-
-    // ---- VK_AMD_shader_info extension commands
-    table->GetShaderInfoAMD = (PFN_vkGetShaderInfoAMD)gpa(dev, "vkGetShaderInfoAMD");
-
-    // ---- VK_NV_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetMemoryWin32HandleNV = (PFN_vkGetMemoryWin32HandleNV)gpa(dev, "vkGetMemoryWin32HandleNV");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHX_device_group extension commands
-    table->GetDeviceGroupPeerMemoryFeaturesKHX = (PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)gpa(dev, "vkGetDeviceGroupPeerMemoryFeaturesKHX");
-    table->CmdSetDeviceMaskKHX = (PFN_vkCmdSetDeviceMaskKHX)gpa(dev, "vkCmdSetDeviceMaskKHX");
-    table->CmdDispatchBaseKHX = (PFN_vkCmdDispatchBaseKHX)gpa(dev, "vkCmdDispatchBaseKHX");
-    table->GetDeviceGroupPresentCapabilitiesKHX = (PFN_vkGetDeviceGroupPresentCapabilitiesKHX)gpa(dev, "vkGetDeviceGroupPresentCapabilitiesKHX");
-    table->GetDeviceGroupSurfacePresentModesKHX = (PFN_vkGetDeviceGroupSurfacePresentModesKHX)gpa(dev, "vkGetDeviceGroupSurfacePresentModesKHX");
-    table->AcquireNextImage2KHX = (PFN_vkAcquireNextImage2KHX)gpa(dev, "vkAcquireNextImage2KHX");
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    table->CmdProcessCommandsNVX = (PFN_vkCmdProcessCommandsNVX)gpa(dev, "vkCmdProcessCommandsNVX");
-    table->CmdReserveSpaceForCommandsNVX = (PFN_vkCmdReserveSpaceForCommandsNVX)gpa(dev, "vkCmdReserveSpaceForCommandsNVX");
-    table->CreateIndirectCommandsLayoutNVX = (PFN_vkCreateIndirectCommandsLayoutNVX)gpa(dev, "vkCreateIndirectCommandsLayoutNVX");
-    table->DestroyIndirectCommandsLayoutNVX = (PFN_vkDestroyIndirectCommandsLayoutNVX)gpa(dev, "vkDestroyIndirectCommandsLayoutNVX");
-    table->CreateObjectTableNVX = (PFN_vkCreateObjectTableNVX)gpa(dev, "vkCreateObjectTableNVX");
-    table->DestroyObjectTableNVX = (PFN_vkDestroyObjectTableNVX)gpa(dev, "vkDestroyObjectTableNVX");
-    table->RegisterObjectsNVX = (PFN_vkRegisterObjectsNVX)gpa(dev, "vkRegisterObjectsNVX");
-    table->UnregisterObjectsNVX = (PFN_vkUnregisterObjectsNVX)gpa(dev, "vkUnregisterObjectsNVX");
-
-    // ---- VK_NV_clip_space_w_scaling extension commands
-    table->CmdSetViewportWScalingNV = (PFN_vkCmdSetViewportWScalingNV)gpa(dev, "vkCmdSetViewportWScalingNV");
-
-    // ---- VK_EXT_display_control extension commands
-    table->DisplayPowerControlEXT = (PFN_vkDisplayPowerControlEXT)gpa(dev, "vkDisplayPowerControlEXT");
-    table->RegisterDeviceEventEXT = (PFN_vkRegisterDeviceEventEXT)gpa(dev, "vkRegisterDeviceEventEXT");
-    table->RegisterDisplayEventEXT = (PFN_vkRegisterDisplayEventEXT)gpa(dev, "vkRegisterDisplayEventEXT");
-    table->GetSwapchainCounterEXT = (PFN_vkGetSwapchainCounterEXT)gpa(dev, "vkGetSwapchainCounterEXT");
-
-    // ---- VK_GOOGLE_display_timing extension commands
-    table->GetRefreshCycleDurationGOOGLE = (PFN_vkGetRefreshCycleDurationGOOGLE)gpa(dev, "vkGetRefreshCycleDurationGOOGLE");
-    table->GetPastPresentationTimingGOOGLE = (PFN_vkGetPastPresentationTimingGOOGLE)gpa(dev, "vkGetPastPresentationTimingGOOGLE");
-
-    // ---- VK_EXT_discard_rectangles extension commands
-    table->CmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)gpa(dev, "vkCmdSetDiscardRectangleEXT");
-
-    // ---- VK_EXT_hdr_metadata extension commands
-    table->SetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)gpa(dev, "vkSetHdrMetadataEXT");
-
-    // ---- VK_EXT_sample_locations extension commands
-    table->CmdSetSampleLocationsEXT = (PFN_vkCmdSetSampleLocationsEXT)gpa(dev, "vkCmdSetSampleLocationsEXT");
-
-    // ---- VK_EXT_validation_cache extension commands
-    table->CreateValidationCacheEXT = (PFN_vkCreateValidationCacheEXT)gpa(dev, "vkCreateValidationCacheEXT");
-    table->DestroyValidationCacheEXT = (PFN_vkDestroyValidationCacheEXT)gpa(dev, "vkDestroyValidationCacheEXT");
-    table->MergeValidationCachesEXT = (PFN_vkMergeValidationCachesEXT)gpa(dev, "vkMergeValidationCachesEXT");
-    table->GetValidationCacheDataEXT = (PFN_vkGetValidationCacheDataEXT)gpa(dev, "vkGetValidationCacheDataEXT");
-
-    // ---- VK_EXT_external_memory_host extension commands
-    table->GetMemoryHostPointerPropertiesEXT = (PFN_vkGetMemoryHostPointerPropertiesEXT)gpa(dev, "vkGetMemoryHostPointerPropertiesEXT");
-}
-
-// Init Instance function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
-                                                                    VkInstance inst) {
-
-    // ---- Core 1_0 commands
-    table->DestroyInstance = (PFN_vkDestroyInstance)gpa(inst, "vkDestroyInstance");
-    table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices)gpa(inst, "vkEnumeratePhysicalDevices");
-    table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures)gpa(inst, "vkGetPhysicalDeviceFeatures");
-    table->GetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties)gpa(inst, "vkGetPhysicalDeviceFormatProperties");
-    table->GetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties");
-    table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties)gpa(inst, "vkGetPhysicalDeviceProperties");
-    table->GetPhysicalDeviceQueueFamilyProperties = (PFN_vkGetPhysicalDeviceQueueFamilyProperties)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties");
-    table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties)gpa(inst, "vkGetPhysicalDeviceMemoryProperties");
-    table->GetInstanceProcAddr = gpa;
-    table->EnumerateDeviceExtensionProperties = (PFN_vkEnumerateDeviceExtensionProperties)gpa(inst, "vkEnumerateDeviceExtensionProperties");
-    table->EnumerateDeviceLayerProperties = (PFN_vkEnumerateDeviceLayerProperties)gpa(inst, "vkEnumerateDeviceLayerProperties");
-    table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
-}
-
-// Init Instance function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
-                                                                        VkInstance inst) {
-
-    // ---- VK_KHR_surface extension commands
-    table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR)gpa(inst, "vkDestroySurfaceKHR");
-    table->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
-    table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
-    table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
-    table->GetPhysicalDeviceSurfacePresentModesKHR = (PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)gpa(inst, "vkGetPhysicalDeviceSurfacePresentModesKHR");
-
-    // ---- VK_KHR_display extension commands
-    table->GetPhysicalDeviceDisplayPropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPropertiesKHR");
-    table->GetPhysicalDeviceDisplayPlanePropertiesKHR = (PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
-    table->GetDisplayPlaneSupportedDisplaysKHR = (PFN_vkGetDisplayPlaneSupportedDisplaysKHR)gpa(inst, "vkGetDisplayPlaneSupportedDisplaysKHR");
-    table->GetDisplayModePropertiesKHR = (PFN_vkGetDisplayModePropertiesKHR)gpa(inst, "vkGetDisplayModePropertiesKHR");
-    table->CreateDisplayModeKHR = (PFN_vkCreateDisplayModeKHR)gpa(inst, "vkCreateDisplayModeKHR");
-    table->GetDisplayPlaneCapabilitiesKHR = (PFN_vkGetDisplayPlaneCapabilitiesKHR)gpa(inst, "vkGetDisplayPlaneCapabilitiesKHR");
-    table->CreateDisplayPlaneSurfaceKHR = (PFN_vkCreateDisplayPlaneSurfaceKHR)gpa(inst, "vkCreateDisplayPlaneSurfaceKHR");
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    table->CreateXlibSurfaceKHR = (PFN_vkCreateXlibSurfaceKHR)gpa(inst, "vkCreateXlibSurfaceKHR");
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    table->GetPhysicalDeviceXlibPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    table->CreateXcbSurfaceKHR = (PFN_vkCreateXcbSurfaceKHR)gpa(inst, "vkCreateXcbSurfaceKHR");
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    table->GetPhysicalDeviceXcbPresentationSupportKHR = (PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    table->CreateWaylandSurfaceKHR = (PFN_vkCreateWaylandSurfaceKHR)gpa(inst, "vkCreateWaylandSurfaceKHR");
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    table->GetPhysicalDeviceWaylandPresentationSupportKHR = (PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWaylandPresentationSupportKHR");
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    table->CreateMirSurfaceKHR = (PFN_vkCreateMirSurfaceKHR)gpa(inst, "vkCreateMirSurfaceKHR");
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    table->GetPhysicalDeviceMirPresentationSupportKHR = (PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceMirPresentationSupportKHR");
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    table->CreateAndroidSurfaceKHR = (PFN_vkCreateAndroidSurfaceKHR)gpa(inst, "vkCreateAndroidSurfaceKHR");
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->CreateWin32SurfaceKHR = (PFN_vkCreateWin32SurfaceKHR)gpa(inst, "vkCreateWin32SurfaceKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    table->GetPhysicalDeviceWin32PresentationSupportKHR = (PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)gpa(inst, "vkGetPhysicalDeviceWin32PresentationSupportKHR");
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    table->GetPhysicalDeviceFeatures2KHR = (PFN_vkGetPhysicalDeviceFeatures2KHR)gpa(inst, "vkGetPhysicalDeviceFeatures2KHR");
-    table->GetPhysicalDeviceProperties2KHR = (PFN_vkGetPhysicalDeviceProperties2KHR)gpa(inst, "vkGetPhysicalDeviceProperties2KHR");
-    table->GetPhysicalDeviceFormatProperties2KHR = (PFN_vkGetPhysicalDeviceFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceFormatProperties2KHR");
-    table->GetPhysicalDeviceImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceImageFormatProperties2KHR");
-    table->GetPhysicalDeviceQueueFamilyProperties2KHR = (PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)gpa(inst, "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
-    table->GetPhysicalDeviceMemoryProperties2KHR = (PFN_vkGetPhysicalDeviceMemoryProperties2KHR)gpa(inst, "vkGetPhysicalDeviceMemoryProperties2KHR");
-    table->GetPhysicalDeviceSparseImageFormatProperties2KHR = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    table->GetPhysicalDeviceExternalBufferPropertiesKHR = (PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    table->GetPhysicalDeviceExternalSemaphorePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    table->GetPhysicalDeviceExternalFencePropertiesKHR = (PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)gpa(inst, "vkGetPhysicalDeviceExternalFencePropertiesKHR");
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    table->GetPhysicalDeviceSurfaceCapabilities2KHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
-    table->GetPhysicalDeviceSurfaceFormats2KHR = (PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)gpa(inst, "vkGetPhysicalDeviceSurfaceFormats2KHR");
-
-    // ---- VK_EXT_debug_report extension commands
-    table->CreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)gpa(inst, "vkCreateDebugReportCallbackEXT");
-    table->DestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)gpa(inst, "vkDestroyDebugReportCallbackEXT");
-    table->DebugReportMessageEXT = (PFN_vkDebugReportMessageEXT)gpa(inst, "vkDebugReportMessageEXT");
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    table->GetPhysicalDeviceExternalImageFormatPropertiesNV = (PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)gpa(inst, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
-
-    // ---- VK_KHX_device_group extension commands
-    table->GetPhysicalDevicePresentRectanglesKHX = (PFN_vkGetPhysicalDevicePresentRectanglesKHX)gpa(inst, "vkGetPhysicalDevicePresentRectanglesKHX");
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    table->CreateViSurfaceNN = (PFN_vkCreateViSurfaceNN)gpa(inst, "vkCreateViSurfaceNN");
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    table->EnumeratePhysicalDeviceGroupsKHX = (PFN_vkEnumeratePhysicalDeviceGroupsKHX)gpa(inst, "vkEnumeratePhysicalDeviceGroupsKHX");
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX = (PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)gpa(inst, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX");
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    table->ReleaseDisplayEXT = (PFN_vkReleaseDisplayEXT)gpa(inst, "vkReleaseDisplayEXT");
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    table->AcquireXlibDisplayEXT = (PFN_vkAcquireXlibDisplayEXT)gpa(inst, "vkAcquireXlibDisplayEXT");
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    table->GetRandROutputDisplayEXT = (PFN_vkGetRandROutputDisplayEXT)gpa(inst, "vkGetRandROutputDisplayEXT");
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    table->GetPhysicalDeviceSurfaceCapabilities2EXT = (PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilities2EXT");
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    table->CreateIOSSurfaceMVK = (PFN_vkCreateIOSSurfaceMVK)gpa(inst, "vkCreateIOSSurfaceMVK");
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    table->CreateMacOSSurfaceMVK = (PFN_vkCreateMacOSSurfaceMVK)gpa(inst, "vkCreateMacOSSurfaceMVK");
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    table->GetPhysicalDeviceMultisamplePropertiesEXT = (PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)gpa(inst, "vkGetPhysicalDeviceMultisamplePropertiesEXT");
-}
-
-// Device command lookup function
-VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name) {
-    if (!name || name[0] != 'v' || name[1] != 'k') return NULL;
-
-    name += 2;
-
-    // ---- Core 1_0 commands
-    if (!strcmp(name, "GetDeviceProcAddr")) return (void *)table->GetDeviceProcAddr;
-    if (!strcmp(name, "DestroyDevice")) return (void *)table->DestroyDevice;
-    if (!strcmp(name, "GetDeviceQueue")) return (void *)table->GetDeviceQueue;
-    if (!strcmp(name, "QueueSubmit")) return (void *)table->QueueSubmit;
-    if (!strcmp(name, "QueueWaitIdle")) return (void *)table->QueueWaitIdle;
-    if (!strcmp(name, "DeviceWaitIdle")) return (void *)table->DeviceWaitIdle;
-    if (!strcmp(name, "AllocateMemory")) return (void *)table->AllocateMemory;
-    if (!strcmp(name, "FreeMemory")) return (void *)table->FreeMemory;
-    if (!strcmp(name, "MapMemory")) return (void *)table->MapMemory;
-    if (!strcmp(name, "UnmapMemory")) return (void *)table->UnmapMemory;
-    if (!strcmp(name, "FlushMappedMemoryRanges")) return (void *)table->FlushMappedMemoryRanges;
-    if (!strcmp(name, "InvalidateMappedMemoryRanges")) return (void *)table->InvalidateMappedMemoryRanges;
-    if (!strcmp(name, "GetDeviceMemoryCommitment")) return (void *)table->GetDeviceMemoryCommitment;
-    if (!strcmp(name, "BindBufferMemory")) return (void *)table->BindBufferMemory;
-    if (!strcmp(name, "BindImageMemory")) return (void *)table->BindImageMemory;
-    if (!strcmp(name, "GetBufferMemoryRequirements")) return (void *)table->GetBufferMemoryRequirements;
-    if (!strcmp(name, "GetImageMemoryRequirements")) return (void *)table->GetImageMemoryRequirements;
-    if (!strcmp(name, "GetImageSparseMemoryRequirements")) return (void *)table->GetImageSparseMemoryRequirements;
-    if (!strcmp(name, "QueueBindSparse")) return (void *)table->QueueBindSparse;
-    if (!strcmp(name, "CreateFence")) return (void *)table->CreateFence;
-    if (!strcmp(name, "DestroyFence")) return (void *)table->DestroyFence;
-    if (!strcmp(name, "ResetFences")) return (void *)table->ResetFences;
-    if (!strcmp(name, "GetFenceStatus")) return (void *)table->GetFenceStatus;
-    if (!strcmp(name, "WaitForFences")) return (void *)table->WaitForFences;
-    if (!strcmp(name, "CreateSemaphore")) return (void *)table->CreateSemaphore;
-    if (!strcmp(name, "DestroySemaphore")) return (void *)table->DestroySemaphore;
-    if (!strcmp(name, "CreateEvent")) return (void *)table->CreateEvent;
-    if (!strcmp(name, "DestroyEvent")) return (void *)table->DestroyEvent;
-    if (!strcmp(name, "GetEventStatus")) return (void *)table->GetEventStatus;
-    if (!strcmp(name, "SetEvent")) return (void *)table->SetEvent;
-    if (!strcmp(name, "ResetEvent")) return (void *)table->ResetEvent;
-    if (!strcmp(name, "CreateQueryPool")) return (void *)table->CreateQueryPool;
-    if (!strcmp(name, "DestroyQueryPool")) return (void *)table->DestroyQueryPool;
-    if (!strcmp(name, "GetQueryPoolResults")) return (void *)table->GetQueryPoolResults;
-    if (!strcmp(name, "CreateBuffer")) return (void *)table->CreateBuffer;
-    if (!strcmp(name, "DestroyBuffer")) return (void *)table->DestroyBuffer;
-    if (!strcmp(name, "CreateBufferView")) return (void *)table->CreateBufferView;
-    if (!strcmp(name, "DestroyBufferView")) return (void *)table->DestroyBufferView;
-    if (!strcmp(name, "CreateImage")) return (void *)table->CreateImage;
-    if (!strcmp(name, "DestroyImage")) return (void *)table->DestroyImage;
-    if (!strcmp(name, "GetImageSubresourceLayout")) return (void *)table->GetImageSubresourceLayout;
-    if (!strcmp(name, "CreateImageView")) return (void *)table->CreateImageView;
-    if (!strcmp(name, "DestroyImageView")) return (void *)table->DestroyImageView;
-    if (!strcmp(name, "CreateShaderModule")) return (void *)table->CreateShaderModule;
-    if (!strcmp(name, "DestroyShaderModule")) return (void *)table->DestroyShaderModule;
-    if (!strcmp(name, "CreatePipelineCache")) return (void *)table->CreatePipelineCache;
-    if (!strcmp(name, "DestroyPipelineCache")) return (void *)table->DestroyPipelineCache;
-    if (!strcmp(name, "GetPipelineCacheData")) return (void *)table->GetPipelineCacheData;
-    if (!strcmp(name, "MergePipelineCaches")) return (void *)table->MergePipelineCaches;
-    if (!strcmp(name, "CreateGraphicsPipelines")) return (void *)table->CreateGraphicsPipelines;
-    if (!strcmp(name, "CreateComputePipelines")) return (void *)table->CreateComputePipelines;
-    if (!strcmp(name, "DestroyPipeline")) return (void *)table->DestroyPipeline;
-    if (!strcmp(name, "CreatePipelineLayout")) return (void *)table->CreatePipelineLayout;
-    if (!strcmp(name, "DestroyPipelineLayout")) return (void *)table->DestroyPipelineLayout;
-    if (!strcmp(name, "CreateSampler")) return (void *)table->CreateSampler;
-    if (!strcmp(name, "DestroySampler")) return (void *)table->DestroySampler;
-    if (!strcmp(name, "CreateDescriptorSetLayout")) return (void *)table->CreateDescriptorSetLayout;
-    if (!strcmp(name, "DestroyDescriptorSetLayout")) return (void *)table->DestroyDescriptorSetLayout;
-    if (!strcmp(name, "CreateDescriptorPool")) return (void *)table->CreateDescriptorPool;
-    if (!strcmp(name, "DestroyDescriptorPool")) return (void *)table->DestroyDescriptorPool;
-    if (!strcmp(name, "ResetDescriptorPool")) return (void *)table->ResetDescriptorPool;
-    if (!strcmp(name, "AllocateDescriptorSets")) return (void *)table->AllocateDescriptorSets;
-    if (!strcmp(name, "FreeDescriptorSets")) return (void *)table->FreeDescriptorSets;
-    if (!strcmp(name, "UpdateDescriptorSets")) return (void *)table->UpdateDescriptorSets;
-    if (!strcmp(name, "CreateFramebuffer")) return (void *)table->CreateFramebuffer;
-    if (!strcmp(name, "DestroyFramebuffer")) return (void *)table->DestroyFramebuffer;
-    if (!strcmp(name, "CreateRenderPass")) return (void *)table->CreateRenderPass;
-    if (!strcmp(name, "DestroyRenderPass")) return (void *)table->DestroyRenderPass;
-    if (!strcmp(name, "GetRenderAreaGranularity")) return (void *)table->GetRenderAreaGranularity;
-    if (!strcmp(name, "CreateCommandPool")) return (void *)table->CreateCommandPool;
-    if (!strcmp(name, "DestroyCommandPool")) return (void *)table->DestroyCommandPool;
-    if (!strcmp(name, "ResetCommandPool")) return (void *)table->ResetCommandPool;
-    if (!strcmp(name, "AllocateCommandBuffers")) return (void *)table->AllocateCommandBuffers;
-    if (!strcmp(name, "FreeCommandBuffers")) return (void *)table->FreeCommandBuffers;
-    if (!strcmp(name, "BeginCommandBuffer")) return (void *)table->BeginCommandBuffer;
-    if (!strcmp(name, "EndCommandBuffer")) return (void *)table->EndCommandBuffer;
-    if (!strcmp(name, "ResetCommandBuffer")) return (void *)table->ResetCommandBuffer;
-    if (!strcmp(name, "CmdBindPipeline")) return (void *)table->CmdBindPipeline;
-    if (!strcmp(name, "CmdSetViewport")) return (void *)table->CmdSetViewport;
-    if (!strcmp(name, "CmdSetScissor")) return (void *)table->CmdSetScissor;
-    if (!strcmp(name, "CmdSetLineWidth")) return (void *)table->CmdSetLineWidth;
-    if (!strcmp(name, "CmdSetDepthBias")) return (void *)table->CmdSetDepthBias;
-    if (!strcmp(name, "CmdSetBlendConstants")) return (void *)table->CmdSetBlendConstants;
-    if (!strcmp(name, "CmdSetDepthBounds")) return (void *)table->CmdSetDepthBounds;
-    if (!strcmp(name, "CmdSetStencilCompareMask")) return (void *)table->CmdSetStencilCompareMask;
-    if (!strcmp(name, "CmdSetStencilWriteMask")) return (void *)table->CmdSetStencilWriteMask;
-    if (!strcmp(name, "CmdSetStencilReference")) return (void *)table->CmdSetStencilReference;
-    if (!strcmp(name, "CmdBindDescriptorSets")) return (void *)table->CmdBindDescriptorSets;
-    if (!strcmp(name, "CmdBindIndexBuffer")) return (void *)table->CmdBindIndexBuffer;
-    if (!strcmp(name, "CmdBindVertexBuffers")) return (void *)table->CmdBindVertexBuffers;
-    if (!strcmp(name, "CmdDraw")) return (void *)table->CmdDraw;
-    if (!strcmp(name, "CmdDrawIndexed")) return (void *)table->CmdDrawIndexed;
-    if (!strcmp(name, "CmdDrawIndirect")) return (void *)table->CmdDrawIndirect;
-    if (!strcmp(name, "CmdDrawIndexedIndirect")) return (void *)table->CmdDrawIndexedIndirect;
-    if (!strcmp(name, "CmdDispatch")) return (void *)table->CmdDispatch;
-    if (!strcmp(name, "CmdDispatchIndirect")) return (void *)table->CmdDispatchIndirect;
-    if (!strcmp(name, "CmdCopyBuffer")) return (void *)table->CmdCopyBuffer;
-    if (!strcmp(name, "CmdCopyImage")) return (void *)table->CmdCopyImage;
-    if (!strcmp(name, "CmdBlitImage")) return (void *)table->CmdBlitImage;
-    if (!strcmp(name, "CmdCopyBufferToImage")) return (void *)table->CmdCopyBufferToImage;
-    if (!strcmp(name, "CmdCopyImageToBuffer")) return (void *)table->CmdCopyImageToBuffer;
-    if (!strcmp(name, "CmdUpdateBuffer")) return (void *)table->CmdUpdateBuffer;
-    if (!strcmp(name, "CmdFillBuffer")) return (void *)table->CmdFillBuffer;
-    if (!strcmp(name, "CmdClearColorImage")) return (void *)table->CmdClearColorImage;
-    if (!strcmp(name, "CmdClearDepthStencilImage")) return (void *)table->CmdClearDepthStencilImage;
-    if (!strcmp(name, "CmdClearAttachments")) return (void *)table->CmdClearAttachments;
-    if (!strcmp(name, "CmdResolveImage")) return (void *)table->CmdResolveImage;
-    if (!strcmp(name, "CmdSetEvent")) return (void *)table->CmdSetEvent;
-    if (!strcmp(name, "CmdResetEvent")) return (void *)table->CmdResetEvent;
-    if (!strcmp(name, "CmdWaitEvents")) return (void *)table->CmdWaitEvents;
-    if (!strcmp(name, "CmdPipelineBarrier")) return (void *)table->CmdPipelineBarrier;
-    if (!strcmp(name, "CmdBeginQuery")) return (void *)table->CmdBeginQuery;
-    if (!strcmp(name, "CmdEndQuery")) return (void *)table->CmdEndQuery;
-    if (!strcmp(name, "CmdResetQueryPool")) return (void *)table->CmdResetQueryPool;
-    if (!strcmp(name, "CmdWriteTimestamp")) return (void *)table->CmdWriteTimestamp;
-    if (!strcmp(name, "CmdCopyQueryPoolResults")) return (void *)table->CmdCopyQueryPoolResults;
-    if (!strcmp(name, "CmdPushConstants")) return (void *)table->CmdPushConstants;
-    if (!strcmp(name, "CmdBeginRenderPass")) return (void *)table->CmdBeginRenderPass;
-    if (!strcmp(name, "CmdNextSubpass")) return (void *)table->CmdNextSubpass;
-    if (!strcmp(name, "CmdEndRenderPass")) return (void *)table->CmdEndRenderPass;
-    if (!strcmp(name, "CmdExecuteCommands")) return (void *)table->CmdExecuteCommands;
-
-    // ---- VK_KHR_swapchain extension commands
-    if (!strcmp(name, "CreateSwapchainKHR")) return (void *)table->CreateSwapchainKHR;
-    if (!strcmp(name, "DestroySwapchainKHR")) return (void *)table->DestroySwapchainKHR;
-    if (!strcmp(name, "GetSwapchainImagesKHR")) return (void *)table->GetSwapchainImagesKHR;
-    if (!strcmp(name, "AcquireNextImageKHR")) return (void *)table->AcquireNextImageKHR;
-    if (!strcmp(name, "QueuePresentKHR")) return (void *)table->QueuePresentKHR;
-
-    // ---- VK_KHR_display_swapchain extension commands
-    if (!strcmp(name, "CreateSharedSwapchainsKHR")) return (void *)table->CreateSharedSwapchainsKHR;
-
-    // ---- VK_KHR_maintenance1 extension commands
-    if (!strcmp(name, "TrimCommandPoolKHR")) return (void *)table->TrimCommandPoolKHR;
-
-    // ---- VK_KHR_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetMemoryWin32HandleKHR")) return (void *)table->GetMemoryWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetMemoryWin32HandlePropertiesKHR")) return (void *)table->GetMemoryWin32HandlePropertiesKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_memory_fd extension commands
-    if (!strcmp(name, "GetMemoryFdKHR")) return (void *)table->GetMemoryFdKHR;
-    if (!strcmp(name, "GetMemoryFdPropertiesKHR")) return (void *)table->GetMemoryFdPropertiesKHR;
-
-    // ---- VK_KHR_external_semaphore_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "ImportSemaphoreWin32HandleKHR")) return (void *)table->ImportSemaphoreWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetSemaphoreWin32HandleKHR")) return (void *)table->GetSemaphoreWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_semaphore_fd extension commands
-    if (!strcmp(name, "ImportSemaphoreFdKHR")) return (void *)table->ImportSemaphoreFdKHR;
-    if (!strcmp(name, "GetSemaphoreFdKHR")) return (void *)table->GetSemaphoreFdKHR;
-
-    // ---- VK_KHR_push_descriptor extension commands
-    if (!strcmp(name, "CmdPushDescriptorSetKHR")) return (void *)table->CmdPushDescriptorSetKHR;
-
-    // ---- VK_KHR_descriptor_update_template extension commands
-    if (!strcmp(name, "CreateDescriptorUpdateTemplateKHR")) return (void *)table->CreateDescriptorUpdateTemplateKHR;
-    if (!strcmp(name, "DestroyDescriptorUpdateTemplateKHR")) return (void *)table->DestroyDescriptorUpdateTemplateKHR;
-    if (!strcmp(name, "UpdateDescriptorSetWithTemplateKHR")) return (void *)table->UpdateDescriptorSetWithTemplateKHR;
-    if (!strcmp(name, "CmdPushDescriptorSetWithTemplateKHR")) return (void *)table->CmdPushDescriptorSetWithTemplateKHR;
-
-    // ---- VK_KHR_shared_presentable_image extension commands
-    if (!strcmp(name, "GetSwapchainStatusKHR")) return (void *)table->GetSwapchainStatusKHR;
-
-    // ---- VK_KHR_external_fence_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "ImportFenceWin32HandleKHR")) return (void *)table->ImportFenceWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetFenceWin32HandleKHR")) return (void *)table->GetFenceWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_fence_fd extension commands
-    if (!strcmp(name, "ImportFenceFdKHR")) return (void *)table->ImportFenceFdKHR;
-    if (!strcmp(name, "GetFenceFdKHR")) return (void *)table->GetFenceFdKHR;
-
-    // ---- VK_KHR_get_memory_requirements2 extension commands
-    if (!strcmp(name, "GetImageMemoryRequirements2KHR")) return (void *)table->GetImageMemoryRequirements2KHR;
-    if (!strcmp(name, "GetBufferMemoryRequirements2KHR")) return (void *)table->GetBufferMemoryRequirements2KHR;
-    if (!strcmp(name, "GetImageSparseMemoryRequirements2KHR")) return (void *)table->GetImageSparseMemoryRequirements2KHR;
-
-    // ---- VK_KHR_sampler_ycbcr_conversion extension commands
-    if (!strcmp(name, "CreateSamplerYcbcrConversionKHR")) return (void *)table->CreateSamplerYcbcrConversionKHR;
-    if (!strcmp(name, "DestroySamplerYcbcrConversionKHR")) return (void *)table->DestroySamplerYcbcrConversionKHR;
-
-    // ---- VK_KHR_bind_memory2 extension commands
-    if (!strcmp(name, "BindBufferMemory2KHR")) return (void *)table->BindBufferMemory2KHR;
-    if (!strcmp(name, "BindImageMemory2KHR")) return (void *)table->BindImageMemory2KHR;
-
-    // ---- VK_EXT_debug_marker extension commands
-    if (!strcmp(name, "DebugMarkerSetObjectTagEXT")) return (void *)table->DebugMarkerSetObjectTagEXT;
-    if (!strcmp(name, "DebugMarkerSetObjectNameEXT")) return (void *)table->DebugMarkerSetObjectNameEXT;
-    if (!strcmp(name, "CmdDebugMarkerBeginEXT")) return (void *)table->CmdDebugMarkerBeginEXT;
-    if (!strcmp(name, "CmdDebugMarkerEndEXT")) return (void *)table->CmdDebugMarkerEndEXT;
-    if (!strcmp(name, "CmdDebugMarkerInsertEXT")) return (void *)table->CmdDebugMarkerInsertEXT;
-
-    // ---- VK_AMD_draw_indirect_count extension commands
-    if (!strcmp(name, "CmdDrawIndirectCountAMD")) return (void *)table->CmdDrawIndirectCountAMD;
-    if (!strcmp(name, "CmdDrawIndexedIndirectCountAMD")) return (void *)table->CmdDrawIndexedIndirectCountAMD;
-
-    // ---- VK_AMD_shader_info extension commands
-    if (!strcmp(name, "GetShaderInfoAMD")) return (void *)table->GetShaderInfoAMD;
-
-    // ---- VK_NV_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetMemoryWin32HandleNV")) return (void *)table->GetMemoryWin32HandleNV;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHX_device_group extension commands
-    if (!strcmp(name, "GetDeviceGroupPeerMemoryFeaturesKHX")) return (void *)table->GetDeviceGroupPeerMemoryFeaturesKHX;
-    if (!strcmp(name, "CmdSetDeviceMaskKHX")) return (void *)table->CmdSetDeviceMaskKHX;
-    if (!strcmp(name, "CmdDispatchBaseKHX")) return (void *)table->CmdDispatchBaseKHX;
-    if (!strcmp(name, "GetDeviceGroupPresentCapabilitiesKHX")) return (void *)table->GetDeviceGroupPresentCapabilitiesKHX;
-    if (!strcmp(name, "GetDeviceGroupSurfacePresentModesKHX")) return (void *)table->GetDeviceGroupSurfacePresentModesKHX;
-    if (!strcmp(name, "AcquireNextImage2KHX")) return (void *)table->AcquireNextImage2KHX;
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    if (!strcmp(name, "CmdProcessCommandsNVX")) return (void *)table->CmdProcessCommandsNVX;
-    if (!strcmp(name, "CmdReserveSpaceForCommandsNVX")) return (void *)table->CmdReserveSpaceForCommandsNVX;
-    if (!strcmp(name, "CreateIndirectCommandsLayoutNVX")) return (void *)table->CreateIndirectCommandsLayoutNVX;
-    if (!strcmp(name, "DestroyIndirectCommandsLayoutNVX")) return (void *)table->DestroyIndirectCommandsLayoutNVX;
-    if (!strcmp(name, "CreateObjectTableNVX")) return (void *)table->CreateObjectTableNVX;
-    if (!strcmp(name, "DestroyObjectTableNVX")) return (void *)table->DestroyObjectTableNVX;
-    if (!strcmp(name, "RegisterObjectsNVX")) return (void *)table->RegisterObjectsNVX;
-    if (!strcmp(name, "UnregisterObjectsNVX")) return (void *)table->UnregisterObjectsNVX;
-
-    // ---- VK_NV_clip_space_w_scaling extension commands
-    if (!strcmp(name, "CmdSetViewportWScalingNV")) return (void *)table->CmdSetViewportWScalingNV;
-
-    // ---- VK_EXT_display_control extension commands
-    if (!strcmp(name, "DisplayPowerControlEXT")) return (void *)table->DisplayPowerControlEXT;
-    if (!strcmp(name, "RegisterDeviceEventEXT")) return (void *)table->RegisterDeviceEventEXT;
-    if (!strcmp(name, "RegisterDisplayEventEXT")) return (void *)table->RegisterDisplayEventEXT;
-    if (!strcmp(name, "GetSwapchainCounterEXT")) return (void *)table->GetSwapchainCounterEXT;
-
-    // ---- VK_GOOGLE_display_timing extension commands
-    if (!strcmp(name, "GetRefreshCycleDurationGOOGLE")) return (void *)table->GetRefreshCycleDurationGOOGLE;
-    if (!strcmp(name, "GetPastPresentationTimingGOOGLE")) return (void *)table->GetPastPresentationTimingGOOGLE;
-
-    // ---- VK_EXT_discard_rectangles extension commands
-    if (!strcmp(name, "CmdSetDiscardRectangleEXT")) return (void *)table->CmdSetDiscardRectangleEXT;
-
-    // ---- VK_EXT_hdr_metadata extension commands
-    if (!strcmp(name, "SetHdrMetadataEXT")) return (void *)table->SetHdrMetadataEXT;
-
-    // ---- VK_EXT_sample_locations extension commands
-    if (!strcmp(name, "CmdSetSampleLocationsEXT")) return (void *)table->CmdSetSampleLocationsEXT;
-
-    // ---- VK_EXT_validation_cache extension commands
-    if (!strcmp(name, "CreateValidationCacheEXT")) return (void *)table->CreateValidationCacheEXT;
-    if (!strcmp(name, "DestroyValidationCacheEXT")) return (void *)table->DestroyValidationCacheEXT;
-    if (!strcmp(name, "MergeValidationCachesEXT")) return (void *)table->MergeValidationCachesEXT;
-    if (!strcmp(name, "GetValidationCacheDataEXT")) return (void *)table->GetValidationCacheDataEXT;
-
-    // ---- VK_EXT_external_memory_host extension commands
-    if (!strcmp(name, "GetMemoryHostPointerPropertiesEXT")) return (void *)table->GetMemoryHostPointerPropertiesEXT;
-
-    return NULL;
-}
-
-// Instance command lookup function
-VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
-                                                                 bool *found_name) {
-    if (!name || name[0] != 'v' || name[1] != 'k') {
-        *found_name = false;
-        return NULL;
-    }
-
-    *found_name = true;
-    name += 2;
-
-    // ---- Core 1_0 commands
-    if (!strcmp(name, "DestroyInstance")) return (void *)table->DestroyInstance;
-    if (!strcmp(name, "EnumeratePhysicalDevices")) return (void *)table->EnumeratePhysicalDevices;
-    if (!strcmp(name, "GetPhysicalDeviceFeatures")) return (void *)table->GetPhysicalDeviceFeatures;
-    if (!strcmp(name, "GetPhysicalDeviceFormatProperties")) return (void *)table->GetPhysicalDeviceFormatProperties;
-    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties")) return (void *)table->GetPhysicalDeviceImageFormatProperties;
-    if (!strcmp(name, "GetPhysicalDeviceProperties")) return (void *)table->GetPhysicalDeviceProperties;
-    if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties")) return (void *)table->GetPhysicalDeviceQueueFamilyProperties;
-    if (!strcmp(name, "GetPhysicalDeviceMemoryProperties")) return (void *)table->GetPhysicalDeviceMemoryProperties;
-    if (!strcmp(name, "GetInstanceProcAddr")) return (void *)table->GetInstanceProcAddr;
-    if (!strcmp(name, "EnumerateDeviceExtensionProperties")) return (void *)table->EnumerateDeviceExtensionProperties;
-    if (!strcmp(name, "EnumerateDeviceLayerProperties")) return (void *)table->EnumerateDeviceLayerProperties;
-    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties")) return (void *)table->GetPhysicalDeviceSparseImageFormatProperties;
-
-    // ---- VK_KHR_surface extension commands
-    if (!strcmp(name, "DestroySurfaceKHR")) return (void *)table->DestroySurfaceKHR;
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceSupportKHR")) return (void *)table->GetPhysicalDeviceSurfaceSupportKHR;
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilitiesKHR")) return (void *)table->GetPhysicalDeviceSurfaceCapabilitiesKHR;
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceFormatsKHR")) return (void *)table->GetPhysicalDeviceSurfaceFormatsKHR;
-    if (!strcmp(name, "GetPhysicalDeviceSurfacePresentModesKHR")) return (void *)table->GetPhysicalDeviceSurfacePresentModesKHR;
-
-    // ---- VK_KHR_display extension commands
-    if (!strcmp(name, "GetPhysicalDeviceDisplayPropertiesKHR")) return (void *)table->GetPhysicalDeviceDisplayPropertiesKHR;
-    if (!strcmp(name, "GetPhysicalDeviceDisplayPlanePropertiesKHR")) return (void *)table->GetPhysicalDeviceDisplayPlanePropertiesKHR;
-    if (!strcmp(name, "GetDisplayPlaneSupportedDisplaysKHR")) return (void *)table->GetDisplayPlaneSupportedDisplaysKHR;
-    if (!strcmp(name, "GetDisplayModePropertiesKHR")) return (void *)table->GetDisplayModePropertiesKHR;
-    if (!strcmp(name, "CreateDisplayModeKHR")) return (void *)table->CreateDisplayModeKHR;
-    if (!strcmp(name, "GetDisplayPlaneCapabilitiesKHR")) return (void *)table->GetDisplayPlaneCapabilitiesKHR;
-    if (!strcmp(name, "CreateDisplayPlaneSurfaceKHR")) return (void *)table->CreateDisplayPlaneSurfaceKHR;
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    if (!strcmp(name, "CreateXlibSurfaceKHR")) return (void *)table->CreateXlibSurfaceKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    if (!strcmp(name, "GetPhysicalDeviceXlibPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceXlibPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    if (!strcmp(name, "CreateXcbSurfaceKHR")) return (void *)table->CreateXcbSurfaceKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    if (!strcmp(name, "GetPhysicalDeviceXcbPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceXcbPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    if (!strcmp(name, "CreateWaylandSurfaceKHR")) return (void *)table->CreateWaylandSurfaceKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    if (!strcmp(name, "GetPhysicalDeviceWaylandPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceWaylandPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    if (!strcmp(name, "CreateMirSurfaceKHR")) return (void *)table->CreateMirSurfaceKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    if (!strcmp(name, "GetPhysicalDeviceMirPresentationSupportKHR")) return (void *)table->GetPhysicalDeviceMirPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    if (!strcmp(name, "CreateAndroidSurfaceKHR")) return (void *)table->CreateAndroidSurfaceKHR;
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "CreateWin32SurfaceKHR")) return (void *)table->CreateWin32SurfaceKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp(name, "GetPhysicalDeviceWin32PresentationSupportKHR")) return (void *)table->GetPhysicalDeviceWin32PresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    if (!strcmp(name, "GetPhysicalDeviceFeatures2KHR")) return (void *)table->GetPhysicalDeviceFeatures2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceProperties2KHR")) return (void *)table->GetPhysicalDeviceProperties2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceFormatProperties2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceImageFormatProperties2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceQueueFamilyProperties2KHR")) return (void *)table->GetPhysicalDeviceQueueFamilyProperties2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceMemoryProperties2KHR")) return (void *)table->GetPhysicalDeviceMemoryProperties2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties2KHR")) return (void *)table->GetPhysicalDeviceSparseImageFormatProperties2KHR;
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    if (!strcmp(name, "GetPhysicalDeviceExternalBufferPropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalBufferPropertiesKHR;
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    if (!strcmp(name, "GetPhysicalDeviceExternalSemaphorePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalSemaphorePropertiesKHR;
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    if (!strcmp(name, "GetPhysicalDeviceExternalFencePropertiesKHR")) return (void *)table->GetPhysicalDeviceExternalFencePropertiesKHR;
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2KHR")) return (void *)table->GetPhysicalDeviceSurfaceCapabilities2KHR;
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceFormats2KHR")) return (void *)table->GetPhysicalDeviceSurfaceFormats2KHR;
-
-    // ---- VK_EXT_debug_report extension commands
-    if (!strcmp(name, "CreateDebugReportCallbackEXT")) return (void *)table->CreateDebugReportCallbackEXT;
-    if (!strcmp(name, "DestroyDebugReportCallbackEXT")) return (void *)table->DestroyDebugReportCallbackEXT;
-    if (!strcmp(name, "DebugReportMessageEXT")) return (void *)table->DebugReportMessageEXT;
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    if (!strcmp(name, "GetPhysicalDeviceExternalImageFormatPropertiesNV")) return (void *)table->GetPhysicalDeviceExternalImageFormatPropertiesNV;
-
-    // ---- VK_KHX_device_group extension commands
-    if (!strcmp(name, "GetPhysicalDevicePresentRectanglesKHX")) return (void *)table->GetPhysicalDevicePresentRectanglesKHX;
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    if (!strcmp(name, "CreateViSurfaceNN")) return (void *)table->CreateViSurfaceNN;
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    if (!strcmp(name, "EnumeratePhysicalDeviceGroupsKHX")) return (void *)table->EnumeratePhysicalDeviceGroupsKHX;
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    if (!strcmp(name, "GetPhysicalDeviceGeneratedCommandsPropertiesNVX")) return (void *)table->GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    if (!strcmp(name, "ReleaseDisplayEXT")) return (void *)table->ReleaseDisplayEXT;
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    if (!strcmp(name, "AcquireXlibDisplayEXT")) return (void *)table->AcquireXlibDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    if (!strcmp(name, "GetRandROutputDisplayEXT")) return (void *)table->GetRandROutputDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    if (!strcmp(name, "GetPhysicalDeviceSurfaceCapabilities2EXT")) return (void *)table->GetPhysicalDeviceSurfaceCapabilities2EXT;
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    if (!strcmp(name, "CreateIOSSurfaceMVK")) return (void *)table->CreateIOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    if (!strcmp(name, "CreateMacOSSurfaceMVK")) return (void *)table->CreateMacOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    if (!strcmp(name, "GetPhysicalDeviceMultisamplePropertiesEXT")) return (void *)table->GetPhysicalDeviceMultisamplePropertiesEXT;
-
-    *found_name = false;
-    return NULL;
-}
-
-
-// ---- VK_KHR_maintenance1 extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
-    VkDevice                                    device,
-    VkCommandPool                               commandPool,
-    VkCommandPoolTrimFlagsKHR                   flags) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->TrimCommandPoolKHR(device, commandPool, flags);
-}
-
-
-// ---- VK_KHR_external_memory_win32 extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
-    VkDevice                                    device,
-    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
-    HANDLE*                                     pHandle) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    HANDLE                                      handle,
-    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-// ---- VK_KHR_external_memory_fd extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
-    VkDevice                                    device,
-    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
-    int*                                        pFd) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryFdKHR(device, pGetFdInfo, pFd);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    int                                         fd,
-    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
-}
-
-
-// ---- VK_KHR_external_semaphore_win32 extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
-    HANDLE*                                     pHandle) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-// ---- VK_KHR_external_semaphore_fd extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
-    VkDevice                                    device,
-    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
-    VkDevice                                    device,
-    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
-    int*                                        pFd) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetSemaphoreFdKHR(device, pGetFdInfo, pFd);
-}
-
-
-// ---- VK_KHR_push_descriptor extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineBindPoint                         pipelineBindPoint,
-    VkPipelineLayout                            layout,
-    uint32_t                                    set,
-    uint32_t                                    descriptorWriteCount,
-    const VkWriteDescriptorSet*                 pDescriptorWrites) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
-}
-
-
-// ---- VK_KHR_descriptor_update_template extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
-    VkDevice                                    device,
-    const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-}
-
-VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
-    VkDevice                                    device,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    const VkAllocationCallbacks*                pAllocator) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
-}
-
-VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
-    VkDevice                                    device,
-    VkDescriptorSet                             descriptorSet,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    const void*                                 pData) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
-    VkCommandBuffer                             commandBuffer,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    VkPipelineLayout                            layout,
-    uint32_t                                    set,
-    const void*                                 pData) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
-}
-
-
-// ---- VK_KHR_shared_presentable_image extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetSwapchainStatusKHR(device, swapchain);
-}
-
-
-// ---- VK_KHR_external_fence_win32 extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
-    HANDLE*                                     pHandle) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-// ---- VK_KHR_external_fence_fd extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
-    VkDevice                                    device,
-    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->ImportFenceFdKHR(device, pImportFenceFdInfo);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
-    VkDevice                                    device,
-    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
-    int*                                        pFd) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetFenceFdKHR(device, pGetFdInfo, pFd);
-}
-
-
-// ---- VK_KHR_get_memory_requirements2 extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkImageMemoryRequirementsInfo2KHR*    pInfo,
-    VkMemoryRequirements2KHR*                   pMemoryRequirements) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-}
-
-VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
-    VkMemoryRequirements2KHR*                   pMemoryRequirements) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
-}
-
-VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
-    uint32_t*                                   pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2KHR*        pSparseMemoryRequirements) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-
-// ---- VK_KHR_sampler_ycbcr_conversion extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
-    VkDevice                                    device,
-    const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSamplerYcbcrConversionKHR*                pYcbcrConversion) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
-}
-
-VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
-    VkDevice                                    device,
-    VkSamplerYcbcrConversionKHR                 ycbcrConversion,
-    const VkAllocationCallbacks*                pAllocator) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
-}
-
-
-// ---- VK_KHR_bind_memory2 extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
-    VkDevice                                    device,
-    uint32_t                                    bindInfoCount,
-    const VkBindBufferMemoryInfoKHR*            pBindInfos) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->BindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
-    VkDevice                                    device,
-    uint32_t                                    bindInfoCount,
-    const VkBindImageMemoryInfoKHR*             pBindInfos) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->BindImageMemory2KHR(device, bindInfoCount, pBindInfos);
-}
-
-
-// ---- VK_EXT_debug_marker extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    VkDebugMarkerObjectTagInfoEXT local_tag_info;
-    memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT));
-    // If this is a physical device, we have to replace it with the proper one for the next call.
-    if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-        struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object;
-        local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
-    }
-    return disp->DebugMarkerSetObjectTagEXT(device, &local_tag_info);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo) {
-    uint32_t icd_index = 0;
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
-    if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectTagEXT) {
-        VkDebugMarkerObjectTagInfoEXT local_tag_info;
-        memcpy(&local_tag_info, pTagInfo, sizeof(VkDebugMarkerObjectTagInfoEXT));
-        // If this is a physical device, we have to replace it with the proper one for the next call.
-        if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-            struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pTagInfo->object;
-            local_tag_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
-        // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call.
-        } else if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
-            if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {
-                VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pTagInfo->object;
-                if (NULL != icd_surface->real_icd_surfaces) {
-                    local_tag_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];
-                }
-            }
-        }
-        return icd_term->dispatch.DebugMarkerSetObjectTagEXT(device, &local_tag_info);
-    } else {
-        return VK_SUCCESS;
-    }
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    VkDebugMarkerObjectNameInfoEXT local_name_info;
-    memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT));
-    // If this is a physical device, we have to replace it with the proper one for the next call.
-    if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-        struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object;
-        local_name_info.object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev;
-    }
-    return disp->DebugMarkerSetObjectNameEXT(device, &local_name_info);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo) {
-    uint32_t icd_index = 0;
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
-    if (NULL != icd_term && NULL != icd_term->dispatch.DebugMarkerSetObjectNameEXT) {
-        VkDebugMarkerObjectNameInfoEXT local_name_info;
-        memcpy(&local_name_info, pNameInfo, sizeof(VkDebugMarkerObjectNameInfoEXT));
-        // If this is a physical device, we have to replace it with the proper one for the next call.
-        if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-            struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pNameInfo->object;
-            local_name_info.object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev;
-        // If this is a KHR_surface, and the ICD has created its own, we have to replace it with the proper one for the next call.
-        } else if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
-            if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {
-                VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pNameInfo->object;
-                if (NULL != icd_surface->real_icd_surfaces) {
-                    local_name_info.object = (uint64_t)icd_surface->real_icd_surfaces[icd_index];
-                }
-            }
-        }
-        return icd_term->dispatch.DebugMarkerSetObjectNameEXT(device, &local_name_info);
-    } else {
-        return VK_SUCCESS;
-    }
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
-    VkCommandBuffer                             commandBuffer) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDebugMarkerEndEXT(commandBuffer);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
-}
-
-
-// ---- VK_AMD_draw_indirect_count extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    VkBuffer                                    countBuffer,
-    VkDeviceSize                                countBufferOffset,
-    uint32_t                                    maxDrawCount,
-    uint32_t                                    stride) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    VkBuffer                                    countBuffer,
-    VkDeviceSize                                countBufferOffset,
-    uint32_t                                    maxDrawCount,
-    uint32_t                                    stride) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
-}
-
-
-// ---- VK_AMD_shader_info extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
-    VkDevice                                    device,
-    VkPipeline                                  pipeline,
-    VkShaderStageFlagBits                       shaderStage,
-    VkShaderInfoTypeAMD                         infoType,
-    size_t*                                     pInfoSize,
-    void*                                       pInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
-}
-
-
-// ---- VK_NV_external_memory_win32 extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    VkExternalMemoryHandleTypeFlagsNV           handleType,
-    HANDLE*                                     pHandle) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
-}
-
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-// ---- VK_KHX_device_group extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(
-    VkDevice                                    device,
-    uint32_t                                    heapIndex,
-    uint32_t                                    localDeviceIndex,
-    uint32_t                                    remoteDeviceIndex,
-    VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->GetDeviceGroupPeerMemoryFeaturesKHX(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    deviceMask) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdSetDeviceMaskKHX(commandBuffer, deviceMask);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    baseGroupX,
-    uint32_t                                    baseGroupY,
-    uint32_t                                    baseGroupZ,
-    uint32_t                                    groupCountX,
-    uint32_t                                    groupCountY,
-    uint32_t                                    groupCountZ) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdDispatchBaseKHX(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHX(
-    VkDevice                                    device,
-    VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(
-    VkDevice                                    device,
-    VkSurfaceKHR                                surface,
-    VkDeviceGroupPresentModeFlagsKHX*           pModes) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDeviceGroupSurfacePresentModesKHX(
-    VkDevice                                    device,
-    VkSurfaceKHR                                surface,
-    VkDeviceGroupPresentModeFlagsKHX*           pModes) {
-    uint32_t icd_index = 0;
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
-    if (NULL != icd_term && NULL != icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX) {
-        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-        if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
-            return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX(device, icd_surface->real_icd_surfaces[icd_index], pModes);
-        }
-        return icd_term->dispatch.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
-    }
-    return VK_SUCCESS;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    uint32_t*                                   pRectCount,
-    VkRect2D*                                   pRects) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    return disp->GetPhysicalDevicePresentRectanglesKHX(unwrapped_phys_dev, surface, pRectCount, pRects);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDevicePresentRectanglesKHX(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    uint32_t*                                   pRectCount,
-    VkRect2D*                                   pRects) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL == icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD associated with VkPhysicalDevice does not support GetPhysicalDevicePresentRectanglesKHX");
-    }
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(surface);
-    uint8_t icd_index = phys_dev_term->icd_index;
-    if (NULL != icd_surface->real_icd_surfaces && NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) {
-        return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX(phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pRectCount, pRects);
-    }
-    return icd_term->dispatch.GetPhysicalDevicePresentRectanglesKHX(phys_dev_term->phys_dev, surface, pRectCount, pRects);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(
-    VkDevice                                    device,
-    const VkAcquireNextImageInfoKHX*            pAcquireInfo,
-    uint32_t*                                   pImageIndex) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex);
-}
-
-
-// ---- VK_NN_vi_surface extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_VI_NN
-VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
-    VkInstance                                  instance,
-    const VkViSurfaceCreateInfoNN*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-    return disp->CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateViSurfaceNN(
-    VkInstance                                  instance,
-    const VkViSurfaceCreateInfoNN*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-}
-
-#endif // VK_USE_PLATFORM_VI_NN
-
-// ---- VK_NVX_device_generated_commands extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(
-    VkCommandBuffer                             commandBuffer,
-    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
-}
-
-VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
-    VkCommandBuffer                             commandBuffer,
-    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
-    VkDevice                                    device,
-    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
-}
-
-VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
-    VkDevice                                    device,
-    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
-    const VkAllocationCallbacks*                pAllocator) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
-    VkDevice                                    device,
-    const VkObjectTableCreateInfoNVX*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkObjectTableNVX*                           pObjectTable) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
-}
-
-VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    const VkAllocationCallbacks*                pAllocator) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroyObjectTableNVX(device, objectTable, pAllocator);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    uint32_t                                    objectCount,
-    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
-    const uint32_t*                             pObjectIndices) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    uint32_t                                    objectCount,
-    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
-    const uint32_t*                             pObjectIndices) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice                            physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX*         pLimits) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev, pFeatures, pLimits);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice                            physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX*         pLimits) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceGeneratedCommandsPropertiesNVX) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceGeneratedCommandsPropertiesNVX");
-    }
-    icd_term->dispatch.GetPhysicalDeviceGeneratedCommandsPropertiesNVX(phys_dev_term->phys_dev, pFeatures, pLimits);
-}
-
-
-// ---- VK_NV_clip_space_w_scaling extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstViewport,
-    uint32_t                                    viewportCount,
-    const VkViewportWScalingNV*                 pViewportWScalings) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
-}
-
-
-// ---- VK_EXT_display_control extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
-    VkDevice                                    device,
-    VkDisplayKHR                                display,
-    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
-    VkDevice                                    device,
-    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFence*                                    pFence) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
-    VkDevice                                    device,
-    VkDisplayKHR                                display,
-    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFence*                                    pFence) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    VkSurfaceCounterFlagBitsEXT                 counter,
-    uint64_t*                                   pCounterValue) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
-}
-
-
-// ---- VK_GOOGLE_display_timing extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    uint32_t*                                   pPresentationTimingCount,
-    VkPastPresentationTimingGOOGLE*             pPresentationTimings) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
-}
-
-
-// ---- VK_EXT_discard_rectangles extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstDiscardRectangle,
-    uint32_t                                    discardRectangleCount,
-    const VkRect2D*                             pDiscardRectangles) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
-}
-
-
-// ---- VK_EXT_hdr_metadata extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
-    VkDevice                                    device,
-    uint32_t                                    swapchainCount,
-    const VkSwapchainKHR*                       pSwapchains,
-    const VkHdrMetadataEXT*                     pMetadata) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
-}
-
-
-// ---- VK_MVK_ios_surface extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-    return disp->CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateIOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-}
-
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-// ---- VK_MVK_macos_surface extension trampoline/terminators
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-    return disp->CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMacOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface) {
-#error("Not implemented. Likely needs to be manually generated!");
-}
-
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-// ---- VK_EXT_sample_locations extension trampoline/terminators
-
-VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer);
-    disp->CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
-}
-
-VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
-    VkPhysicalDevice                            physicalDevice,
-    VkSampleCountFlagBits                       samples,
-    VkMultisamplePropertiesEXT*                 pMultisampleProperties) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    disp->GetPhysicalDeviceMultisamplePropertiesEXT(unwrapped_phys_dev, samples, pMultisampleProperties);
-}
-
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMultisamplePropertiesEXT(
-    VkPhysicalDevice                            physicalDevice,
-    VkSampleCountFlagBits                       samples,
-    VkMultisamplePropertiesEXT*                 pMultisampleProperties) {
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceMultisamplePropertiesEXT) {
-        loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceMultisamplePropertiesEXT");
-    }
-    icd_term->dispatch.GetPhysicalDeviceMultisamplePropertiesEXT(phys_dev_term->phys_dev, samples, pMultisampleProperties);
-}
-
-
-// ---- VK_EXT_validation_cache extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
-    VkDevice                                    device,
-    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkValidationCacheEXT*                       pValidationCache) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
-}
-
-VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        validationCache,
-    const VkAllocationCallbacks*                pAllocator) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    disp->DestroyValidationCacheEXT(device, validationCache, pAllocator);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        dstCache,
-    uint32_t                                    srcCacheCount,
-    const VkValidationCacheEXT*                 pSrcCaches) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        validationCache,
-    size_t*                                     pDataSize,
-    void*                                       pData) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
-}
-
-
-// ---- VK_EXT_external_memory_host extension trampoline/terminators
-
-VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    const void*                                 pHostPointer,
-    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties) {
-    const VkLayerDispatchTable *disp = loader_get_dispatch(device);
-    return disp->GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
-}
-
-// GPA helpers for extensions
-bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
-    *addr = NULL;
-
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    if (!strcmp("vkGetPhysicalDeviceFeatures2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceFeatures2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceProperties2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceFormatProperties2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceImageFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceImageFormatProperties2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceQueueFamilyProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceQueueFamilyProperties2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceMemoryProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceMemoryProperties2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1)
-                     ? (void *)GetPhysicalDeviceSparseImageFormatProperties2KHR
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_KHR_maintenance1 extension commands
-    if (!strcmp("vkTrimCommandPoolKHR", name)) {
-        *addr = (void *)TrimCommandPoolKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    if (!strcmp("vkGetPhysicalDeviceExternalBufferPropertiesKHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_external_memory_capabilities == 1)
-                     ? (void *)GetPhysicalDeviceExternalBufferPropertiesKHR
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_KHR_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkGetMemoryWin32HandleKHR", name)) {
-        *addr = (void *)GetMemoryWin32HandleKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkGetMemoryWin32HandlePropertiesKHR", name)) {
-        *addr = (void *)GetMemoryWin32HandlePropertiesKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_memory_fd extension commands
-    if (!strcmp("vkGetMemoryFdKHR", name)) {
-        *addr = (void *)GetMemoryFdKHR;
-        return true;
-    }
-    if (!strcmp("vkGetMemoryFdPropertiesKHR", name)) {
-        *addr = (void *)GetMemoryFdPropertiesKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    if (!strcmp("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities == 1)
-                     ? (void *)GetPhysicalDeviceExternalSemaphorePropertiesKHR
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_KHR_external_semaphore_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkImportSemaphoreWin32HandleKHR", name)) {
-        *addr = (void *)ImportSemaphoreWin32HandleKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkGetSemaphoreWin32HandleKHR", name)) {
-        *addr = (void *)GetSemaphoreWin32HandleKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_semaphore_fd extension commands
-    if (!strcmp("vkImportSemaphoreFdKHR", name)) {
-        *addr = (void *)ImportSemaphoreFdKHR;
-        return true;
-    }
-    if (!strcmp("vkGetSemaphoreFdKHR", name)) {
-        *addr = (void *)GetSemaphoreFdKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_push_descriptor extension commands
-    if (!strcmp("vkCmdPushDescriptorSetKHR", name)) {
-        *addr = (void *)CmdPushDescriptorSetKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_descriptor_update_template extension commands
-    if (!strcmp("vkCreateDescriptorUpdateTemplateKHR", name)) {
-        *addr = (void *)CreateDescriptorUpdateTemplateKHR;
-        return true;
-    }
-    if (!strcmp("vkDestroyDescriptorUpdateTemplateKHR", name)) {
-        *addr = (void *)DestroyDescriptorUpdateTemplateKHR;
-        return true;
-    }
-    if (!strcmp("vkUpdateDescriptorSetWithTemplateKHR", name)) {
-        *addr = (void *)UpdateDescriptorSetWithTemplateKHR;
-        return true;
-    }
-    if (!strcmp("vkCmdPushDescriptorSetWithTemplateKHR", name)) {
-        *addr = (void *)CmdPushDescriptorSetWithTemplateKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_shared_presentable_image extension commands
-    if (!strcmp("vkGetSwapchainStatusKHR", name)) {
-        *addr = (void *)GetSwapchainStatusKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    if (!strcmp("vkGetPhysicalDeviceExternalFencePropertiesKHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_external_fence_capabilities == 1)
-                     ? (void *)GetPhysicalDeviceExternalFencePropertiesKHR
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_KHR_external_fence_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkImportFenceWin32HandleKHR", name)) {
-        *addr = (void *)ImportFenceWin32HandleKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkGetFenceWin32HandleKHR", name)) {
-        *addr = (void *)GetFenceWin32HandleKHR;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_fence_fd extension commands
-    if (!strcmp("vkImportFenceFdKHR", name)) {
-        *addr = (void *)ImportFenceFdKHR;
-        return true;
-    }
-    if (!strcmp("vkGetFenceFdKHR", name)) {
-        *addr = (void *)GetFenceFdKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1)
-                     ? (void *)GetPhysicalDeviceSurfaceCapabilities2KHR
-                     : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSurfaceFormats2KHR", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 == 1)
-                     ? (void *)GetPhysicalDeviceSurfaceFormats2KHR
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_KHR_get_memory_requirements2 extension commands
-    if (!strcmp("vkGetImageMemoryRequirements2KHR", name)) {
-        *addr = (void *)GetImageMemoryRequirements2KHR;
-        return true;
-    }
-    if (!strcmp("vkGetBufferMemoryRequirements2KHR", name)) {
-        *addr = (void *)GetBufferMemoryRequirements2KHR;
-        return true;
-    }
-    if (!strcmp("vkGetImageSparseMemoryRequirements2KHR", name)) {
-        *addr = (void *)GetImageSparseMemoryRequirements2KHR;
-        return true;
-    }
-
-    // ---- VK_KHR_sampler_ycbcr_conversion extension commands
-    if (!strcmp("vkCreateSamplerYcbcrConversionKHR", name)) {
-        *addr = (void *)CreateSamplerYcbcrConversionKHR;
-        return true;
-    }
-    if (!strcmp("vkDestroySamplerYcbcrConversionKHR", name)) {
-        *addr = (void *)DestroySamplerYcbcrConversionKHR;
-        return true;
-    }
-
-    // ---- VK_KHR_bind_memory2 extension commands
-    if (!strcmp("vkBindBufferMemory2KHR", name)) {
-        *addr = (void *)BindBufferMemory2KHR;
-        return true;
-    }
-    if (!strcmp("vkBindImageMemory2KHR", name)) {
-        *addr = (void *)BindImageMemory2KHR;
-        return true;
-    }
-
-    // ---- VK_EXT_debug_marker extension commands
-    if (!strcmp("vkDebugMarkerSetObjectTagEXT", name)) {
-        *addr = (void *)DebugMarkerSetObjectTagEXT;
-        return true;
-    }
-    if (!strcmp("vkDebugMarkerSetObjectNameEXT", name)) {
-        *addr = (void *)DebugMarkerSetObjectNameEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerBeginEXT", name)) {
-        *addr = (void *)CmdDebugMarkerBeginEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerEndEXT", name)) {
-        *addr = (void *)CmdDebugMarkerEndEXT;
-        return true;
-    }
-    if (!strcmp("vkCmdDebugMarkerInsertEXT", name)) {
-        *addr = (void *)CmdDebugMarkerInsertEXT;
-        return true;
-    }
-
-    // ---- VK_AMD_draw_indirect_count extension commands
-    if (!strcmp("vkCmdDrawIndirectCountAMD", name)) {
-        *addr = (void *)CmdDrawIndirectCountAMD;
-        return true;
-    }
-    if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) {
-        *addr = (void *)CmdDrawIndexedIndirectCountAMD;
-        return true;
-    }
-
-    // ---- VK_AMD_shader_info extension commands
-    if (!strcmp("vkGetShaderInfoAMD", name)) {
-        *addr = (void *)GetShaderInfoAMD;
-        return true;
-    }
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.nv_external_memory_capabilities == 1)
-                     ? (void *)GetPhysicalDeviceExternalImageFormatPropertiesNV
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_NV_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    if (!strcmp("vkGetMemoryWin32HandleNV", name)) {
-        *addr = (void *)GetMemoryWin32HandleNV;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHX_device_group extension commands
-    if (!strcmp("vkGetDeviceGroupPeerMemoryFeaturesKHX", name)) {
-        *addr = (void *)GetDeviceGroupPeerMemoryFeaturesKHX;
-        return true;
-    }
-    if (!strcmp("vkCmdSetDeviceMaskKHX", name)) {
-        *addr = (void *)CmdSetDeviceMaskKHX;
-        return true;
-    }
-    if (!strcmp("vkCmdDispatchBaseKHX", name)) {
-        *addr = (void *)CmdDispatchBaseKHX;
-        return true;
-    }
-    if (!strcmp("vkGetDeviceGroupPresentCapabilitiesKHX", name)) {
-        *addr = (void *)GetDeviceGroupPresentCapabilitiesKHX;
-        return true;
-    }
-    if (!strcmp("vkGetDeviceGroupSurfacePresentModesKHX", name)) {
-        *addr = (void *)GetDeviceGroupSurfacePresentModesKHX;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDevicePresentRectanglesKHX", name)) {
-        *addr = (void *)GetPhysicalDevicePresentRectanglesKHX;
-        return true;
-    }
-    if (!strcmp("vkAcquireNextImage2KHX", name)) {
-        *addr = (void *)AcquireNextImage2KHX;
-        return true;
-    }
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    if (!strcmp("vkCreateViSurfaceNN", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.nn_vi_surface == 1)
-                     ? (void *)CreateViSurfaceNN
-                     : NULL;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    if (!strcmp("vkEnumeratePhysicalDeviceGroupsKHX", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.khx_device_group_creation == 1)
-                     ? (void *)EnumeratePhysicalDeviceGroupsKHX
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    if (!strcmp("vkCmdProcessCommandsNVX", name)) {
-        *addr = (void *)CmdProcessCommandsNVX;
-        return true;
-    }
-    if (!strcmp("vkCmdReserveSpaceForCommandsNVX", name)) {
-        *addr = (void *)CmdReserveSpaceForCommandsNVX;
-        return true;
-    }
-    if (!strcmp("vkCreateIndirectCommandsLayoutNVX", name)) {
-        *addr = (void *)CreateIndirectCommandsLayoutNVX;
-        return true;
-    }
-    if (!strcmp("vkDestroyIndirectCommandsLayoutNVX", name)) {
-        *addr = (void *)DestroyIndirectCommandsLayoutNVX;
-        return true;
-    }
-    if (!strcmp("vkCreateObjectTableNVX", name)) {
-        *addr = (void *)CreateObjectTableNVX;
-        return true;
-    }
-    if (!strcmp("vkDestroyObjectTableNVX", name)) {
-        *addr = (void *)DestroyObjectTableNVX;
-        return true;
-    }
-    if (!strcmp("vkRegisterObjectsNVX", name)) {
-        *addr = (void *)RegisterObjectsNVX;
-        return true;
-    }
-    if (!strcmp("vkUnregisterObjectsNVX", name)) {
-        *addr = (void *)UnregisterObjectsNVX;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", name)) {
-        *addr = (void *)GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
-        return true;
-    }
-
-    // ---- VK_NV_clip_space_w_scaling extension commands
-    if (!strcmp("vkCmdSetViewportWScalingNV", name)) {
-        *addr = (void *)CmdSetViewportWScalingNV;
-        return true;
-    }
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    if (!strcmp("vkReleaseDisplayEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_direct_mode_display == 1)
-                     ? (void *)ReleaseDisplayEXT
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    if (!strcmp("vkAcquireXlibDisplayEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1)
-                     ? (void *)AcquireXlibDisplayEXT
-                     : NULL;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    if (!strcmp("vkGetRandROutputDisplayEXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1)
-                     ? (void *)GetRandROutputDisplayEXT
-                     : NULL;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2EXT", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.ext_display_surface_counter == 1)
-                     ? (void *)GetPhysicalDeviceSurfaceCapabilities2EXT
-                     : NULL;
-        return true;
-    }
-
-    // ---- VK_EXT_display_control extension commands
-    if (!strcmp("vkDisplayPowerControlEXT", name)) {
-        *addr = (void *)DisplayPowerControlEXT;
-        return true;
-    }
-    if (!strcmp("vkRegisterDeviceEventEXT", name)) {
-        *addr = (void *)RegisterDeviceEventEXT;
-        return true;
-    }
-    if (!strcmp("vkRegisterDisplayEventEXT", name)) {
-        *addr = (void *)RegisterDisplayEventEXT;
-        return true;
-    }
-    if (!strcmp("vkGetSwapchainCounterEXT", name)) {
-        *addr = (void *)GetSwapchainCounterEXT;
-        return true;
-    }
-
-    // ---- VK_GOOGLE_display_timing extension commands
-    if (!strcmp("vkGetRefreshCycleDurationGOOGLE", name)) {
-        *addr = (void *)GetRefreshCycleDurationGOOGLE;
-        return true;
-    }
-    if (!strcmp("vkGetPastPresentationTimingGOOGLE", name)) {
-        *addr = (void *)GetPastPresentationTimingGOOGLE;
-        return true;
-    }
-
-    // ---- VK_EXT_discard_rectangles extension commands
-    if (!strcmp("vkCmdSetDiscardRectangleEXT", name)) {
-        *addr = (void *)CmdSetDiscardRectangleEXT;
-        return true;
-    }
-
-    // ---- VK_EXT_hdr_metadata extension commands
-    if (!strcmp("vkSetHdrMetadataEXT", name)) {
-        *addr = (void *)SetHdrMetadataEXT;
-        return true;
-    }
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    if (!strcmp("vkCreateIOSSurfaceMVK", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.mvk_ios_surface == 1)
-                     ? (void *)CreateIOSSurfaceMVK
-                     : NULL;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    if (!strcmp("vkCreateMacOSSurfaceMVK", name)) {
-        *addr = (ptr_instance->enabled_known_extensions.mvk_macos_surface == 1)
-                     ? (void *)CreateMacOSSurfaceMVK
-                     : NULL;
-        return true;
-    }
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    if (!strcmp("vkCmdSetSampleLocationsEXT", name)) {
-        *addr = (void *)CmdSetSampleLocationsEXT;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceMultisamplePropertiesEXT", name)) {
-        *addr = (void *)GetPhysicalDeviceMultisamplePropertiesEXT;
-        return true;
-    }
-
-    // ---- VK_EXT_validation_cache extension commands
-    if (!strcmp("vkCreateValidationCacheEXT", name)) {
-        *addr = (void *)CreateValidationCacheEXT;
-        return true;
-    }
-    if (!strcmp("vkDestroyValidationCacheEXT", name)) {
-        *addr = (void *)DestroyValidationCacheEXT;
-        return true;
-    }
-    if (!strcmp("vkMergeValidationCachesEXT", name)) {
-        *addr = (void *)MergeValidationCachesEXT;
-        return true;
-    }
-    if (!strcmp("vkGetValidationCacheDataEXT", name)) {
-        *addr = (void *)GetValidationCacheDataEXT;
-        return true;
-    }
-
-    // ---- VK_EXT_external_memory_host extension commands
-    if (!strcmp("vkGetMemoryHostPointerPropertiesEXT", name)) {
-        *addr = (void *)GetMemoryHostPointerPropertiesEXT;
-        return true;
-    }
-    return false;
-}
-
-// A function that can be used to query enabled extensions during a vkCreateInstance call
-void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-        if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 = 1;
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khr_external_memory_capabilities = 1;
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khr_external_semaphore_capabilities = 1;
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khr_external_fence_capabilities = 1;
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khr_get_surface_capabilities2 = 1;
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 1;
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NN_VI_SURFACE_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.nn_vi_surface = 1;
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.khx_device_group_creation = 1;
-
-    // ---- VK_EXT_direct_mode_display extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.ext_direct_mode_display = 1;
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.ext_acquire_xlib_display = 1;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.ext_display_surface_counter = 1;
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_IOS_SURFACE_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.mvk_ios_surface = 1;
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-        } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_MVK_MACOS_SURFACE_EXTENSION_NAME)) {
-            ptr_instance->enabled_known_extensions.mvk_macos_surface = 1;
-#endif // VK_USE_PLATFORM_MACOS_MVK
-        }
-    }
-}
-
-// Some device commands still need a terminator because the loader needs to unwrap something about them.
-// In many cases, the item needing unwrapping is a VkPhysicalDevice or VkSurfaceKHR object.  But there may be other items
-// in the future.
-PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName) {
-    PFN_vkVoidFunction addr = NULL;
-
-    // ---- VK_KHR_swapchain extension commands
-    if(!strcmp(pName, "vkCreateSwapchainKHR")) {
-        addr = (PFN_vkVoidFunction)terminator_CreateSwapchainKHR;
-
-    // ---- VK_KHR_display_swapchain extension commands
-    } else if(!strcmp(pName, "vkCreateSharedSwapchainsKHR")) {
-        addr = (PFN_vkVoidFunction)terminator_CreateSharedSwapchainsKHR;
-
-    // ---- VK_EXT_debug_marker extension commands
-    } else if(!strcmp(pName, "vkDebugMarkerSetObjectTagEXT")) {
-        addr = (PFN_vkVoidFunction)terminator_DebugMarkerSetObjectTagEXT;
-    } else if(!strcmp(pName, "vkDebugMarkerSetObjectNameEXT")) {
-        addr = (PFN_vkVoidFunction)terminator_DebugMarkerSetObjectNameEXT;
-
-    // ---- VK_KHX_device_group extension commands
-    } else if(!strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHX")) {
-        addr = (PFN_vkVoidFunction)terminator_GetDeviceGroupSurfacePresentModesKHX;
-    }
-    return addr;
-}
-
-// This table contains the loader's instance dispatch table, which contains
-// default functions if no instance layers are activated.  This contains
-// pointers to "terminator functions".
-const VkLayerInstanceDispatchTable instance_disp = {
-
-    // ---- Core 1_0 commands
-    .DestroyInstance = terminator_DestroyInstance,
-    .EnumeratePhysicalDevices = terminator_EnumeratePhysicalDevices,
-    .GetPhysicalDeviceFeatures = terminator_GetPhysicalDeviceFeatures,
-    .GetPhysicalDeviceFormatProperties = terminator_GetPhysicalDeviceFormatProperties,
-    .GetPhysicalDeviceImageFormatProperties = terminator_GetPhysicalDeviceImageFormatProperties,
-    .GetPhysicalDeviceProperties = terminator_GetPhysicalDeviceProperties,
-    .GetPhysicalDeviceQueueFamilyProperties = terminator_GetPhysicalDeviceQueueFamilyProperties,
-    .GetPhysicalDeviceMemoryProperties = terminator_GetPhysicalDeviceMemoryProperties,
-    .GetInstanceProcAddr = vkGetInstanceProcAddr,
-    .EnumerateDeviceExtensionProperties = terminator_EnumerateDeviceExtensionProperties,
-    .EnumerateDeviceLayerProperties = terminator_EnumerateDeviceLayerProperties,
-    .GetPhysicalDeviceSparseImageFormatProperties = terminator_GetPhysicalDeviceSparseImageFormatProperties,
-
-    // ---- VK_KHR_surface extension commands
-    .DestroySurfaceKHR = terminator_DestroySurfaceKHR,
-    .GetPhysicalDeviceSurfaceSupportKHR = terminator_GetPhysicalDeviceSurfaceSupportKHR,
-    .GetPhysicalDeviceSurfaceCapabilitiesKHR = terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR,
-    .GetPhysicalDeviceSurfaceFormatsKHR = terminator_GetPhysicalDeviceSurfaceFormatsKHR,
-    .GetPhysicalDeviceSurfacePresentModesKHR = terminator_GetPhysicalDeviceSurfacePresentModesKHR,
-
-    // ---- VK_KHR_display extension commands
-    .GetPhysicalDeviceDisplayPropertiesKHR = terminator_GetPhysicalDeviceDisplayPropertiesKHR,
-    .GetPhysicalDeviceDisplayPlanePropertiesKHR = terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR,
-    .GetDisplayPlaneSupportedDisplaysKHR = terminator_GetDisplayPlaneSupportedDisplaysKHR,
-    .GetDisplayModePropertiesKHR = terminator_GetDisplayModePropertiesKHR,
-    .CreateDisplayModeKHR = terminator_CreateDisplayModeKHR,
-    .GetDisplayPlaneCapabilitiesKHR = terminator_GetDisplayPlaneCapabilitiesKHR,
-    .CreateDisplayPlaneSurfaceKHR = terminator_CreateDisplayPlaneSurfaceKHR,
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    .CreateXlibSurfaceKHR = terminator_CreateXlibSurfaceKHR,
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    .GetPhysicalDeviceXlibPresentationSupportKHR = terminator_GetPhysicalDeviceXlibPresentationSupportKHR,
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    .CreateXcbSurfaceKHR = terminator_CreateXcbSurfaceKHR,
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    .GetPhysicalDeviceXcbPresentationSupportKHR = terminator_GetPhysicalDeviceXcbPresentationSupportKHR,
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    .CreateWaylandSurfaceKHR = terminator_CreateWaylandSurfaceKHR,
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    .GetPhysicalDeviceWaylandPresentationSupportKHR = terminator_GetPhysicalDeviceWaylandPresentationSupportKHR,
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    .CreateMirSurfaceKHR = terminator_CreateMirSurfaceKHR,
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    .GetPhysicalDeviceMirPresentationSupportKHR = terminator_GetPhysicalDeviceMirPresentationSupportKHR,
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    .CreateAndroidSurfaceKHR = terminator_CreateAndroidSurfaceKHR,
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    .CreateWin32SurfaceKHR = terminator_CreateWin32SurfaceKHR,
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    .GetPhysicalDeviceWin32PresentationSupportKHR = terminator_GetPhysicalDeviceWin32PresentationSupportKHR,
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    .GetPhysicalDeviceFeatures2KHR = terminator_GetPhysicalDeviceFeatures2KHR,
-    .GetPhysicalDeviceProperties2KHR = terminator_GetPhysicalDeviceProperties2KHR,
-    .GetPhysicalDeviceFormatProperties2KHR = terminator_GetPhysicalDeviceFormatProperties2KHR,
-    .GetPhysicalDeviceImageFormatProperties2KHR = terminator_GetPhysicalDeviceImageFormatProperties2KHR,
-    .GetPhysicalDeviceQueueFamilyProperties2KHR = terminator_GetPhysicalDeviceQueueFamilyProperties2KHR,
-    .GetPhysicalDeviceMemoryProperties2KHR = terminator_GetPhysicalDeviceMemoryProperties2KHR,
-    .GetPhysicalDeviceSparseImageFormatProperties2KHR = terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR,
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    .GetPhysicalDeviceExternalBufferPropertiesKHR = terminator_GetPhysicalDeviceExternalBufferPropertiesKHR,
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    .GetPhysicalDeviceExternalSemaphorePropertiesKHR = terminator_GetPhysicalDeviceExternalSemaphorePropertiesKHR,
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    .GetPhysicalDeviceExternalFencePropertiesKHR = terminator_GetPhysicalDeviceExternalFencePropertiesKHR,
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    .GetPhysicalDeviceSurfaceCapabilities2KHR = terminator_GetPhysicalDeviceSurfaceCapabilities2KHR,
-    .GetPhysicalDeviceSurfaceFormats2KHR = terminator_GetPhysicalDeviceSurfaceFormats2KHR,
-
-    // ---- VK_EXT_debug_report extension commands
-    .CreateDebugReportCallbackEXT = terminator_CreateDebugReportCallbackEXT,
-    .DestroyDebugReportCallbackEXT = terminator_DestroyDebugReportCallbackEXT,
-    .DebugReportMessageEXT = terminator_DebugReportMessageEXT,
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    .GetPhysicalDeviceExternalImageFormatPropertiesNV = terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV,
-
-    // ---- VK_KHX_device_group extension commands
-    .GetPhysicalDevicePresentRectanglesKHX = terminator_GetPhysicalDevicePresentRectanglesKHX,
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    .CreateViSurfaceNN = terminator_CreateViSurfaceNN,
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    .EnumeratePhysicalDeviceGroupsKHX = terminator_EnumeratePhysicalDeviceGroupsKHX,
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    .GetPhysicalDeviceGeneratedCommandsPropertiesNVX = terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX,
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    .ReleaseDisplayEXT = terminator_ReleaseDisplayEXT,
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    .AcquireXlibDisplayEXT = terminator_AcquireXlibDisplayEXT,
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    .GetRandROutputDisplayEXT = terminator_GetRandROutputDisplayEXT,
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    .GetPhysicalDeviceSurfaceCapabilities2EXT = terminator_GetPhysicalDeviceSurfaceCapabilities2EXT,
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    .CreateIOSSurfaceMVK = terminator_CreateIOSSurfaceMVK,
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    .CreateMacOSSurfaceMVK = terminator_CreateMacOSSurfaceMVK,
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    .GetPhysicalDeviceMultisamplePropertiesEXT = terminator_GetPhysicalDeviceMultisamplePropertiesEXT,
-};
-
-// A null-terminated list of all of the instance extensions supported by the loader.
-// If an instance extension name is not in this list, but it is exported by one or more of the
-// ICDs detected by the loader, then the extension name not in the list will be filtered out
-// before passing the list of extensions to the application.
-const char *const LOADER_INSTANCE_EXTENSIONS[] = {
-                                                  VK_KHR_SURFACE_EXTENSION_NAME,
-                                                  VK_KHR_DISPLAY_EXTENSION_NAME,
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-                                                  VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-                                                  VK_KHR_XCB_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-                                                  VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-                                                  VK_KHR_MIR_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-                                                  VK_KHR_WIN32_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_WIN32_KHR
-                                                  VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
-                                                  VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
-                                                  VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME,
-                                                  VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME,
-                                                  VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,
-                                                  VK_EXT_DEBUG_REPORT_EXTENSION_NAME,
-                                                  VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME,
-                                                  VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME,
-#ifdef VK_USE_PLATFORM_VI_NN
-                                                  VK_NN_VI_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_VI_NN
-                                                  VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME,
-                                                  VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME,
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-                                                  VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-                                                  VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME,
-                                                  VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME,
-#ifdef VK_USE_PLATFORM_IOS_MVK
-                                                  VK_MVK_IOS_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_IOS_MVK
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-                                                  VK_MVK_MACOS_SURFACE_EXTENSION_NAME,
-#endif // VK_USE_PLATFORM_MACOS_MVK
-                                                  NULL };
-
diff --git a/third_party/vulkan/loader/vk_loader_extensions.h b/third_party/vulkan/loader/vk_loader_extensions.h
deleted file mode 100644
index 474adb950..000000000
--- a/third_party/vulkan/loader/vk_loader_extensions.h
+++ /dev/null
@@ -1,342 +0,0 @@
-// *** THIS FILE IS GENERATED - DO NOT EDIT ***
-// See loader_extension_generator.py for modifications
-
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Lobodzinski <mark@lunarg.com>
- * Author: Mark Young <marky@lunarg.com>
- */
-
-#pragma once
-
-// Structures defined externally, but used here
-struct loader_instance;
-struct loader_icd_term;
-struct loader_dev_dispatch_table;
-
-// Device extension error function
-VKAPI_ATTR VkResult VKAPI_CALL vkDevExtError(VkDevice dev);
-
-// Extension interception for vkGetInstanceProcAddr function, so we can return
-// the appropriate information for any instance extensions we know about.
-bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
-
-// Extension interception for vkCreateInstance function, so we can properly
-// detect and enable any instance extension information for extensions we know
-// about.
-void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
-
-// Extension interception for vkGetDeviceProcAddr function, so we can return
-// an appropriate terminator if this is one of those few device commands requiring
-// a terminator.
-PFN_vkVoidFunction get_extension_device_proc_terminator(const char *pName);
-
-// Dispatch table properly filled in with appropriate terminators for the
-// supported extensions.
-extern const VkLayerInstanceDispatchTable instance_disp;
-
-// Array of extension strings for instance extensions we support.
-extern const char *const LOADER_INSTANCE_EXTENSIONS[];
-
-VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
-                                                   const PFN_vkGetInstanceProcAddr fp_gipa);
-
-// Init Device function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_device_dispatch_table(struct loader_dev_dispatch_table *dev_table, PFN_vkGetDeviceProcAddr gpa,
-                                                             VkDevice dev);
-
-// Init Device function pointer dispatch table with extension commands
-VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct loader_dev_dispatch_table *dev_table,
-                                                                       PFN_vkGetDeviceProcAddr gpa, VkDevice dev);
-
-// Init Instance function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_instance_core_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
-                                                                    VkInstance inst);
-
-// Init Instance function pointer dispatch table with core commands
-VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayerInstanceDispatchTable *table, PFN_vkGetInstanceProcAddr gpa,
-                                                                         VkInstance inst);
-
-// Device command lookup function
-VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDispatchTable *table, const char *name);
-
-// Instance command lookup function
-VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerInstanceDispatchTable *table, const char *name,
-                                                                  bool *found_name);
-
-VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_term, VkInstance inst,
-                                                   const PFN_vkGetInstanceProcAddr fp_gipa);
-
-// Loader core instance terminators
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateInstance(
-    const VkInstanceCreateInfo*                 pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkInstance*                                 pInstance);
-VKAPI_ATTR void VKAPI_CALL terminator_DestroyInstance(
-    VkInstance                                  instance,
-    const VkAllocationCallbacks*                pAllocator);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumeratePhysicalDevices(
-    VkInstance                                  instance,
-    uint32_t*                                   pPhysicalDeviceCount,
-    VkPhysicalDevice*                           pPhysicalDevices);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceFeatures*                   pFeatures);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkFormatProperties*                         pFormatProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkImageType                                 type,
-    VkImageTiling                               tiling,
-    VkImageUsageFlags                           usage,
-    VkImageCreateFlags                          flags,
-    VkImageFormatProperties*                    pImageFormatProperties);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceProperties*                 pProperties);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties*                    pQueueFamilyProperties);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
-VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL terminator_GetInstanceProcAddr(
-    VkInstance                                  instance,
-    const char*                                 pName);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDevice(
-    VkPhysicalDevice                            physicalDevice,
-    const VkDeviceCreateInfo*                   pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDevice*                                   pDevice);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceExtensionProperties(
-    const VkEnumerateInstanceExtensionPropertiesChain* chain,
-    const char*                                 pLayerName,
-    uint32_t*                                   pPropertyCount,
-    VkExtensionProperties*                      pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceExtensionProperties(
-    VkPhysicalDevice                            physicalDevice,
-    const char*                                 pLayerName,
-    uint32_t*                                   pPropertyCount,
-    VkExtensionProperties*                      pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateInstanceLayerProperties(
-    const VkEnumerateInstanceLayerPropertiesChain* chain,
-    uint32_t*                                   pPropertyCount,
-    VkLayerProperties*                          pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_EnumerateDeviceLayerProperties(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pPropertyCount,
-    VkLayerProperties*                          pProperties);
-VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkImageType                                 type,
-    VkSampleCountFlagBits                       samples,
-    VkImageUsageFlags                           usage,
-    VkImageTiling                               tiling,
-    uint32_t*                                   pPropertyCount,
-    VkSparseImageFormatProperties*              pProperties);
-
-// ICD function pointer dispatch table
-struct loader_icd_term_dispatch {
-
-    // ---- Core 1_0 commands
-    PFN_vkCreateInstance CreateInstance;
-    PFN_vkDestroyInstance DestroyInstance;
-    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
-    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
-    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
-    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
-    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
-    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
-    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
-    PFN_vkCreateDevice CreateDevice;
-    PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
-    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
-    PFN_vkEnumerateInstanceLayerProperties EnumerateInstanceLayerProperties;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
-
-    // ---- VK_KHR_surface extension commands
-    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
-    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
-    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
-    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
-
-    // ---- VK_KHR_swapchain extension commands
-    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
-
-    // ---- VK_KHR_display extension commands
-    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR;
-    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR;
-    PFN_vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR;
-    PFN_vkCreateDisplayModeKHR CreateDisplayModeKHR;
-    PFN_vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR;
-    PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
-
-    // ---- VK_KHR_display_swapchain extension commands
-    PFN_vkCreateSharedSwapchainsKHR CreateSharedSwapchainsKHR;
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    PFN_vkCreateXlibSurfaceKHR CreateXlibSurfaceKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR GetPhysicalDeviceXlibPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    PFN_vkCreateXcbSurfaceKHR CreateXcbSurfaceKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    PFN_vkCreateWaylandSurfaceKHR CreateWaylandSurfaceKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWaylandPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkCreateWin32SurfaceKHR CreateWin32SurfaceKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR;
-    PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR;
-    PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR;
-    PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR;
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR;
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR;
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR;
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR;
-    PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR;
-
-    // ---- VK_EXT_debug_report extension commands
-    PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
-    PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
-    PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
-
-    // ---- VK_EXT_debug_marker extension commands
-    PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT;
-    PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT;
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV GetPhysicalDeviceExternalImageFormatPropertiesNV;
-
-    // ---- VK_KHX_device_group extension commands
-    PFN_vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX;
-    PFN_vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX;
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    PFN_vkCreateViSurfaceNN CreateViSurfaceNN;
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX;
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    PFN_vkReleaseDisplayEXT ReleaseDisplayEXT;
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    PFN_vkAcquireXlibDisplayEXT AcquireXlibDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    PFN_vkGetRandROutputDisplayEXT GetRandROutputDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT GetPhysicalDeviceSurfaceCapabilities2EXT;
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    PFN_vkCreateIOSSurfaceMVK CreateIOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT GetPhysicalDeviceMultisamplePropertiesEXT;
-};
-
-union loader_instance_extension_enables {
-    struct {
-        uint8_t khr_get_physical_device_properties2 : 1;
-        uint8_t khr_external_memory_capabilities : 1;
-        uint8_t khr_external_semaphore_capabilities : 1;
-        uint8_t khr_external_fence_capabilities : 1;
-        uint8_t khr_get_surface_capabilities2 : 1;
-        uint8_t ext_debug_report : 1;
-        uint8_t nv_external_memory_capabilities : 1;
-        uint8_t nn_vi_surface : 1;
-        uint8_t khx_device_group_creation : 1;
-        uint8_t ext_direct_mode_display : 1;
-        uint8_t ext_acquire_xlib_display : 1;
-        uint8_t ext_display_surface_counter : 1;
-        uint8_t mvk_ios_surface : 1;
-        uint8_t mvk_macos_surface : 1;
-    };
-    uint64_t padding[4];
-};
-
-
diff --git a/third_party/vulkan/loader/vk_loader_layer.h b/third_party/vulkan/loader/vk_loader_layer.h
deleted file mode 100644
index 425154d82..000000000
--- a/third_party/vulkan/loader/vk_loader_layer.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-*
-* Copyright (c) 2016 The Khronos Group Inc.
-* Copyright (c) 2016 Valve Corporation
-* Copyright (c) 2016 LunarG, Inc.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*
-* Author: Mark Lobodzinski <mark@lunarg.com>
-*
-*/
-#pragma once
-
-// Linked list node for tree of debug callback functions
-typedef struct VkLayerDbgFunctionNode_ {
-    VkDebugReportCallbackEXT msgCallback;
-    PFN_vkDebugReportCallbackEXT pfnMsgCallback;
-    VkFlags msgFlags;
-    void *pUserData;
-    struct VkLayerDbgFunctionNode_ *pNext;
-} VkLayerDbgFunctionNode;
diff --git a/third_party/vulkan/loader/vk_loader_platform.h b/third_party/vulkan/loader/vk_loader_platform.h
deleted file mode 100644
index 40de844eb..000000000
--- a/third_party/vulkan/loader/vk_loader_platform.h
+++ /dev/null
@@ -1,359 +0,0 @@
-/*
- *
- * Copyright (c) 2015-2018 The Khronos Group Inc.
- * Copyright (c) 2015-2018 Valve Corporation
- * Copyright (c) 2015-2018 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Ian Elliot <ian@lunarg.com>
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Lenny Komow <lenny@lunarg.com>
- *
- */
-#pragma once
-
-#if defined(_WIN32)
-// WinSock2.h must be included *BEFORE* windows.h
-#include <WinSock2.h>
-#endif  // _WIN32
-
-#include "vulkan/vk_platform.h"
-#include "vulkan/vk_sdk_platform.h"
-
-#if defined(__linux__)
-/* Linux-specific common code: */
-
-// Headers:
-//#define _GNU_SOURCE 1
-// TBD: Are the contents of the following file used?
-#include <unistd.h>
-// Note: The following file is for dynamic loading:
-#include <dlfcn.h>
-#include <pthread.h>
-#include <assert.h>
-#include <string.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <libgen.h>
-
-// VK Library Filenames, Paths, etc.:
-#define PATH_SEPARATOR ':'
-#define DIRECTORY_SYMBOL '/'
-
-#define VULKAN_DIR "/vulkan/"
-#define VULKAN_ICDCONF_DIR "icd.d"
-#define VULKAN_ICD_DIR "icd"
-#define VULKAN_ELAYERCONF_DIR "explicit_layer.d"
-#define VULKAN_ILAYERCONF_DIR "implicit_layer.d"
-#define VULKAN_LAYER_DIR "layer"
-
-#define DEFAULT_VK_DRIVERS_INFO ""
-#define DEFAULT_VK_ELAYERS_INFO ""
-#define DEFAULT_VK_ILAYERS_INFO ""
-
-#define DEFAULT_VK_DRIVERS_PATH ""
-#if !defined(DEFAULT_VK_LAYERS_PATH)
-#define DEFAULT_VK_LAYERS_PATH ""
-#endif
-
-#if !defined(LAYERS_SOURCE_PATH)
-#define LAYERS_SOURCE_PATH NULL
-#endif
-#define LAYERS_PATH_ENV "VK_LAYER_PATH"
-#define ENABLED_LAYERS_ENV "VK_INSTANCE_LAYERS"
-
-#define RELATIVE_VK_DRIVERS_INFO VULKAN_DIR VULKAN_ICDCONF_DIR
-#define RELATIVE_VK_ELAYERS_INFO VULKAN_DIR VULKAN_ELAYERCONF_DIR
-#define RELATIVE_VK_ILAYERS_INFO VULKAN_DIR VULKAN_ILAYERCONF_DIR
-
-// C99:
-#define PRINTF_SIZE_T_SPECIFIER "%zu"
-
-// File IO
-static inline bool loader_platform_file_exists(const char *path) {
-    if (access(path, F_OK))
-        return false;
-    else
-        return true;
-}
-
-static inline bool loader_platform_is_path_absolute(const char *path) {
-    if (path[0] == '/')
-        return true;
-    else
-        return false;
-}
-
-static inline char *loader_platform_dirname(char *path) { return dirname(path); }
-
-// Dynamic Loading of libraries:
-typedef void *loader_platform_dl_handle;
-static inline loader_platform_dl_handle loader_platform_open_library(const char *libPath) {
-    // When loading the library, we use RTLD_LAZY so that not all symbols have to be
-    // resolved at this time (which improves performance). Note that if not all symbols
-    // can be resolved, this could cause crashes later. Use the LD_BIND_NOW environment
-    // variable to force all symbols to be resolved here.
-    return dlopen(libPath, RTLD_LAZY | RTLD_LOCAL);
-}
-static inline const char *loader_platform_open_library_error(const char *libPath) { return dlerror(); }
-static inline void loader_platform_close_library(loader_platform_dl_handle library) { dlclose(library); }
-static inline void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) {
-    assert(library);
-    assert(name);
-    return dlsym(library, name);
-}
-static inline const char *loader_platform_get_proc_address_error(const char *name) { return dlerror(); }
-
-// Threads:
-typedef pthread_t loader_platform_thread;
-#define THREAD_LOCAL_DECL __thread
-
-// The once init functionality is not used on Linux
-#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var)
-#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var)
-#define LOADER_PLATFORM_THREAD_ONCE(ctl, func)
-
-// Thread IDs:
-typedef pthread_t loader_platform_thread_id;
-static inline loader_platform_thread_id loader_platform_get_thread_id() { return pthread_self(); }
-
-// Thread mutex:
-typedef pthread_mutex_t loader_platform_thread_mutex;
-static inline void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_init(pMutex, NULL); }
-static inline void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_lock(pMutex); }
-static inline void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_unlock(pMutex); }
-static inline void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { pthread_mutex_destroy(pMutex); }
-typedef pthread_cond_t loader_platform_thread_cond;
-static inline void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { pthread_cond_init(pCond, NULL); }
-static inline void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) {
-    pthread_cond_wait(pCond, pMutex);
-}
-static inline void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { pthread_cond_broadcast(pCond); }
-
-#define loader_stack_alloc(size) alloca(size)
-
-#elif defined(_WIN32)  // defined(__linux__)
-/* Windows-specific common code: */
-// WinBase.h defines CreateSemaphore and synchapi.h defines CreateEvent
-//  undefine them to avoid conflicts with VkLayerDispatchTable struct members.
-#ifdef CreateSemaphore
-#undef CreateSemaphore
-#endif
-#ifdef CreateEvent
-#undef CreateEvent
-#endif
-#include <assert.h>
-#include <stdio.h>
-#include <string.h>
-#include <io.h>
-#include <stdbool.h>
-#include <shlwapi.h>
-#ifdef __cplusplus
-#include <iostream>
-#include <string>
-#endif  // __cplusplus
-
-// VK Library Filenames, Paths, etc.:
-#define PATH_SEPARATOR ';'
-#define DIRECTORY_SYMBOL '\\'
-#define DEFAULT_VK_REGISTRY_HIVE HKEY_LOCAL_MACHINE
-#define DEFAULT_VK_REGISTRY_HIVE_STR "HKEY_LOCAL_MACHINE"
-#define SECONDARY_VK_REGISTRY_HIVE HKEY_CURRENT_USER
-#define SECONDARY_VK_REGISTRY_HIVE_STR "HKEY_CURRENT_USER"
-#define DEFAULT_VK_DRIVERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\Drivers"
-#define DEFAULT_VK_DRIVERS_PATH ""
-#define DEFAULT_VK_ELAYERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\ExplicitLayers"
-#define DEFAULT_VK_ILAYERS_INFO "SOFTWARE\\Khronos\\" API_NAME "\\ImplicitLayers"
-#if !defined(DEFAULT_VK_LAYERS_PATH)
-#define DEFAULT_VK_LAYERS_PATH ""
-#endif
-#if !defined(LAYERS_SOURCE_PATH)
-#define LAYERS_SOURCE_PATH NULL
-#endif
-#define LAYERS_PATH_ENV "VK_LAYER_PATH"
-#define ENABLED_LAYERS_ENV "VK_INSTANCE_LAYERS"
-#define RELATIVE_VK_DRIVERS_INFO ""
-#define RELATIVE_VK_ELAYERS_INFO ""
-#define RELATIVE_VK_ILAYERS_INFO ""
-#define PRINTF_SIZE_T_SPECIFIER "%Iu"
-
-#if defined(_WIN32)
-// Get the key for the plug n play driver registry
-// The string returned by this function should NOT be freed
-static inline const char *LoaderPnpDriverRegistry() {
-    BOOL is_wow;
-    IsWow64Process(GetCurrentProcess(), &is_wow);
-    return is_wow ? (API_NAME "DriverNameWow") : (API_NAME "DriverName");
-}
-
-// Get the key for the plug 'n play explicit layer registry
-// The string returned by this function should NOT be freed
-static inline const char *LoaderPnpELayerRegistry() {
-    BOOL is_wow;
-    IsWow64Process(GetCurrentProcess(), &is_wow);
-    return is_wow ? (API_NAME "ExplicitLayersWow") : (API_NAME "ExplicitLayers");
-}
-// Get the key for the plug 'n play implicit layer registry
-// The string returned by this function should NOT be freed
-
-static inline const char *LoaderPnpILayerRegistry() {
-    BOOL is_wow;
-    IsWow64Process(GetCurrentProcess(), &is_wow);
-    return is_wow ? (API_NAME "ImplicitLayersWow") : (API_NAME "ImplicitLayers");
-}
-#endif
-
-// File IO
-static bool loader_platform_file_exists(const char *path) {
-    if ((_access(path, 0)) == -1)
-        return false;
-    else
-        return true;
-}
-
-static bool loader_platform_is_path_absolute(const char *path) { return !PathIsRelative(path); }
-
-// WIN32 runtime doesn't have dirname().
-static inline char *loader_platform_dirname(char *path) {
-    char *current, *next;
-
-    // TODO/TBD: Do we need to deal with the Windows's ":" character?
-
-    for (current = path; *current != '\0'; current = next) {
-        next = strchr(current, DIRECTORY_SYMBOL);
-        if (next == NULL) {
-            if (current != path) *(current - 1) = '\0';
-            return path;
-        } else {
-            // Point one character past the DIRECTORY_SYMBOL:
-            next++;
-        }
-    }
-    return path;
-}
-
-// WIN32 runtime doesn't have basename().
-// Microsoft also doesn't have basename().  Paths are different on Windows, and
-// so this is just a temporary solution in order to get us compiling, so that we
-// can test some scenarios, and develop the correct solution for Windows.
-// TODO: Develop a better, permanent solution for Windows, to replace this
-// temporary code:
-static char *loader_platform_basename(char *pathname) {
-    char *current, *next;
-
-    // TODO/TBD: Do we need to deal with the Windows's ":" character?
-
-    for (current = pathname; *current != '\0'; current = next) {
-        next = strchr(current, DIRECTORY_SYMBOL);
-        if (next == NULL) {
-            // No more DIRECTORY_SYMBOL's so return p:
-            return current;
-        } else {
-            // Point one character past the DIRECTORY_SYMBOL:
-            next++;
-        }
-    }
-    // We shouldn't get to here, but this makes the compiler happy:
-    return current;
-}
-
-// Dynamic Loading:
-typedef HMODULE loader_platform_dl_handle;
-static loader_platform_dl_handle loader_platform_open_library(const char *lib_path) {
-    // Try loading the library the original way first.
-    loader_platform_dl_handle lib_handle = LoadLibrary(lib_path);
-    if (lib_handle == NULL && GetLastError() == ERROR_MOD_NOT_FOUND && PathFileExists(lib_path)) {
-        // If that failed, then try loading it with broader search folders.
-        lib_handle = LoadLibraryEx(lib_path, NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR);
-    }
-    return lib_handle;
-}
-static char *loader_platform_open_library_error(const char *libPath) {
-    static char errorMsg[164];
-    (void)snprintf(errorMsg, 163, "Failed to open dynamic library \"%s\" with error %lu", libPath, GetLastError());
-    return errorMsg;
-}
-static void loader_platform_close_library(loader_platform_dl_handle library) { FreeLibrary(library); }
-static void *loader_platform_get_proc_address(loader_platform_dl_handle library, const char *name) {
-    assert(library);
-    assert(name);
-    return GetProcAddress(library, name);
-}
-static char *loader_platform_get_proc_address_error(const char *name) {
-    static char errorMsg[120];
-    (void)snprintf(errorMsg, 119, "Failed to find function \"%s\" in dynamic library", name);
-    return errorMsg;
-}
-
-// Threads:
-typedef HANDLE loader_platform_thread;
-#define THREAD_LOCAL_DECL __declspec(thread)
-
-// The once init functionality is not used when building a DLL on Windows. This is because there is no way to clean up the
-// resources allocated by anything allocated by once init. This isn't a problem for static libraries, but it is for dynamic
-// ones. When building a DLL, we use DllMain() instead to allow properly cleaning up resources.
-#if defined(LOADER_DYNAMIC_LIB)
-#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var)
-#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var)
-#define LOADER_PLATFORM_THREAD_ONCE(ctl, func)
-#else
-#define LOADER_PLATFORM_THREAD_ONCE_DECLARATION(var) INIT_ONCE var = INIT_ONCE_STATIC_INIT;
-#define LOADER_PLATFORM_THREAD_ONCE_DEFINITION(var) INIT_ONCE var;
-#define LOADER_PLATFORM_THREAD_ONCE(ctl, func) loader_platform_thread_once_fn(ctl, func)
-static BOOL CALLBACK InitFuncWrapper(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *Context) {
-    void (*func)(void) = (void (*)(void))Parameter;
-    func();
-    return TRUE;
-}
-static void loader_platform_thread_once_fn(void *ctl, void (*func)(void)) {
-    assert(func != NULL);
-    assert(ctl != NULL);
-    InitOnceExecuteOnce((PINIT_ONCE)ctl, InitFuncWrapper, func, NULL);
-}
-#endif
-
-// Thread IDs:
-typedef DWORD loader_platform_thread_id;
-static loader_platform_thread_id loader_platform_get_thread_id() { return GetCurrentThreadId(); }
-
-// Thread mutex:
-typedef CRITICAL_SECTION loader_platform_thread_mutex;
-static void loader_platform_thread_create_mutex(loader_platform_thread_mutex *pMutex) { InitializeCriticalSection(pMutex); }
-static void loader_platform_thread_lock_mutex(loader_platform_thread_mutex *pMutex) { EnterCriticalSection(pMutex); }
-static void loader_platform_thread_unlock_mutex(loader_platform_thread_mutex *pMutex) { LeaveCriticalSection(pMutex); }
-static void loader_platform_thread_delete_mutex(loader_platform_thread_mutex *pMutex) { DeleteCriticalSection(pMutex); }
-typedef CONDITION_VARIABLE loader_platform_thread_cond;
-static void loader_platform_thread_init_cond(loader_platform_thread_cond *pCond) { InitializeConditionVariable(pCond); }
-static void loader_platform_thread_cond_wait(loader_platform_thread_cond *pCond, loader_platform_thread_mutex *pMutex) {
-    SleepConditionVariableCS(pCond, pMutex, INFINITE);
-}
-static void loader_platform_thread_cond_broadcast(loader_platform_thread_cond *pCond) { WakeAllConditionVariable(pCond); }
-
-#define loader_stack_alloc(size) _alloca(size)
-#else  // defined(_WIN32)
-
-#error The "loader_platform.h" file must be modified for this OS.
-
-// NOTE: In order to support another OS, an #elif needs to be added (above the
-// "#else // defined(_WIN32)") for that OS, and OS-specific versions of the
-// contents of this file must be created.
-
-// NOTE: Other OS-specific changes are also needed for this OS.  Search for
-// files with "WIN32" in it, as a quick way to find files that must be changed.
-
-#endif  // defined(_WIN32)
-
-// returns true if the given string appears to be a relative or absolute
-// path, as opposed to a bare filename.
-static inline bool loader_platform_is_path(const char *path) { return strchr(path, DIRECTORY_SYMBOL) != NULL; }
diff --git a/third_party/vulkan/loader/wsi.c b/third_party/vulkan/loader/wsi.c
deleted file mode 100644
index 131ca5184..000000000
--- a/third_party/vulkan/loader/wsi.c
+++ /dev/null
@@ -1,1547 +0,0 @@
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Ian Elliott <ian@lunarg.com>
- * Author: Jon Ashburn <jon@lunarg.com>
- * Author: Ian Elliott <ianelliott@google.com>
- * Author: Mark Lobodzinski <mark@lunarg.com>
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "vk_loader_platform.h"
-#include "loader.h"
-#include "wsi.h"
-#include <vulkan/vk_icd.h>
-
-// The first ICD/Loader interface that support querying the SurfaceKHR from
-// the ICDs.
-#define ICD_VER_SUPPORTS_ICD_SURFACE_KHR 3
-
-void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) {
-    ptr_instance->wsi_surface_enabled = false;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    ptr_instance->wsi_win32_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    ptr_instance->wsi_mir_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    ptr_instance->wsi_wayland_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    ptr_instance->wsi_xcb_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    ptr_instance->wsi_xlib_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    ptr_instance->wsi_android_surface_enabled = false;
-#endif  // VK_USE_PLATFORM_ANDROID_KHR
-
-    ptr_instance->wsi_display_enabled = false;
-
-    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_surface_enabled = true;
-            continue;
-        }
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WIN32_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_win32_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_MIR_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_mir_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_wayland_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XCB_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_xcb_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_XLIB_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_xlib_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_ANDROID_SURFACE_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_android_surface_enabled = true;
-            continue;
-        }
-#endif  // VK_USE_PLATFORM_ANDROID_KHR
-        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
-            ptr_instance->wsi_display_enabled = true;
-            continue;
-        }
-    }
-}
-
-// Linux WSI surface extensions are not always compiled into the loader. (Assume
-// for Windows the KHR_win32_surface is always compiled into loader). A given
-// Linux build environment might not have the headers required for building one
-// of the four extensions  (Xlib, Xcb, Mir, Wayland).  Thus, need to check if
-// the built loader actually supports the particular Linux surface extension.
-// If not supported by the built loader it will not be included in the list of
-// enumerated instance extensions.  This solves the issue where an ICD or layer
-// advertises support for a given Linux surface extension but the loader was not
-// built to support the extension.
-bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop) {
-#ifndef VK_USE_PLATFORM_MIR_KHR
-    if (!strcmp(ext_prop->extensionName, "VK_KHR_mir_surface")) return true;
-#endif  // VK_USE_PLATFORM_MIR_KHR
-#ifndef VK_USE_PLATFORM_WAYLAND_KHR
-    if (!strcmp(ext_prop->extensionName, "VK_KHR_wayland_surface")) return true;
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-#ifndef VK_USE_PLATFORM_XCB_KHR
-    if (!strcmp(ext_prop->extensionName, "VK_KHR_xcb_surface")) return true;
-#endif  // VK_USE_PLATFORM_XCB_KHR
-#ifndef VK_USE_PLATFORM_XLIB_KHR
-    if (!strcmp(ext_prop->extensionName, "VK_KHR_xlib_surface")) return true;
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-
-    return false;
-}
-
-// Functions for the VK_KHR_surface extension:
-
-// This is the trampoline entrypoint for DestroySurfaceKHR
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                                                             const VkAllocationCallbacks *pAllocator) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    disp->DestroySurfaceKHR(instance, surface, pAllocator);
-}
-
-// TODO probably need to lock around all the loader_get_instance() calls.
-
-// This is the instance chain terminator function for DestroySurfaceKHR
-VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                                                        const VkAllocationCallbacks *pAllocator) {
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface) {
-        if (NULL != icd_surface->real_icd_surfaces) {
-            uint32_t i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-                    if (NULL != icd_term->dispatch.DestroySurfaceKHR && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[i]) {
-                        icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, icd_surface->real_icd_surfaces[i], pAllocator);
-                        icd_surface->real_icd_surfaces[i] = (VkSurfaceKHR)NULL;
-                    }
-                } else {
-                    // The real_icd_surface for any ICD not supporting the
-                    // proper interface version should be NULL.  If not, then
-                    // we have a problem.
-                    assert((VkSurfaceKHR)NULL == icd_surface->real_icd_surfaces[i]);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, icd_surface->real_icd_surfaces);
-        }
-
-        loader_instance_heap_free(ptr_instance, (void *)(uintptr_t)surface);
-    }
-}
-
-// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                  uint32_t queueFamilyIndex, VkSurfaceKHR surface,
-                                                                                  VkBool32 *pSupported) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceSupportKHR(unwrapped_phys_dev, queueFamilyIndex, surface, pSupported);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceSurfaceSupportKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                             uint32_t queueFamilyIndex, VkSurfaceKHR surface,
-                                                                             VkBool32 *pSupported) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  vkGetPhysicalDeviceSurfaceSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == pSupported) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceSupportKHR for pSupported!\n");
-        assert(false && "GetPhysicalDeviceSurfaceSupportKHR: Error, null pSupported");
-    }
-    *pSupported = false;
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceSurfaceSupportKHR ICD pointer");
-    }
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR(
-            phys_dev_term->phys_dev, queueFamilyIndex, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSupported);
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceSurfaceSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, surface, pSupported);
-}
-
-// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceCapabilitiesKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-    VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
-    const VkLayerInstanceDispatchTable *disp;
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceCapabilitiesKHR(unwrapped_phys_dev, surface, pSurfaceCapabilities);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceSurfaceCapabilitiesKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                  VkSurfaceKHR surface,
-                                                                                  VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == pSurfaceCapabilities) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceCapabilitiesKHR for pSurfaceCapabilities!\n");
-        assert(false && "GetPhysicalDeviceSurfaceCapabilitiesKHR: Error, null pSurfaceCapabilities");
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceCapabilitiesKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceSurfaceCapabilitiesKHR ICD pointer");
-    }
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(
-            phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pSurfaceCapabilities);
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(phys_dev_term->phys_dev, surface, pSurfaceCapabilities);
-}
-
-// This is the trampoline entrypoint for GetPhysicalDeviceSurfaceFormatsKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice,
-                                                                                  VkSurfaceKHR surface,
-                                                                                  uint32_t *pSurfaceFormatCount,
-                                                                                  VkSurfaceFormatKHR *pSurfaceFormats) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfaceFormatsKHR(unwrapped_phys_dev, surface, pSurfaceFormatCount, pSurfaceFormats);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceSurfaceFormatsKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                             uint32_t *pSurfaceFormatCount,
-                                                                             VkSurfaceFormatKHR *pSurfaceFormats) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  vkGetPhysicalDeviceSurfaceFormatsKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == pSurfaceFormatCount) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "NULL pointer passed into vkGetPhysicalDeviceSurfaceFormatsKHR for pSurfaceFormatCount!\n");
-        assert(false && "GetPhysicalDeviceSurfaceFormatsKHR(: Error, null pSurfaceFormatCount");
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfaceCapabilitiesKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceSurfaceFormatsKHR ICD pointer");
-    }
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev,
-                                                                     icd_surface->real_icd_surfaces[phys_dev_term->icd_index],
-                                                                     pSurfaceFormatCount, pSurfaceFormats);
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceSurfaceFormatsKHR(phys_dev_term->phys_dev, surface, pSurfaceFormatCount,
-                                                                 pSurfaceFormats);
-}
-
-// This is the trampoline entrypoint for GetPhysicalDeviceSurfacePresentModesKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
-                                                                                       VkSurfaceKHR surface,
-                                                                                       uint32_t *pPresentModeCount,
-                                                                                       VkPresentModeKHR *pPresentModes) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceSurfacePresentModesKHR(unwrapped_phys_dev, surface, pPresentModeCount, pPresentModes);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceSurfacePresentModesKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
-                                                                                  VkSurfaceKHR surface, uint32_t *pPresentModeCount,
-                                                                                  VkPresentModeKHR *pPresentModes) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  vkGetPhysicalDeviceSurfacePresentModesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == pPresentModeCount) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "NULL pointer passed into vkGetPhysicalDeviceSurfacePresentModesKHR for pPresentModeCount!\n");
-        assert(false && "GetPhysicalDeviceSurfacePresentModesKHR(: Error, null pPresentModeCount");
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceSurfacePresentModesKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceSurfacePresentModesKHR ICD pointer");
-    }
-
-    VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)surface;
-    if (NULL != icd_surface->real_icd_surfaces && (VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[phys_dev_term->icd_index]) {
-        return icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR(
-            phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[phys_dev_term->icd_index], pPresentModeCount, pPresentModes);
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceSurfacePresentModesKHR(phys_dev_term->phys_dev, surface, pPresentModeCount,
-                                                                      pPresentModes);
-}
-
-// Functions for the VK_KHR_swapchain extension:
-
-// This is the trampoline entrypoint for CreateSwapchainKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-                                                                  const VkAllocationCallbacks *pAllocator,
-                                                                  VkSwapchainKHR *pSwapchain) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    return disp->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-                                                             const VkAllocationCallbacks *pAllocator,
-                                                             VkSwapchainKHR *pSwapchain) {
-    uint32_t icd_index = 0;
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
-    if (NULL != icd_term && NULL != icd_term->dispatch.CreateSwapchainKHR) {
-        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfo->surface;
-        if (NULL != icd_surface->real_icd_surfaces) {
-            if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
-                // We found the ICD, and there is an ICD KHR surface
-                // associated with it, so copy the CreateInfo struct
-                // and point it at the ICD's surface.
-                VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR));
-                if (NULL == pCreateCopy) {
-                    return VK_ERROR_OUT_OF_HOST_MEMORY;
-                }
-                memcpy(pCreateCopy, pCreateInfo, sizeof(VkSwapchainCreateInfoKHR));
-                pCreateCopy->surface = icd_surface->real_icd_surfaces[icd_index];
-                return icd_term->dispatch.CreateSwapchainKHR(device, pCreateCopy, pAllocator, pSwapchain);
-            }
-        }
-        return icd_term->dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
-    }
-    return VK_SUCCESS;
-}
-
-// This is the trampoline entrypoint for DestroySwapchainKHR
-LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
-                                                               const VkAllocationCallbacks *pAllocator) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    disp->DestroySwapchainKHR(device, swapchain, pAllocator);
-}
-
-// This is the trampoline entrypoint for GetSwapchainImagesKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
-                                                                     uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    return disp->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
-}
-
-// This is the trampoline entrypoint for AcquireNextImageKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
-                                                                   VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    return disp->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
-}
-
-// This is the trampoline entrypoint for QueuePresentKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(queue);
-    return disp->QueuePresentKHR(queue, pPresentInfo);
-}
-
-static VkIcdSurface *AllocateIcdSurfaceStruct(struct loader_instance *instance, size_t base_size, size_t platform_size) {
-    // Next, if so, proceed with the implementation of this function:
-    VkIcdSurface *pIcdSurface = loader_instance_heap_alloc(instance, sizeof(VkIcdSurface), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    if (pIcdSurface != NULL) {
-        // Setup the new sizes and offsets so we can grow the structures in the
-        // future without having problems
-        pIcdSurface->base_size = (uint32_t)base_size;
-        pIcdSurface->platform_size = (uint32_t)platform_size;
-        pIcdSurface->non_platform_offset = (uint32_t)((uint8_t *)(&pIcdSurface->base_size) - (uint8_t *)pIcdSurface);
-        pIcdSurface->entire_size = sizeof(VkIcdSurface);
-
-        pIcdSurface->real_icd_surfaces = loader_instance_heap_alloc(instance, sizeof(VkSurfaceKHR) * instance->total_icd_count,
-                                                                    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-        if (pIcdSurface->real_icd_surfaces == NULL) {
-            loader_instance_heap_free(instance, pIcdSurface);
-            pIcdSurface = NULL;
-        } else {
-            memset(pIcdSurface->real_icd_surfaces, 0, sizeof(VkSurfaceKHR) * instance->total_icd_count);
-        }
-    }
-    return pIcdSurface;
-}
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-
-// Functions for the VK_KHR_win32_surface extension:
-
-// This is the trampoline entrypoint for CreateWin32SurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(VkInstance instance,
-                                                                     const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                                                                     const VkAllocationCallbacks *pAllocator,
-                                                                     VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateWin32SurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    VkResult vkRes = VK_SUCCESS;
-    VkIcdSurface *pIcdSurface = NULL;
-    uint32_t i = 0;
-
-    // Initialize pSurface to NULL just to be safe.
-    *pSurface = VK_NULL_HANDLE;
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_win32_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_win32_surface extension not enabled.  vkCreateWin32SurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->win_surf.base), sizeof(pIcdSurface->win_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->win_surf.base.platform = VK_ICD_WSI_PLATFORM_WIN32;
-    pIcdSurface->win_surf.hinstance = pCreateInfo->hinstance;
-    pIcdSurface->win_surf.hwnd = pCreateInfo->hwnd;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateWin32SurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateWin32SurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                                 &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)(pIcdSurface);
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(ptr_instance, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// This is the trampoline entrypoint for
-// GetPhysicalDeviceWin32PresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                            uint32_t queueFamilyIndex) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceWin32PresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceWin32PresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                       uint32_t queueFamilyIndex) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_win32_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_win32_surface extension not enabled.  vkGetPhysicalDeviceWin32PresentationSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceWin32PresentationSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceWin32PresentationSupportKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceWin32PresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex);
-}
-#endif  // VK_USE_PLATFORM_WIN32_KHR
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-
-// Functions for the VK_KHR_mir_surface extension:
-
-// This is the trampoline entrypoint for CreateMirSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(VkInstance instance,
-                                                                   const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-                                                                   const VkAllocationCallbacks *pAllocator,
-                                                                   VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateMirSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    VkResult vkRes = VK_SUCCESS;
-    VkIcdSurface *pIcdSurface = NULL;
-    uint32_t i = 0;
-
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_mir_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_mir_surface extension not enabled.  vkCreateMirSurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->mir_surf.base), sizeof(pIcdSurface->mir_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->mir_surf.base.platform = VK_ICD_WSI_PLATFORM_MIR;
-    pIcdSurface->mir_surf.connection = pCreateInfo->connection;
-    pIcdSurface->mir_surf.mirSurface = pCreateInfo->mirSurface;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateMirSurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateMirSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                               &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(ptr_instance, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// This is the trampoline entrypoint for
-// GetPhysicalDeviceMirPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                          uint32_t queueFamilyIndex,
-                                                                                          MirConnection *connection) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceMirPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceMirPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t queueFamilyIndex,
-                                                                                     MirConnection *connection) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_mir_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_mir_surface extension not enabled.  vkGetPhysicalDeviceMirPresentationSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceMirPresentationSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceMirPresentationSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceMirPresentationSupportKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceMirPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection);
-}
-#endif  // VK_USE_PLATFORM_MIR_KHR
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-
-// This is the trampoline entrypoint for CreateWaylandSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(VkInstance instance,
-                                                                       const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateWaylandSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance,
-                                                                  const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    VkResult vkRes = VK_SUCCESS;
-    VkIcdSurface *pIcdSurface = NULL;
-    uint32_t i = 0;
-
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_wayland_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_wayland_surface extension not enabled.  vkCreateWaylandSurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->wayland_surf.base), sizeof(pIcdSurface->wayland_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->wayland_surf.base.platform = VK_ICD_WSI_PLATFORM_WAYLAND;
-    pIcdSurface->wayland_surf.display = pCreateInfo->display;
-    pIcdSurface->wayland_surf.surface = pCreateInfo->surface;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateWaylandSurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateWaylandSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                                   &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(ptr_instance, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// This is the trampoline entrypoint for
-// GetPhysicalDeviceWaylandPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                              uint32_t queueFamilyIndex,
-                                                                                              struct wl_display *display) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceWaylandPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, display);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceWaylandPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                         uint32_t queueFamilyIndex,
-                                                                                         struct wl_display *display) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_wayland_surface_enabled) {
-        loader_log(
-            ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-            "VK_KHR_wayland_surface extension not enabled.  vkGetPhysicalDeviceWaylandPresentationSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceWaylandPresentationSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceWaylandPresentationSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceWaylandPresentationSupportKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceWaylandPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, display);
-}
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-
-// Functions for the VK_KHR_xcb_surface extension:
-
-// This is the trampoline entrypoint for CreateXcbSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(VkInstance instance,
-                                                                   const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                                                                   const VkAllocationCallbacks *pAllocator,
-                                                                   VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateXcbSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    VkResult vkRes = VK_SUCCESS;
-    VkIcdSurface *pIcdSurface = NULL;
-    uint32_t i = 0;
-
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_xcb_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xcb_surface extension not enabled.  vkCreateXcbSurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xcb_surf.base), sizeof(pIcdSurface->xcb_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->xcb_surf.base.platform = VK_ICD_WSI_PLATFORM_XCB;
-    pIcdSurface->xcb_surf.connection = pCreateInfo->connection;
-    pIcdSurface->xcb_surf.window = pCreateInfo->window;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateXcbSurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateXcbSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                               &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(ptr_instance, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// This is the trampoline entrypoint for
-// GetPhysicalDeviceXcbPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                          uint32_t queueFamilyIndex,
-                                                                                          xcb_connection_t *connection,
-                                                                                          xcb_visualid_t visual_id) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceXcbPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, connection, visual_id);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceXcbPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t queueFamilyIndex,
-                                                                                     xcb_connection_t *connection,
-                                                                                     xcb_visualid_t visual_id) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_xcb_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xcb_surface extension not enabled.  vkGetPhysicalDeviceXcbPresentationSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceXcbPresentationSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceXcbPresentationSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceXcbPresentationSupportKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceXcbPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, connection,
-                                                                         visual_id);
-}
-#endif  // VK_USE_PLATFORM_XCB_KHR
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-
-// Functions for the VK_KHR_xlib_surface extension:
-
-// This is the trampoline entrypoint for CreateXlibSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(VkInstance instance,
-                                                                    const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateXlibSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    VkResult vkRes = VK_SUCCESS;
-    VkIcdSurface *pIcdSurface = NULL;
-    uint32_t i = 0;
-
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_xlib_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xlib_surface extension not enabled.  vkCreateXlibSurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(ptr_instance, sizeof(pIcdSurface->xlib_surf.base), sizeof(pIcdSurface->xlib_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->xlib_surf.base.platform = VK_ICD_WSI_PLATFORM_XLIB;
-    pIcdSurface->xlib_surf.dpy = pCreateInfo->dpy;
-    pIcdSurface->xlib_surf.window = pCreateInfo->window;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateXlibSurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateXlibSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                                &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = ptr_instance->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(ptr_instance, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(ptr_instance, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// This is the trampoline entrypoint for
-// GetPhysicalDeviceXlibPresentationSupportKHR
-LOADER_EXPORT VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                           uint32_t queueFamilyIndex, Display *dpy,
-                                                                                           VisualID visualID) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkBool32 res = disp->GetPhysicalDeviceXlibPresentationSupportKHR(unwrapped_phys_dev, queueFamilyIndex, dpy, visualID);
-    return res;
-}
-
-// This is the instance chain terminator function for
-// GetPhysicalDeviceXlibPresentationSupportKHR
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                      uint32_t queueFamilyIndex, Display *dpy,
-                                                                                      VisualID visualID) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_xlib_surface_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_xlib_surface extension not enabled.  vkGetPhysicalDeviceXlibPresentationSupportKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceXlibPresentationSupportKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceXlibPresentationSupportKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceXlibPresentationSupportKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceXlibPresentationSupportKHR(phys_dev_term->phys_dev, queueFamilyIndex, dpy, visualID);
-}
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-
-// Functions for the VK_KHR_android_surface extension:
-
-// This is the trampoline entrypoint for CreateAndroidSurfaceKHR
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(VkInstance instance, ANativeWindow *window,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateAndroidSurfaceKHR(instance, window, pAllocator, pSurface);
-    return res;
-}
-
-// This is the instance chain terminator function for CreateAndroidSurfaceKHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateAndroidSurfaceKHR(VkInstance instance, Window window,
-                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_instance *ptr_instance = loader_get_instance(instance);
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkCreateAndroidSurfaceKHR not executed!\n");
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    VkIcdSurfaceAndroid *pIcdSurface =
-        loader_instance_heap_alloc(ptr_instance, sizeof(VkIcdSurfaceAndroid), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
-    if (pIcdSurface == NULL) {
-        return VK_ERROR_OUT_OF_HOST_MEMORY;
-    }
-
-    pIcdSurface->base.platform = VK_ICD_WSI_PLATFORM_ANDROID;
-    pIcdSurface->dpy = dpy;
-    pIcdSurface->window = window;
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-    return VK_SUCCESS;
-}
-
-#endif  // VK_USE_PLATFORM_ANDROID_KHR
-
-// Functions for the VK_KHR_display instance extension:
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t *pPropertyCount,
-                                                                                     VkDisplayPropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceDisplayPropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                uint32_t *pPropertyCount,
-                                                                                VkDisplayPropertiesKHR *pProperties) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkGetPhysicalDeviceDisplayPropertiesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceDisplayPropertiesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceDisplayPropertiesKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceDisplayPropertiesKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceDisplayPropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkDisplayPlanePropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetPhysicalDeviceDisplayPlanePropertiesKHR(unwrapped_phys_dev, pPropertyCount, pProperties);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t *pPropertyCount,
-                                                                                     VkDisplayPlanePropertiesKHR *pProperties) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkGetPhysicalDeviceDisplayPlanePropertiesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetPhysicalDeviceDisplayPlanePropertiesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetPhysicalDeviceDisplayPlanePropertiesKHR!\n");
-        assert(false && "loader: null GetPhysicalDeviceDisplayPlanePropertiesKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetPhysicalDeviceDisplayPlanePropertiesKHR(phys_dev_term->phys_dev, pPropertyCount, pProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice,
-                                                                                   uint32_t planeIndex, uint32_t *pDisplayCount,
-                                                                                   VkDisplayKHR *pDisplays) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayPlaneSupportedDisplaysKHR(unwrapped_phys_dev, planeIndex, pDisplayCount, pDisplays);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-                                                                              uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkGetDisplayPlaneSupportedDisplaysKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetDisplayPlaneSupportedDisplaysKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetDisplayPlaneSupportedDisplaysKHR!\n");
-        assert(false && "loader: null GetDisplayPlaneSupportedDisplaysKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetDisplayPlaneSupportedDisplaysKHR(phys_dev_term->phys_dev, planeIndex, pDisplayCount, pDisplays);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                                           uint32_t *pPropertyCount,
-                                                                           VkDisplayModePropertiesKHR *pProperties) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayModePropertiesKHR(unwrapped_phys_dev, display, pPropertyCount, pProperties);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                                      uint32_t *pPropertyCount,
-                                                                      VkDisplayModePropertiesKHR *pProperties) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkGetDisplayModePropertiesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetDisplayModePropertiesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetDisplayModePropertiesKHR!\n");
-        assert(false && "loader: null GetDisplayModePropertiesKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetDisplayModePropertiesKHR(phys_dev_term->phys_dev, display, pPropertyCount, pProperties);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                                    const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkDisplayModeKHR *pMode) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->CreateDisplayModeKHR(unwrapped_phys_dev, display, pCreateInfo, pAllocator, pMode);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                               const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkCreateDisplayModeKHR not executed!\n");
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    }
-
-    if (NULL == icd_term->dispatch.CreateDisplayModeKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkCreateDisplayModeKHR!\n");
-        assert(false && "loader: null CreateDisplayModeKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.CreateDisplayModeKHR(phys_dev_term->phys_dev, display, pCreateInfo, pAllocator, pMode);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-                                                                              VkDisplayModeKHR mode, uint32_t planeIndex,
-                                                                              VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
-    VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice);
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(physicalDevice);
-    VkResult res = disp->GetDisplayPlaneCapabilitiesKHR(unwrapped_phys_dev, mode, planeIndex, pCapabilities);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
-                                                                         uint32_t planeIndex,
-                                                                         VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
-    // First, check to ensure the appropriate extension was enabled:
-    struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice;
-    struct loader_icd_term *icd_term = phys_dev_term->this_icd_term;
-    struct loader_instance *ptr_instance = (struct loader_instance *)icd_term->this_instance;
-    if (!ptr_instance->wsi_display_enabled) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_display extension not enabled.  vkGetDisplayPlaneCapabilitiesKHR not executed!\n");
-        return VK_SUCCESS;
-    }
-
-    if (NULL == icd_term->dispatch.GetDisplayPlaneCapabilitiesKHR) {
-        loader_log(ptr_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "ICD for selected physical device is not exporting vkGetDisplayPlaneCapabilitiesKHR!\n");
-        assert(false && "loader: null GetDisplayPlaneCapabilitiesKHR ICD pointer");
-    }
-
-    return icd_term->dispatch.GetDisplayPlaneCapabilitiesKHR(phys_dev_term->phys_dev, mode, planeIndex, pCapabilities);
-}
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(VkInstance instance,
-                                                                            const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-                                                                            const VkAllocationCallbacks *pAllocator,
-                                                                            VkSurfaceKHR *pSurface) {
-    const VkLayerInstanceDispatchTable *disp;
-    disp = loader_get_instance_layer_dispatch(instance);
-    VkResult res;
-
-    res = disp->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
-    return res;
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance,
-                                                                       const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkSurfaceKHR *pSurface) {
-    struct loader_instance *inst = loader_get_instance(instance);
-    VkIcdSurface *pIcdSurface = NULL;
-    VkResult vkRes = VK_SUCCESS;
-    uint32_t i = 0;
-
-    if (!inst->wsi_display_enabled) {
-        loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
-                   "VK_KHR_surface extension not enabled.  vkCreateDisplayPlaneSurfaceKHR not executed!\n");
-        vkRes = VK_ERROR_EXTENSION_NOT_PRESENT;
-        goto out;
-    }
-
-    // Next, if so, proceed with the implementation of this function:
-    pIcdSurface = AllocateIcdSurfaceStruct(inst, sizeof(pIcdSurface->display_surf.base), sizeof(pIcdSurface->display_surf));
-    if (pIcdSurface == NULL) {
-        vkRes = VK_ERROR_OUT_OF_HOST_MEMORY;
-        goto out;
-    }
-
-    pIcdSurface->display_surf.base.platform = VK_ICD_WSI_PLATFORM_DISPLAY;
-    pIcdSurface->display_surf.displayMode = pCreateInfo->displayMode;
-    pIcdSurface->display_surf.planeIndex = pCreateInfo->planeIndex;
-    pIcdSurface->display_surf.planeStackIndex = pCreateInfo->planeStackIndex;
-    pIcdSurface->display_surf.transform = pCreateInfo->transform;
-    pIcdSurface->display_surf.globalAlpha = pCreateInfo->globalAlpha;
-    pIcdSurface->display_surf.alphaMode = pCreateInfo->alphaMode;
-    pIcdSurface->display_surf.imageExtent = pCreateInfo->imageExtent;
-
-    // Loop through each ICD and determine if they need to create a surface
-    for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-        if (icd_term->scanned_icd->interface_version >= ICD_VER_SUPPORTS_ICD_SURFACE_KHR) {
-            if (NULL != icd_term->dispatch.CreateDisplayPlaneSurfaceKHR) {
-                vkRes = icd_term->dispatch.CreateDisplayPlaneSurfaceKHR(icd_term->instance, pCreateInfo, pAllocator,
-                                                                        &pIcdSurface->real_icd_surfaces[i]);
-                if (VK_SUCCESS != vkRes) {
-                    goto out;
-                }
-            }
-        }
-    }
-
-    *pSurface = (VkSurfaceKHR)pIcdSurface;
-
-out:
-
-    if (VK_SUCCESS != vkRes && NULL != pIcdSurface) {
-        if (NULL != pIcdSurface->real_icd_surfaces) {
-            i = 0;
-            for (struct loader_icd_term *icd_term = inst->icd_terms; icd_term != NULL; icd_term = icd_term->next, i++) {
-                if ((VkSurfaceKHR)NULL != pIcdSurface->real_icd_surfaces[i] && NULL != icd_term->dispatch.DestroySurfaceKHR) {
-                    icd_term->dispatch.DestroySurfaceKHR(icd_term->instance, pIcdSurface->real_icd_surfaces[i], pAllocator);
-                }
-            }
-            loader_instance_heap_free(inst, pIcdSurface->real_icd_surfaces);
-        }
-        loader_instance_heap_free(inst, pIcdSurface);
-    }
-
-    return vkRes;
-}
-
-// EXT_display_swapchain Extension command
-
-LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
-                                                                         const VkSwapchainCreateInfoKHR *pCreateInfos,
-                                                                         const VkAllocationCallbacks *pAllocator,
-                                                                         VkSwapchainKHR *pSwapchains) {
-    const VkLayerDispatchTable *disp;
-    disp = loader_get_dispatch(device);
-    return disp->CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
-                                                                    const VkSwapchainCreateInfoKHR *pCreateInfos,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkSwapchainKHR *pSwapchains) {
-    uint32_t icd_index = 0;
-    struct loader_device *dev;
-    struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index);
-    if (NULL != icd_term && NULL != icd_term->dispatch.CreateSharedSwapchainsKHR) {
-        VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pCreateInfos->surface;
-        if (NULL != icd_surface->real_icd_surfaces) {
-            if ((VkSurfaceKHR)NULL != icd_surface->real_icd_surfaces[icd_index]) {
-                // We found the ICD, and there is an ICD KHR surface
-                // associated with it, so copy the CreateInfo struct
-                // and point it at the ICD's surface.
-                VkSwapchainCreateInfoKHR *pCreateCopy = loader_stack_alloc(sizeof(VkSwapchainCreateInfoKHR) * swapchainCount);
-                if (NULL == pCreateCopy) {
-                    return VK_ERROR_OUT_OF_HOST_MEMORY;
-                }
-                memcpy(pCreateCopy, pCreateInfos, sizeof(VkSwapchainCreateInfoKHR) * swapchainCount);
-                for (uint32_t sc = 0; sc < swapchainCount; sc++) {
-                    pCreateCopy[sc].surface = icd_surface->real_icd_surfaces[icd_index];
-                }
-                return icd_term->dispatch.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateCopy, pAllocator, pSwapchains);
-            }
-        }
-        return icd_term->dispatch.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
-    }
-    return VK_SUCCESS;
-}
-
-bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) {
-    *addr = NULL;
-
-    // Functions for the VK_KHR_surface extension:
-    if (!strcmp("vkDestroySurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkDestroySurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceSupportKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceCapabilitiesKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSurfaceFormatsKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfaceFormatsKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceSurfacePresentModesKHR", name)) {
-        *addr = ptr_instance->wsi_surface_enabled ? (void *)vkGetPhysicalDeviceSurfacePresentModesKHR : NULL;
-        return true;
-    }
-
-    // Functions for the VK_KHR_swapchain extension:
-
-    // Note: This is a device extension, and its functions are statically
-    // exported from the loader.  Per Khronos decisions, the loader's GIPA
-    // function will return the trampoline function for such device-extension
-    // functions, regardless of whether the extension has been enabled.
-    if (!strcmp("vkCreateSwapchainKHR", name)) {
-        *addr = (void *)vkCreateSwapchainKHR;
-        return true;
-    }
-    if (!strcmp("vkDestroySwapchainKHR", name)) {
-        *addr = (void *)vkDestroySwapchainKHR;
-        return true;
-    }
-    if (!strcmp("vkGetSwapchainImagesKHR", name)) {
-        *addr = (void *)vkGetSwapchainImagesKHR;
-        return true;
-    }
-    if (!strcmp("vkAcquireNextImageKHR", name)) {
-        *addr = (void *)vkAcquireNextImageKHR;
-        return true;
-    }
-    if (!strcmp("vkQueuePresentKHR", name)) {
-        *addr = (void *)vkQueuePresentKHR;
-        return true;
-    }
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-
-    // Functions for the VK_KHR_win32_surface extension:
-    if (!strcmp("vkCreateWin32SurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkCreateWin32SurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceWin32PresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_win32_surface_enabled ? (void *)vkGetPhysicalDeviceWin32PresentationSupportKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-
-    // Functions for the VK_KHR_mir_surface extension:
-    if (!strcmp("vkCreateMirSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkCreateMirSurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceMirPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_mir_surface_enabled ? (void *)vkGetPhysicalDeviceMirPresentationSupportKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-
-    // Functions for the VK_KHR_wayland_surface extension:
-    if (!strcmp("vkCreateWaylandSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkCreateWaylandSurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceWaylandPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_wayland_surface_enabled ? (void *)vkGetPhysicalDeviceWaylandPresentationSupportKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-
-    // Functions for the VK_KHR_xcb_surface extension:
-    if (!strcmp("vkCreateXcbSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkCreateXcbSurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceXcbPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_xcb_surface_enabled ? (void *)vkGetPhysicalDeviceXcbPresentationSupportKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-
-    // Functions for the VK_KHR_xlib_surface extension:
-    if (!strcmp("vkCreateXlibSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateXlibSurfaceKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceXlibPresentationSupportKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkGetPhysicalDeviceXlibPresentationSupportKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-
-    // Functions for the VK_KHR_android_surface extension:
-    if (!strcmp("vkCreateAndroidSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_xlib_surface_enabled ? (void *)vkCreateAndroidSurfaceKHR : NULL;
-        return true;
-    }
-#endif  // VK_USE_PLATFORM_ANDROID_KHR
-
-    // Functions for VK_KHR_display extension:
-    if (!strcmp("vkGetPhysicalDeviceDisplayPropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPropertiesKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetPhysicalDeviceDisplayPlanePropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetPhysicalDeviceDisplayPlanePropertiesKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetDisplayPlaneSupportedDisplaysKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneSupportedDisplaysKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetDisplayModePropertiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayModePropertiesKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkCreateDisplayModeKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayModeKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkGetDisplayPlaneCapabilitiesKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkGetDisplayPlaneCapabilitiesKHR : NULL;
-        return true;
-    }
-    if (!strcmp("vkCreateDisplayPlaneSurfaceKHR", name)) {
-        *addr = ptr_instance->wsi_display_enabled ? (void *)vkCreateDisplayPlaneSurfaceKHR : NULL;
-        return true;
-    }
-
-    // Functions for KHR_display_swapchain extension:
-    if (!strcmp("vkCreateSharedSwapchainsKHR", name)) {
-        *addr = (void *)vkCreateSharedSwapchainsKHR;
-        return true;
-    }
-
-    return false;
-}
diff --git a/third_party/vulkan/loader/wsi.h b/third_party/vulkan/loader/wsi.h
deleted file mode 100644
index 519a7aacc..000000000
--- a/third_party/vulkan/loader/wsi.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Ian Elliott <ian@lunarg.com>
- *
- */
-
-#ifndef WSI_H
-#define WSI_H
-
-#include "vk_loader_platform.h"
-#include "loader.h"
-
-typedef struct {
-    union {
-#ifdef VK_USE_PLATFORM_MIR_KHR
-        VkIcdSurfaceMir mir_surf;
-#endif  // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-        VkIcdSurfaceWayland wayland_surf;
-#endif  // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-        VkIcdSurfaceWin32 win_surf;
-#endif  // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-        VkIcdSurfaceXcb xcb_surf;
-#endif  // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-        VkIcdSurfaceXlib xlib_surf;
-#endif  // VK_USE_PLATFORM_XLIB_KHR
-        VkIcdSurfaceDisplay display_surf;
-    };
-    uint32_t base_size;            // Size of VkIcdSurfaceBase
-    uint32_t platform_size;        // Size of corresponding VkIcdSurfaceXXX
-    uint32_t non_platform_offset;  // Start offset to base_size
-    uint32_t entire_size;          // Size of entire VkIcdSurface
-    VkSurfaceKHR *real_icd_surfaces;
-} VkIcdSurface;
-
-bool wsi_swapchain_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr);
-
-void wsi_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo);
-bool wsi_unsupported_instance_extension(const VkExtensionProperties *ext_prop);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-                                                             const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
-
-VKAPI_ATTR void VKAPI_CALL terminator_DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                                                        const VkAllocationCallbacks *pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                             uint32_t queueFamilyIndex, VkSurfaceKHR surface,
-                                                                             VkBool32 *pSupported);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                  VkSurfaceKHR surface,
-                                                                                  VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                             uint32_t *pSurfaceFormatCount,
-                                                                             VkSurfaceFormatKHR *pSurfaceFormats);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
-                                                                                  VkSurfaceKHR surface, uint32_t *pPresentModeCount,
-                                                                                  VkPresentModeKHR *pPresentModes);
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                       uint32_t queueFamilyIndex);
-#endif
-#ifdef VK_USE_PLATFORM_MIR_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t queueFamilyIndex,
-                                                                                     MirConnection *connection);
-#endif
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateWaylandSurfaceKHR(VkInstance instance,
-                                                                  const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-                                                                  const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                         uint32_t queueFamilyIndex,
-                                                                                         struct wl_display *display);
-#endif
-#ifdef VK_USE_PLATFORM_XCB_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                                                              const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t queueFamilyIndex,
-                                                                                     xcb_connection_t *connection,
-                                                                                     xcb_visualid_t visual_id);
-#endif
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VKAPI_ATTR VkBool32 VKAPI_CALL terminator_GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
-                                                                                      uint32_t queueFamilyIndex, Display *dpy,
-                                                                                      VisualID visualID);
-#endif
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                uint32_t *pPropertyCount,
-                                                                                VkDisplayPropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
-                                                                                     uint32_t *pPropertyCount,
-                                                                                     VkDisplayPlanePropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-                                                                              uint32_t *pDisplayCount, VkDisplayKHR *pDisplays);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                                      uint32_t *pPropertyCount,
-                                                                      VkDisplayModePropertiesKHR *pProperties);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
-                                                               const VkDisplayModeCreateInfoKHR *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
-                                                                         uint32_t planeIndex,
-                                                                         VkDisplayPlaneCapabilitiesKHR *pCapabilities);
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateDisplayPlaneSurfaceKHR(VkInstance instance,
-                                                                       const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-                                                                       const VkAllocationCallbacks *pAllocator,
-                                                                       VkSurfaceKHR *pSurface);
-
-VKAPI_ATTR VkResult VKAPI_CALL terminator_CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
-                                                                    const VkSwapchainCreateInfoKHR *pCreateInfos,
-                                                                    const VkAllocationCallbacks *pAllocator,
-                                                                    VkSwapchainKHR *pSwapchains);
-
-#endif // WSI_H

From 00a64d543c9ce5ad1707706515375bab8a9d39ed Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 17:12:12 -0500
Subject: [PATCH 52/56] [HID] Fix HID demo linkage

---
 src/xenia/hid/premake5.lua | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/xenia/hid/premake5.lua b/src/xenia/hid/premake5.lua
index de7e44f35..a348160f6 100644
--- a/src/xenia/hid/premake5.lua
+++ b/src/xenia/hid/premake5.lua
@@ -26,6 +26,7 @@ project("xenia-hid-demo")
     "gflags",
     "glew",
     "imgui",
+    "volk",
     "xenia-base",
     "xenia-hid",
     "xenia-hid-nop",

From 1b006707f4c4f11cb1c7b990d3586f09559573bc Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 17:35:29 -0500
Subject: [PATCH 53/56] [UI] Correct the order of mips in the icon

---
 assets/icon/icon.ico | Bin 284444 -> 227279 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/assets/icon/icon.ico b/assets/icon/icon.ico
index b5da3d6a5dc02df45b0a044c28986902b91397dc..50a1b7658869d17ee771c8ff688852cdbc4c1e77 100644
GIT binary patch
delta 42893
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

delta 100515
zcmdSC2UuQNawbfBW<6uC$9Zf&yWX9#*ZZ$m;`_)s3Xo7jp_OyaIcHrYP(V4Mh>!%z
zLJ<%WIVhu?b5_Uco}Og4XS((N?|UvEd>~Nh?wS9$o~Lv#_q+FmsybD5>eQ)o>E}O6
zJMdSQhsS#!Kk)d=ztr`o9z(zH;W636!{etvwg2AD=MVYJ+q>%T|Lx&1|HmF4(b4wb
z{~F`r;SBTeNKCBy`-ks&be_cm_)q1PKl1RHJ@38hzwiIzJ&))?f8_D6e8QqVe#-jI
zi{_0t{O52uen{|*3U$os+}d$`cu&XGVLcp|yCgV@!h#%0{LPcV=Dzxm&;KSi!jU|E
znB#+Oi#)$Nvc546t!)hJV5%n$uWS5r=Q7W)^dk$Jub176;NO4QD%P<jZJy_E^U@k4
zd%Y*JR(oR0LI<)pI9QManM?R=l_%EC@%*xBlw*s&Q5n4cage_wDRH#t@AU0~HJ;eH
z%)#%y1Q!4E#=%rC93W(^cHr1%Ps|+Q_>!$n<i|fC`19}Qdsce#H~Yh#%Y3kRl|MEn
z`(xkgAl?VEAptnL$rpQ8*yT(c>Uhp?ed41XbGM~<zEs(B$2yU_DFC}yhGOrUCRmqb
zMPbMCI2>5l6o=Nw;Ly4-q)hg~uH|0Xn&SA1A1C%`=P1hE$X>4VhBev;D`$oB{Z`ns
zrX%*Q>yG^!dLd^^Z<Ourg_Nn$m@_sAN7I6Ec)d3|wshtX>gu?<eTfr!n**?Sbrf2}
z`eIFTM;zKR20N|wW0ALeHcAi9!Nw&6(78<r_OENp3ZijvZ2(5}^13#>m-CW(mbE4f
zJ61Hul3DE#9~+GI%O)Tza}kamNX7c)(-9FCh?U9xQM_j;a?{(OC^PEi&>r4by0vu{
z98C+v!F4gnN$-l%15+_!WH&^H2g6#jU?!F=vJe>&iYem<;q>uT<n5e*ylvf(m)`X2
z&aJ%*Vk4Y$wl59%T~=xwd)pm{w@pTI_FDAo-35Mrz6cBqK)*iSQJl9EWw{%0bmuhW
zZtaaNi(`Kq73LIU`pz2Z`{DLwG00Bug*}_bqww%rj2kt`g15If{Qdkear{UW<?TYw
z-W4d^HycONdt=J5kf;3EoAAfcVa{1==SKX;p45&wx?>_Hj_iTfE#r`!I2E&JOhk+L
zI7}Qn2t|ih;B>BqjSJiUM|7CiY<*kBh(B%>>y<HSNcfjiN49vmB6$$@Znfs2B0m#_
zIoptTU;|Q@OvaSaonVb`{o7_ueA4*w-`5!le;*X!oHK4v<g@*ohJ2N?W5&zNWgBrK
zZ!PloFT%lXQ@<WPFkXx|mr!dIxys>l!_+|mUP;}p4v~4I2PIq^-ap}T_YO^pqQm`?
z`GR`<1J?(-e)$s*kH>sc`aKF8$`e6D|MZ*Q6X+X#D}nP<LNq~w$@Ne2=bittasP$z
zV?rch0%04Wh;Z85%W;<1VnPOC5<&0$HQ|rysp#G6S0RM|O;Dw0SlJiRp^mTGH+P_a
zX9q_1^2FGFo*2OUcJU5Ggg9REonP|Z^Mvt)|3PqT$UD@}4}U}$K)4nX==klxE)Gy4
zqBx^5PVZ@qv-=w3=F!GDwVQwMZHzO7!mW+5A;}XI)d=u&{FdL|A`B+{CE-1fx2>Nq
ztL59+n_my>;b~;IDm=EiF)kczj5%W{HHUlRV%7a#O3U5LB{4m5{(#*$$$MeO&&Tl_
zmL(DW&u^@sFTF?j7eZlpkmIWrGdxkbzcFqcZA5V`QSFJc9iEsy%7JCm9oRhIh7-Fy
zQJU##<h?L3VSocis5ed$J1T=Z;cJ#@mGHktga-MUzx@-Tut~V%W#;0>xRuuk>*ji5
zKNU&EPEQnV^Tdf=4s2WGAle<6IM9Jpdz=*E4x-*c@;Hp5D$ejk!B$T!n(S#vw4Dko
zBE)jMWZ}mNKdpy5rM>=wAXI(5Y`UkRv3gy)UE0qRIn;iuXFE{7!^x`?h1<Na#`411
zEN_hJ?ZokPFYI37#N@#aHr9cXOozdQ8h!g%V=T3%d4h%ij<AF9SMH7A-`^t)_Vsam
zIcbn5QY}xzU>S=&v3QCDW!oLpW=@Rh>tq9{m}YvTIMa_b_ajOCv38CRDt7siB;M?~
z57F-hDI$F*Z78x?t7m&+>QGORvHp#f4Ixwy58nSz!fi2)=q3g`mqjK!<RIFe?5UHL
z`C!o$Z=yaBt7iEU1Ht44Ut}x}WX}U}YHtYEB(gy}1E|1!X(xE&<Q{KoQKv9s8PuHE
z)!2+*R(756zk~%|#du>i)b_7wY|uqJ086I{-Ci64-t2`hb-H>P!oowaX?`#YGomoC
zt1pgjj;01|f+f>}P_Qk6>RaywV*64*lE)us_Nn3Q!7LVf=eQ>g2Tu^yBE>|4P%o)f
zsorZmAKheIJhTZ|m=6o{!_MUasMsBW)H%V}x;O$S_O`%+$>BJ-J|0=A@mM@P5-0by
zrj5}A+xYv*y-irDKd$D4B4?u?Vyy^qr_-2Gr}uh7LPeDl{)!Mr_ytWW<fnUbj0^2v
zPy_mP^1|tTVMK2<mdyx7K}HK4+nRu7Gh;D#d=u*VPFP_zN7lOcu{X6X4sU9UQ(5gX
zeMATw8^%UQqi;tVG|ihhQIz3}StFh7p@T!qAzt``6-#bU)tJxU;)%;g#57LwfiD~4
zElgp?hya{B*b0|&IwEsfYb=@`kMp@hsJi>0VCP`0o8Jis)B0k^>Tama9*nbx`l57q
zXPn;uJ|+zbQau*UB|n@$7=(qBys&8=&7?F3B0~%rq&&7rwrgD5zxi;S`{G!72%3aD
z5fbR6$<+iGa{6M)%+{=YES4vB#^e#Laj75?<%g!@==O2gxppurk50z!wY_n>WHc5`
zZAx+MMAInC8~IzK*?@2|MWE^3nSEYJXlmp_IvbEL#d0>wNmEQh#h2I$!Ode$iRMs|
z3e@9Ro%B9#l+47b>>23OH4cldemIl27zJ5LC?xFOH~}}x7UOc^T&z#&!OFeNw@KE7
zC^AS((lChQF@${JhjaUV(5HjpgF;qta%?|IG%u{0?TzwXL8N&U(iTRdWLJB%Ywm9f
ziVX9^rlo^%p>Qcq9$kiWh3hbFTyJdOXyM9<t=OG58+XrcM%waG2oCfy-z3Bb!YbX<
z6FHj`aAtoClENSJCivpY5r5NLR(@JAvNy;79v==>nbtuZQo$J0F9`XWov~$U=jz@>
zg!*I4nkl${F$=2}O-9DX`M7odF!pR)jEfaJk)Apef&RXx@&JEtq%Z4Z;av7`(yuoe
zC=T0~MX>kbxSkt?krbb-{0yN$B)FdIM=S)9b0cwTUvr#0)EUdIRydn89^;25m_qq3
z!a@SEaaAI&oH>HEE0VA&bpfuN&BfZ~i3ke~H1BzPdtuzL_i_7#wGdmD^~9-z{gJu6
z1u74<q}d%teh8sJG7XSbv%PII$IEkBeiR-7oHT@B!@Ow2@mrU5#;vkMR2-R$HZ7y7
z8xa`bkL9$gZ(l9P&CBITnKzS_2Uq{zvRM?$bC%(;bv_jv7WKx-gF`r0+o5D<D_lR?
z6qgQ%leSJNCu2rY`+Zfo%@1d?!f<R$G>&g=Mf7(;&ej3^z8~(KUW)@6$%vp$FD$rV
z{FvdGFm8mgvR%)@LW6K<*K%AeO@no%bOqMT?~T)kM<Q!|2W(pshqMLZ92KDm4|aUT
zkH!*$3BOvO<ilA^2uAnw$F7y}IFi;GM>9CCk6PH5J{?z2W?<8rIc84as;urcBsd6Z
zYZn^6xP5M?h3p*`wyhe9(?`Z&|N4$>Kr>D}VyL|gtv+J`(FBR&(}TNt;o@QP$bn{@
zzct6Eg>A4gr5ol>>4F^_rr`Fu-FSHII2O;JUaQCa)?h?)jpa*{aPL|v(o&OfsodIz
zoSkzxHWy;k;%+G4*Bgg6v_j><cns=lhDilK{#(NL3FB$Ce3`W-n2IG9UEBEK$mTA{
z-#HYsCv?R5!j;&xY8q~yKY}Cs(&}wMWMnvU4{gV-ONH2;mVygb*%nM6*9{q~hvL-X
zF*uyY0y7e*T%u(#x|ETzj@W>o60Y{|?EUi8zBsJ3qH!XtC$1KZ$M)2rSY-9b*}{#S
z53WPY=CRd0z;9~Zzu&Gk3UV^=>{dRkotqMol|BvUk0)Zo!p>MYwHal4d-UsU#;Mft
zPh3U`?`3`uqyhPF5?Gao+F-$ySfor(z{TS;$%L!1Z%ZOtH*Zp_!uV#fXwkfBt!K^R
zqL7urA@b<b4qPl;f+Jf;QGSm^<&mCPG%dnqr4D3;oX6Ds<KN<it>MAWuQQfL<II81
zoUHc3`Mk-T{q{v@uq_e!4gv%GFm2KZoU6#e`IC7_oH+p@!L|(0?-5~EAXdyDhKmLB
zQE^}#?v;(g_7yD=8t4?~ZzTNJnyPE=_*_P5QDle{>yl%TzPJqrbc>`$bHdNp3oV+4
zW9Fp(B*j|tLk`N1??m>#jktO)2gSKtF>A^Yv}zuWK+E3;5{3P{$5NDb#rpZJ5EtpK
z$|ZQJQD0NFeaGKq9sMhzkZSa6X|oA~n_yK^XJn;~qClF5v-zvBGc6I@*3ZG!(|d9J
z;5yzX;pvSWTqsS)sl1i+|7@FvRrC5_%%G+S5Al{x7SrVu=<9m@Kfa?z$VSZIcfaY@
zF3@;H?w_=%ev^>CVkDL&4Z)35>9~Gs8;<N;h_eOjDX8XR%jyXtyM_Cw7t=@>j2`bB
zb*h<38sR5|YD4t(%`mp&pYwf9t1b}}U-j)0&f(nCcsj0>EW)D;8*uaFT3jhzgL`K;
z@VXo&2WDgQGHW0P_l!YsfY<N5y`AFrL4-ehQ-$^Y&hI26#22z3H4FY_aDeyM9TLJY
zpnDuf4{H5#?2rTu?b93y%|l;?2K#*FZFxCmYMmmCCaBl7xV^rL-t>%Rh%A3Yh#;sj
zTM5MkX;VQVVGCir#sBn@UVf{J@#Rl|((eHt9{9?`BkD^JkDq+u;qe!bJv@FODE098
zo*<Ea1{ZiV@Q=S+)i0G+efYSlAQh^@Rf#Gym9lbqGQ0_W3GSW@{`n35Sq*<fjEJ5x
z!@USS2uTE?Er%c!77z{-^i02XAb1lbp#GT9;H0*?*4NZu{m#4Iu;RZYL=u)0G?(}}
z;XeqHD{u$VUk|<}$k_Oj@EJjN-(o@(LA`nFq4<uCt?5525!VXcLbXu)IpJ#x7BktP
zV;Y(ZXoe(<c=BLR&h<Sx`_*j7_V>^;E&*mh-&U0&Vb+WA=dU)drv6uddxs}1T=b45
zXqZWeeI4NI0PRLIYu>TclXL&Z#yxW@uQBcwG{%F%#<*+c^S|TrYBa{BLyb{FXOdo)
zTSdK9Z&;W}qv?4Op&6l;Z}1)3`O2%N|19vo6P6H!@|T=)g9{7DSVWIUmfgT7rS$pa
zHm0lIlT$IeQaC4+2V><-Pvg(Yq*Ee$gYDnB&z=e7C)%3gX{PpW9Z?;s>mS*gZ-;*t
zBA)Rf2<_r<aAm|SMqJCWv6{cdZsa+3L=9BuL>jqZ?ibLdB8SoP8Jy$o^Q3j_X?lKY
zk31cXjc-rARAK5#mxOAP{En509Fh%hB{}Qjp5J}n!SUCGH<t(o?XyOD8fW6;l18|C
z#CDYp?&dIae!0{Ruk$qbL%Tb$o>O(Lh>Y%|`JpHMI}Y-YCrRR<N6aQi(@5JRmP_Y_
z_)Jboxp9O6)(O_{xI%~`ywe!x`$D};^Xr6{8lLOvmb-nd5iZc-n6uI5n;Z0qUOMcF
zB~#@?QllJ5U*N#aJO}1a;QYT;oP&-c2Zw}%6Hgmv4CkDGkAsCc(Cd8%y;ionP0S{;
zxO{;0@0wn)0XM4}^VXf<`y`!ZTK~0NDm#{nYa5X%8ezdiPjCSWxf?ZZ<v4U0$HW;r
zB828m$qtTRC+5;6Bj4WLd@uTsoczuSuA&()%B?&n_O5hramqm#tf#?(TsfNB%a^2j
zc3Je%R`o*CO1<zWys;O2=f4poC5?2HBl=-cBMwV@*ok4+CVFx)OO-n)cx=y^Jfla}
z+YP;$NB_^Du1?P9okYLfVNUsF={WWx9lgzq-P@|iPL2+{Ah}c}W<~3VMUC;exDg$U
z#)&CXNKk21{P()t?*2D_{}aMOg7uXgNu1r%mD-qYxJF2s<Y{PrXe~K5-$55D9Zlp1
zp^XcR#(AivwfPghaO;>K9amoT8OUqmM?aCDnYLH#^feyOq1~PID>>=lbdtB|G281j
z!&^)!mtX!Cj(?#_l{arvJ+^<#mZcEt6|;OU&W|U2uEtNKYgS%Vfu!VJigc}T_H6Gk
zTz~117weF-(%a~Rle;-@T<=R>@y0FdSP*;SgDcrV92)*~v&r+}g%i62=-c(<$neF(
zVt?aQK1CNy_6GWa=sLZZ?=<6|tDHs*r;^rcfc(U26dU&$p_x0{UH5$cw*(n5u%u)v
zc2cer-Cf%_xR~IH2SpMVe7?)cG3ul;a?<DPYfvn&h<v?A)(5Z$z9d07M)mPV+WY`I
zr$VtlDS-Us$MGGG{i$4#q)+%>fqcUB`?BZR8+_PsFI>&`lG?V+7{7AFlio-N*MMyW
zLid|`pb;Ssuj>^T`g;)mLp>EEN?I1uw=X_gV`(@#NCGE2<4q>@rQ6O2L%Vxn`~YwI
z5B+hsAOe|7<#V+Bar<}-hIHpN%+G<|9k{T(I*k6kSh~_9FuWIAn-qvU`4RMZd6O(!
zX!hg6vo~q#OHu2jOWupC-e$4MG~!8#z2;M;@qWdI_9ax?g1r9=f*HEKEK0YF)ccan
zmHTbkE{P})_bIx`#pNaR>1$D1tuNUgire{3%nEk5w%&BZMBq+AOAPAfhw%dg=wOb=
zt^C$VPl-hLc0R~h5^kK8r8}a~r=vH{?hixuMtaDSeTgOd|1KT&C7o@~)RNh`{Sw9U
z@izunzFp$=7+YLDE8@MB)-TmVt?k@l<F(jyBbQ5X^cC_qGNRMC?BpfylHjECQeN*U
zdRAiSXAH#9p8m+&($vDe;`YW}E_ce=1MP4*rvs)94>b<PQhLMg6t>6C6-_XthaVX#
z5_b!mB7I>HD-OW3a*`@95L1TO?o?^Qn-sg!C%2DzvX|APL9?tFf_Ue9ghhmxO(V%H
zr?_@k#`T=xJsn)ta?<hSG($)#GHt#uX)iZ>IME!7oU~{R?(T=BGs1D@==->u*NJYJ
zSj0pSgU$VLC9fBDtV}@DXf8_Z?SjikyCZpG6n(`J^su%iY1$gnw2k-Xnm{NXStZe|
z#J}2VU7zGdw0RjRRk~eT(9;MewpO;g%qG{;tL*xhQa<-6a9m=!D8mcoJH3sF=I@l4
zT%t)2!{f4M#-}v2X8^I?oLKLU!tEUx(9k~|tLL;}tKa7oJQ!Dx55@MC9T6Ahi}Tq7
zjfX37TrBPs^}~hiZuAdD(=X_SDMN$ESS^s77HKL`Wm-!p-|5Fu;BAzehT`pG;)QBH
zI>+}k*YqQNM6kF}<cVixo*b)MN^`O&lI#8yI^HhkqdxHA(n>t89&Ly7M>^nEK`(4s
zl7Nn_>AtaA<9_)#+^?8~8KaxyTHyrjT+<89n)u_wQF_!i_r>PL9gS<Jcvnwc&+muS
zq-MC7-I4reC9rVYBhA*ZQXdM3V65O$n)LsWZt8(ku^=u}{O5enmmmT3I~kKQBxSgq
z+2_QgVjoIUA5<O)G%+Ay!N!MdIx?zn5P7Bx9-kOsR!U+bd~v|q*c%T|PDjbUQAnB5
z5i`cN!GqJuDBd>#-QJJHrQ<W`85@ReD|+Kr$z)`2>5C_)#^K4y;bg8}7}Gzb8cT9U
z9p6G)mqrkqffVb$G(hMvJ?LdtL1m(`(Xx`&cuiPeS}kK_G&*Ql+6#$CH~C=NFmKxU
zl8n)2ji*YIaa7Q{85xZm1w&D`Z!jhgkH@_evyr`R6q?5dAvTIS;LvQGIhuq!CzoN(
zf&sW(G#}ZS6OgfLFm9L6!ITj#aW;Dl?v#$h?6Gl{DU>ZS=$$@1h|;YYayErhsDyEu
z&5uGuet&P8Pxi_e-<4jNLr5pQl-|&=O`GpDOsB=EMN@oPMhKpk$D=Tljx91Q-!-76
zmqjz$;7<7r+$^;$JgHoQ<f&cFvPhd25va&sh)X3axm>aVYZr~c)v{H{-8mDPsblc)
z9D_@;XX3%BWGtNCo_?bmCY1~*%xr~=M_QnN7atlb;gqJqROwv#r0&0Y)Z0u{)o6lT
zGTE~KUurgc=eQS^Pxs>LrZ;;WgloCs#6&DtGh=bD=zR*1$ZAZfC+fw@q#k&3eg&?S
zEJ45S&9PzG7&d$zmd_uFgPBPtK4{YD?zn$GlTPj=?4*bMXSXx)`21SqDfRR5GWNeg
zi#(SLro`bvX-~7dv4)F;>ym<v+@3g)Zu1%5R2aS(-@lrp<@wOm+E~E%^1YEX&Wmc-
z*R1&#W`vt1*v<+3o9lgN4|YfUmI2jd(0BBdT39uIFrHlAit|Nl@%YLfyts83i|39;
z|6c8}ZCxVnUEGg*7xrPrg0VQ6mx|}tb|IByk(*V8xS&n*KrS*4q|oZgrI~n2y!Koz
zi9_=k+I&5|%>wkpB7Zivx&yR;EZYo{gpviU9%zw4YPM`=G$suWG-ywn5RC`r!;rCp
z5l=*$t5RJ9>B3#JXe?gbJVe)OHkQtxfR^!1aIzo+UpzmBb0s_J?;VPh`CIUezpr0D
z8Noq*b{SSx599;hy1W-2oS1;pJ-zU-ybtoXwZg*5Ay_#(nEXJ^R}f0mEYQ^hF_CPz
z18Rg~0PYn~LsH!?p2`5T#6YaJLa<_X1P*U(jm0yXac!XoZkJBM_#rJg+H5Saej9~;
zzTQ~ImcO`Dh_j`8FraT|WNccD6NP(_IAb)<l<dXxJ0)1XWV%^mbA9K!jvv+r4=K3v
zG6ysEs~2@eZ;k@mi5r{YL9z5i7`CJYkcWafVKtSj1D0C9MTPX~;N*|~w0483SR!!i
zcr2k6ZWnf>wCl&!t{xcFBNA5%rlErCx~=2GY!p^?KxO#(`C$H>33zh599JukF&=CP
zVJNO&D8S>}C%7&&t<E>pQ2MZ4D=x$4B;(_&E3tBJ7vyg1hjWMfVa_<xy|fca5r-oi
zh|2YBTwVyradi*W__>6a^7ULg?9cV#K#c3}Lj%T-5P%7TNCqn&Q-;T4_PCZ@Cr-qN
zS5vWl-2`a-*J%+YAy+47Oc{+kS1a)J{&_sUTZwx&PVw0o^P3v%4q~RA8)x9d>s#^B
zwY69=w;MY!2xkuu!n{ebxLec}B|DnqX+;Y>Ds6&GM?yIfF&+4t^&3Udi`Rdbf+*eY
z&slI7m)W9l;c!!`$u?ZymnG8=SB{Uw{Sz}$d2BY_=ZScHaSP^7A6Rdr)WBhb`{8nB
z39etN!03^K>st}CIF5agIBf`?UEhcD>_wDLsq8^d9L*fYwc%k%o)kxGr3V&G4L2ba
z4~k<sJVRU-jvSUf3GxAbqWQqq6knqOb2f(4Zj2<vVb`iw*uAC$cBl40+LB%vJES#o
zcg)16cddQ6d1gBX_v=&(rE0wk+O}y0f$Q(O*FhX9w<-^CnVoBiyOQzz$|fwD)g8GR
zTzJYJ$qqEb-QwOf&x0A5;%69J(J`87i~e$l$)NZ#L5l`-NO^NCM{o=W@g*nvbmC(2
zEUxz@w!*5p?;~w#A1+wU!~Js`kh^<69$wy$%F><a(5^*;ja0eyfz_!)0xHY*<N56Z
zirRhn;Kp8LZ=b~lsir91KLM3Fqsc_^>_H!l8xTyL5P|!}%`jo09YnxF&l6<R$y>gR
zfYxzN>VPoL2cxlkW*DyIcEH_|zPM8|0(Z-&;NHn3V<XI*(A`4U4$V-)VA7vIJBgCK
z?PwZXvy867UI%RxS}^EzH$HiM2D`T|#`9Y_W&v{L{2?emOx1pFJ{P3=kOc9#U)qn+
zFJUO#70+2vOqJ1U$A4)uU|cS|Mi4%i#j`OvfWxIJdz(O0If2V-5$NAF3?uu+U{KFk
zv~5YtdEqcr7OlsJcaGv_<sp3j{5-Pvr!$)NRpC^(BTb?skz*aq#OE)r;_%+}7&E-L
zQ4pI}PQtbFHF$9)6`PjyrO6b}g=wzw7x$%Vj%9<|V1076-S-O?97%Ak5sQzCR9TO9
zUbvDI!(rS4ofG^_pvtC{cBsr9gZ-O^p-a1HSQiSH<D=XA8JjT+*0kaH@WDxn%99vA
zq~B{%uL_0^>WgRhFW}=R7cgz&P|UZ+;Dg(_Sd%ga3ug7hh9!fsI=Kg~7fr;q{Gps@
zG(-8GwzQC1a&l@cCrg#ch%mw8@=)+zbF}V+FEyTJgxoJ~%@GiV9_<5h<=9{xPVdLC
z3k%l7PMA8T3zjAg$Bc>nISdct`Q0)sT{!c#K?p3{bS@;=3Zhb&g=hCp<MGX6vm~w{
zf)N8dpnJzS<YZ2yR$~m$uE7}EE1c@IDMvylY@8Qih9(R8cS1LpYsGctv%ex3>!@X{
z7pLV-ISSfQ7lh&D{yvnXWANfaGEQ4LvoUc*2cl~rt(@I>aODW*S>qZMsVwvrvM2;Q
zamH9Yx?X@!9~NOt>I^KLJqTC1%Bj`Wtc`=vp>;5Z^bEt*V?7velz{hJ81%oiSfH5Y
zl}Kei(==ILu1_@@rVI_h&3p!^Fz9Ghzi@_IB_MTv7hEq*G9vr=)eKy%NXL|MeT_)x
zcds<Go@a*s=0)l5DdPs<#+luCej^Jnu4Qt8I0fq$^~J5y>B!6Ii}JlaaI>I0)oS$`
zzNBZo3+;8U{Otz>38mkOmsVNfxL4AZ(QxmhU5fzp?qo%vXzzG@aAghc{skD&GoeA$
zM@L0q{@m$Um^>3r<7!7Zu!8E|4(Zo{hU!Xud~+L$vSx5v*9kX^C*gz2@iglOV0B^)
z&3B`Ie<%6BoFD&}x-EDAo4@}Lf*eL)OCK<-9*-;f;`G73xLL%RFPGbQqz*&JHc@Q6
zDY&{Z{KiB<j2$@uW%+yXv*(xb`3F}~n!guA2K0ax9aX=il0~#@10y0%rEsb=iyS+e
z6VDOYwzMT8LyZM2hlDu%@7x>P&^_PNzpI3=BSX9x=EGRQBfTtRERG*iJ2-?dnH~fO
z`D66Z9*kC6WsJ`k_bM1#vjO|Iufemsw2tnS;qdNMj2hb0^wRa6>#8}z*g?&WQF<YF
zD7MmPz~~B<E#vcw?0-i?Ew1l5KhheX-1J{_AAs@mDE?38v_NKjXs|Cjw~OHr9Ejq>
z%klW?0X)5)jlv@vP?)_5mriD3NBSa+9@Yzm79V{2u$Y=Fms)TQQWA%uXXkh*l+IPC
zCLF4yS+uW<anu6^l7|!O-S1Oh<MmAM6QT$rg&F^*@EN1xkj?;<BU?FBIWnE0aZ71n
zti#3PHOO2)9is+!#`qCE@aXCx?%hbm!>flec6bj)xU9k__i|BLya^Xd*5lE|t+;h+
z4NhjyL2l+aWUi*#9Tm@6Q#E6L&5AEoHNyI)OJ@>JS}8eB_;(4YHt~#jp4X1bW&%FE
zG#^jTFUEl_6EJyHM>LHI!Jys=C_c0lpWHo2lP`miiJ23vzIb|d53+a7L${92Fl}sC
za8C!GU0lt%z;YAQxo$xx?%A<jbgb-m1Pw)>hEV*r&soNM;=jM=jU?131npKpm$t!-
zYU{#~s;P8Nq~O7srMOg-g1e_v@yV@B&hb~{%&`^NyLkq-rB1{L*Y#{AE*34NC|-j{
z=NQ{}e73Q4dvy#qz5<m^_>`b!{eL7Fd*R!yzgBgXh5eAwl2Ay{LbVtat(pd6#u!FF
zuNg?5qPwL$1&=CM;pxS-cy@UMo?m8k>eEZ>@#Ml<GTbum+exG(8;a?p+t8sD=-zVK
z`4TqG30gd=cBj8By6b<>t^X>N@Ye*n$J7%!jZIH96k{U&(XM5v3Due~EP<}N_c47;
zdlP&*xK}g&7RCrF-|DG#)wl8&O2c*~yrN~l<@$I1ePTuG$e$B5&gC<f+x2GzVNt_R
zyr7P~wA8bzKXlcPauDj}iv)eFLKIN)jfQIdO{{+EhX3kkH8-qOJyFo1CK#IIbtlXs
z$bEL0Af6C<vkB>hM1sht8I>9>Y4;jld42t+CBPSdVZxoDD5R>eCtVexq-!Z7mvl{J
zK$5QdivPXT)$;IQ024!)xD89!pLlriGk#cgwRrPb54hCmx|Zs1BHMLM)ZgqwLs$L$
zP5-fd4HulKA6ap!u5Jx_tiRnFT&qXykgKPzp1UvseaHW*F;z<Z7}U8?$uI0+FTSJ~
z@ufk%V!omYiG*(-^Tk4{|C#<*|Ml9NDrWkxy#6yGg3ymJhp?8gosdP?TXnyNS21dD
zLKDJ25&n!&TV20H{jY7@H~sOA^|QrVaQX*=<^uBx<%Fk%UlP6|R11?j_bz!Njrj}0
zLqahjnV_;%ruACO_nY?W?Z0cF|7_WNgg+%{rAjJO7R#>)UlZIV<}3G7;d;k)t@FOH
zC9Ek%?6UO#Jl+Hle)#sS{_ftaxBqGkA(D_mkkL?0XZK!d^-EC`3e8X$-ZbtbQvj1d
z_j;z~8LcttUH5NUrm$oQ9byov$(@8K!k>P3{d-eMb^6cB#qCla>4Z-RYG5@z75Sow
z7;U$7kLgp4*nP(IJt|g2j17+%9iwOZ?egKqTqoozIro^&o8W0;L*#8`{O>EwBus1|
zI0?0d#hW_w4SuiHe^w}!IiB!@AevYAykkp;iHg#OQ$@@u%He65-D9o)UtzGC;{6m8
zq+Tm(N~`MH)TZ7mz(JUK$_N>KtGKZI^u`ufE9^)|;|{H=u&VOMypAUP^*89)TYgg2
ze^&BGghqtj1er;u=W-e-Dn=2H+D5AotH*4;XsS3L^;SV?S|?T{4fpzU`Cc(ab`X<j
ztkID)&Vj_y47VAjz!XN<Fgns;!Xi3Up!V%5jH*k*E5qcsY>bpj<G1Y6JH2N5&%zbG
z8b^?ntLAtG4=$T#Zz_IT+Q{@)u|f(oQUIcM!77q<I3p+cof+Q?Cpk!8h2)Ua$J<d*
z<vSG0Wn(3Uzbi6IJEa+8!hQP5+P`a~QgJ*A9u!Iy%cDZ8Kw?*olj8UeM+N)O0yUxN
zMR-Io6)N^afyU%eL-Xh5jSPwAbL@&lVpiAM|9wWw2m|^?7#qb1810f(JgK5+wWCrI
zHJOX;@JwMtW#7u<I~HHkM-roR$7(CJJxmmcsG%l?Qo&UX6KOOmWCedGn$u!IqJ3|I
zq@Afqy;B6FVt_<<al6K@#(4z;OV6@*l75owihj69+N!7839YS~>ann-P+W0;*$xM>
z=-}d{gK=Nt8+)YO%=5I2fKaG~M5|sFV~N33`LnV{MtBJALbt1dynaaNL-<y_ApegX
z37Rl`L@*U77F6T?UIE8CqZ^N=HMZ$EM?JM;w-sJ1nkv+`Xq)Kk;L5nY$NPD?lk|61
zYewBaDP^1(1Cta>a`B+_hs`H<EQZ+$WfC6yS8IQ_CsE{S!m1Sas{qtTY{XqgMygSD
zu<!vJ-IMT*u)y!WXYs!n!ZU*Dy@s7aa#X3fUbJ7xkW5KJkx4y2$3QiWbH(=TSZeQT
zzgOVI=spa+UhJe^@FK14D5^PQ6cxjO#$8?*K(3dh6mKX>_T+9S*Jy|u#dzw${X*?%
zw*!TRg^sQ4$mjG0cJ#8uuY%Iu;(pa=8KZK`y)kOmT{QB2ns}Cx`RDnE>Aldqb)g+f
zt6<bp#_UVZOM8jqJG3Bo&mq0@75~e?lUxOtiU$;u>1Cqdw6pz5sUjk63@EDhNvRJv
ztb4)ee5(BA)14gu3{JF)yck&QG=U)sM8C_pP7RaNObrz~BvWRSctPq_BoP)AjIP3}
z8ZPO0o$#*C%)heujb<%I=BpwFA4=0n6iYOVAC^)FC`9u~sRWelJX@P>NOGF37$Qe8
z1JCXk`cM)w)^C;<-}NQKDw@KM9erBrM}AS%E1j8?FUK}}>mBa>T;yejiYgL=9c4y?
z$0bho(hj?lkYS)W<$;unZAz(eYNRBmn^CDwNK;k^D!S9V?mge*(6`L)R^zd9$$UjY
zYOjV+t<)OH<2;RUl3*%i9QflBJK#tg(q-MMH-e%JZ(2TnX6N*3Zq<HL8bBWKVXz`&
z%JO+X&xgXy-=t_zM~|ob;(^78l<@<cOr60+qTP0AtTvk8KE|kK3Jx_!X_g)o*-Au7
z3YO4flHs97N^eM+xM4xY%LKw3M+4t+ivEuXhLKc|GL|Ura}#MV3*~t^B_8Fw(rIWo
zia$j6n|WS%RN}*{4^k6t&Q>0Q`-K6NmfR6P+lLqkCI)=TM~ne33}(!*KkdF??kx^5
zL%3k8zr|q`#E2F}E&8!CCKSl>HG98R@aetY=s?3$m{7RAaz98<C>NBBNTuM={s1*v
zS64@PeL(OgH0b-`Z$A+IH}l4DzY1n1ETX=V*|8$p%9eXx&RBhpb<v#?%LJ3FQL`8o
zeTy9ZyxgC$A-<+ZMHvBnH^g9I<t#r+!f@`U_NT=2VnBMZiIzUSmzkD^Xg9qNu3Ah4
zaj!5Gqx*VO?E2wJSuh*nM^UN58Tq!?$EZ<7GGEK_GI~N}x}M`OMy7T?X?MKDv~qg6
zSxu4&TL^zrm-F>EpUdElw)o#?1cSOHa=LaUh`FTAB=a+u(4H$*&t(lsmMb{Hhc<u@
zqg+H1Z-#CAu>+ERY-FxF6v2pUZw4R*utQDA118r4Vk4c5u=Yl`HvDaNAa3MEQ~vXX
z0&X@>Xle%uKOxGtEc7Ei6$ctf9uWEz%k9G+`xxUfXQLY8B*tv(Xd=V6%%&q6qp}s;
zMuR#R)c^))_F0ZyuHI`XDa(nB4hb4<ozQO@4d)Mt0lmy-f-MWh`J!zAIoqd7GddX|
z=f~bhFzB!eWkEQ!?wgtzY=RKe7MRVgro2Jjn80F7G-C^z<F=LGlvztc7^TK=_|85I
znXn5`baQWmfly)~unGhI#DJgK3-F-Gn?a^t)gju-2czkjhO4Y;1tV2;Ow64@sO4Ya
z-*RvSS^Uq~eL|V?@<_DGHrGxD?PAb#fp)e$Eb^i5_n{7VGNO?wR?_^*s9t11FUEI;
zkd!eDQsYMElu*-q1)yuE{Ie4Y3|NR@S`Y3gm=wwo?^X;(YR8D^<`x&00}&JMg$0us
zDw*Ak=xWZ;$!HUjukiaj`H{px2uFc<Adqwpq-OMEW28)M=d~DBhKME}GOJ~*DqW8o
zAIOQ}=gtTGo4#Sov4A(4Vi{{zvEULcQm@(|B5fzRpx>qCj&S3N<hlY=nH7!0O<QUF
zaN$rS0}kV$z>-;`0%@jk*TkqGhF++r9n4Po5xoN$rXPUY1s(CIyfZ`ho1(SV)Cb+#
zGH!2eQx@<(BOTf@Vkz3J&ktdsdHJp;#7I-aP@P*dmiJI7o>zpD)<GP0KGluWxG&ow
zqr%=^B}arhBXO<96EvMqAym8ZdH-Y4pUa^3OV%iRW~!NsO!0GBny1;uiR+#2ZJitq
zfmBGL)NIOV$MB4zSjPA@V}iLT#&!6jbyII_Urt^qV(4B4SJXDQW&n!4f;M?*IG&v7
zgVJ3cv=nPGY~GhaAsz7SR4;}|bi%xe5oi(P%`7!hxSp3l^tEBUR}2jaUo%QB9E!k;
z6OksgRxyLFhG}Dpw5Gza)p&K{L7~YdSp5#)y-HvLNBf`X-;@u2twN;3wdqJ&Pdn6P
z3+`QMTd%Tc+?a_TE-_|=;rM42%@}6W6e&|e3?q;2&m<*#+Tg|Mp15|b8}|pqA-;(Z
zqQlJYdM34tVnE{%9Lwl}AdBm|gSv;{LD@jQ+=tsD7+lyn$mH*PT+y8<?1YS^F&s{I
z%AIM$0w`YNOlWrEn3}+KHBO1A9#bXnVWVXmDizn$GJ7AO+q^+e%sBO**Y`w!F@^E<
z$hwuCC$z~J<#Q8k`herUe5a4uc&KLr?Uvb)9K=w&cswX+$vqvxXw!@a%)A(e=Xb@^
zlYLOUvlE8*4nus5FAi<$%nXUlGcX{^L_$72J&qwAy)CoGH?&s-9#)KEXiPt}Zsw1Q
zeLeB)^blOk>4D|5W6{2a-P0jG0yv~va-_6k<spV-t_H<NGqcqWKQ^8@ABNd{p-HJG
zDYB&1xvF<15tkA;@wLn{Sz*-=W?uHFSUh0Q>y))jv7R!`WZ6s^QWNj3Z#4c7t#3jJ
z$6(|AZBV?Ut?BvgqQ1-tk$~uMVlBoG8OuB2`MF8>=;Aa6A@;<yk@5U{2J)>PgR3w=
zg>Y&L6VVJq*LEQcml}b)r6aIwHFrA{4j?K!a|cW?%6GTpkm`iP8{()=YXXr)|EWWL
zsG5U0?)@0uW{Yjfg%dPd9u?cpr>c$$0~LfHiT?jYkiXAxxVBn8rJXOdJt>t<&!j`7
zea2!R(mI$jU(2%9s5B^jzoie#b|>KZ>0WqoW&ra%^~B_1(FhIl#*ki-DB3*;&nsu(
z@fpUB9-UzJ0L+=#mJv|%ER<%AGhy^f!|?b_B2FC|i*D`1aDzc(w~EIzkyJl?cz!&d
zpB>5QrM|30*l0&%w1)fDcnx1Ar+HoxZUod48YVJKwGl~K&os}J3&w32bKYn<{ue)v
zCTLg~8LxzKLYK1H<)wMi9^f9J<Nk*B7Y~KdmXBlrQtirBXs-@5UJrN2hv!BhcT0EE
z`{ptJ?9eEDd^w4UiY8+ww|6v)2}F+$Q8<%36CYa)IMxP)WpjF9XrFlAFX9G+X=d+-
z5=z}DnZ}^uRzxAA<WDoQ;ruwFw+}ZVRmcCixSAUgxn(0i1`kUpV9K-)B$#5_pC-C5
z_O0TStVDasY809}E&9h0`Vov4l)_McH+d>FSMS?Vx?WjNeT-1iKEG!bv5f7Hs>Oi(
z-k^4L|43ZTA4cw;!n|L-m|dd@1C-`)@5fy9=@P?t?4g;uZ~&fNO0}?e(|Ft{Uy2I_
z3o&+Z8^!`Ky5Z;?bn6g}Tjld`vuqA}b&A67b^Y+cg;^|oG=)fXb+1*iKq@ycJ(fL>
zXPTy9+7O}4q!dDvO_sACcf)9Oc(Zd(qw4MNEEB)imw(JA7%3=|TD{i}MNPjnFYMS#
z`M<a=iyH|JuMZ^#xbvm3rP&2#7gT#hOdHvZL2Fa-{CqMl=9A7ObLFwQXxb#mG*(zx
zy<iAFv>3CUyNkQvxY<OZn954^{K{sWJ(hy*9b$3&<TBhnxfuI4jl}Z{i~*^bjcKE5
z;`iMv*RHwy#qFq!nwyP`JC=$55p=f&vgb_AveKLTOf_XQTQ5yREEb@NLLwox>fU%U
z?sK|zdasw6l52aNOs{*43%^?+=3*3NVGBGz*`ATHtxOaYzcmHAuIgdZl=irPY5{(B
zGZhccuEfmoT@3w44Qh|AYbIjG_?{Lja+jMu9e2)d!F)zRP8iVzFRt%IWx+~@U^X?G
ztv<P#&dB!ljD%T&#EBh@#B^2Uy2eHNP%gBmanXgkA<{7C$UZVsLrgla!<>9dlq>I_
z6xujWa5VnaYKcRw;qGu1CJ%?aR^>aq&6FySDHRp>ziT-ypW+xMAd6u%bbztz9+mfC
z61rG-!BUM01)!zO>Vb!qYw+Q<bZlNZ7X5m(!sW6J`267!R9ZzF(W!ki3>(l9T{||%
zpg!$TaWoY_f0T<;$JU^C*A}=}xdor!+l@!(H?XkYuk3tLqZMA2GA$mDD*7|5t|Me@
zR_u;vtbbD^j`63TfWc`L+q!C(^rK>5dfc3_Ts`JhE7)?Mn4W00;&BOgG;Q-SJa8=C
zpR?gm>{u2=3^Zk`wn!G}#NugD)OdX<`FeAIPhj=<b}QFJ#Vt!3gohWl;G<jnaJO<h
zdw&!^dw9$;vER*NBQSDEH|$7DW)S*8eEzr)*U#)i(u^V4wst0dcK<LQGfz~CHHf{h
zt%6+@DZ;ffdk~(U8j8(}81uKKH5rt4B_|*03q#E`P1A7gvVK$&$j<q3Q!?{Ex+#P`
zENq{vKxIUfIaQqLYm|$0|3#){yH_as$D(g1Kl82Zx{_U8@a)WJ?wst(7@+FN_-Z~-
znF`HZnmhteukFV#o)zNZl|xu&am!8nHqFqneGA;Vn2le4a2lUIsX*TTwHVO519qh^
zz^4!L@%Y+7q|DK-r}}%Z{a~4^dQv}3VO*#-uk^(8Q@v?Xx98L>j{3rvdp-R*XQcT}
z-SDhDn4R;7HG5RG39V5e`il=t%e8G@(=3@)En}TvE@#g5yfJwQ_w=^$F=qP6J`61G
z5rUC@xe>W!6t`hc#)Kiw>*WI*3mg%1MzcdX_}Sxf=Ks!Ij<}czbneg^_pThr7cVMt
z^uR{6OW=;x?JMy4vr~9-;}{ms8B+_Lu1319lSd>_I?lqKvPoDurwtyR7{*O2+%wcY
zkdqRn>WtzR-lp7N)Py|1<YfnFyp}Nk*R)|ZW)urk?<EO^4SF|)0Y5Y8Jh>;3rc@|_
zc|P~Vm<_3?v)bT(34@Xg`*B}DB+{33#*6cbIC*$7S~h)EMXOAKHoeTAI-LGr#%%wb
zJ<dO}6&>2Q!mvTTuw=mu3}$R@{*i6?#fO*h@J12l%pCpN-Zzg6Ve-jY_~<f|P^S&V
z=mAae@We>&CF@G-*^e8TT5=?`!`0ko+|n0FubPt72E&s3O`FH6TBcsB_p=BF1Dayp
zIqpY>38Li_O8FmYc0%8y{J&S!j=Q6}&?M_ebPvVU5phsb$x}zTkL=<SY+X5wyDDp2
zN>%lk`nb`F^Z)TfaQkv0zWDGOP8J_Prw(n<vl~OGOAg}KpWZgP`ld`6)?iq+3e*<7
zt*ghF-A|ufTh7Fiy)mjkqolc0wscPq?i&cejpLnY9ku1odHNIfMUx+b=!~>N>0}C`
zQ>hvQ(uV52EFuLa7#l$Qx*ik}U88)=2+;n{0bP`A!k<&NAgoPpj@5Hp(cbr^mBXB`
zr2nVa*Koh+Y7<kca_R-E>W86&I9AUU;8#DpXA(x<xKxJUeD(lWDvK~=V6XZ=uKL#O
z7n{(N+p#v|XSX)v6IPtIqz^_C1CLHk<g}}|**T$UnKmJu&Wgv2lg%jwo50d$;fsfY
z%=oTqq3pl`geC-I70a|%V&NxcA>39QM4w<V6AOe<2SgL%n3TQ+v*xwIj#V9TU{fDj
zJ~Qyar6mmMT!N2pY(XV6BX)kj-VpDa_<vR2rBi#HD9Ofee*PH0`s@+!bI`kIm)G`Q
z-$`>`D&2^WZ|%h8;$_6ZTIP1^j}iUi@c8r;vwNmjN76gLJ2$ko2lL3&CWxb@Y{laF
zi756?Tdk^Tq{t@C34ThbnHeqhrQJu{ubdjMJdV)Pc(I<I=t}2BKRiD(oK`RQ5?q*x
zCuis4@YXRH)~}_>1N+(iEF8~Tf|#fpKcE^;`=h$j>Rz^O(-MdGZ^yxX8L!=VW(wf<
z&0-^wm$ed~J;+AsktNuhHU*#D*nsrq1IYu;h=FO`uHB#8`?+O5zb7&9zH!kcG-Ljk
zY;Kc#eu8vd>TgtJRiT_3nVFG-NK5ogT2eVY9+iX|FXw9RoLMq01WTuLFUa&LW<-eN
zo{;8PHk(O^t@oLNw-uVl1!HZ>VCwxe{QSWoe0(<>o7c>C57n<t|EkIjCj59NfDRUL
ze^%eUvYBpOpNvoL=QIE3PHb8+0k==DCkE26dVU{_5C+c7KzY_c^z6Xxn+4jO+JP<^
zZt;(#%j6_eC_gHVX76h0?J`#OBZA_Ak_ko{c4*0YK~4yLKT*sLVoNq*Mh=RReM6}O
zA~3pt6N=wB%o^7gg?p#sgR7hH?8-J29$dnGV%ZG!&qGSm1hZMSUi!1LH}=}~j`sd6
zN}hrb@0a3}2ZcCSv>6}V+=q{D?%=r+Gts_PIHrzDAVbb31_q;7#}HzG`v;l*KwdU$
z81r!4rCPj}8%3vMwG>nX77@(CGOzIj<0X@0>G1kMa(^_oE()#k>4xFLk&fIU-5-xn
zj^IRflBrM=mXEKcnjvXT?v1F3AnZ<0#uv}ZxmhV6Qzr~<nEtHrjaX3cCyyV-{k~<~
zKX{rMF4uAcS`N2jXJI3E!*}l(i>agA<8;n6d~|6pj%D^o_x8a|V9<w~T03zRSWGCr
zB+|_1lytz&v!UKrr_bU2-x1_IG<+aldC1fqm$PHJ!<nkKv;!WNb;s!g-BGf;H%j*o
zMp@QqlpUDN3GNtlY#WWJ@IZ_n(wQk*H{%!2PvF-dpJ)D`i^sVSrzf>r{dOHId@UA6
z4(m@1S%zPId<7*(w_^OLJ_ZAq%F-~be_K@MFUE_@tMTFGB`DuN1|#}Ln@x;&OZt-s
zI>Q>+H2~)iHD_<)IZ>$Em2Ow6`0szH@|1e;UU4D|2?hg7EOL6EWJf%uU;-{>w?XoR
zNRtUAG>A*O^nA2!9t<U>)+}h`fHq7>x`Nj4UYhs$Oh~$q1~1R)`1L1OsrinfTj%y~
zwP%kFsK!XY-raENY(D<&v)j0K?kEQI>4aeeyBZ8!DA|ZaGTn=-Y54TUI^^vb%Uy7x
zG*07aA@`@FYB2rI7L`F#v~e<@&Whn8RJAQAJ3wm#)$Z~tmuV26nH3Z9%CZ^$bVhQ2
zFMR>y2imJ#YT)Ey-2Z=oNsSMWH9H`+CusAEk@)Q19(=~hOzz%g=+HKvD`ZP%;EN9~
z;+G#^$Ifl3Zzb_mfk4u6XU2Nk3HR^|e!pf}q7kiA#`UMD&E<9+TG6eTsCw;K<ZPdW
zVSSrn{ladzS3aJzq*2DFXiXcz%;yIwAj&DXnbTKGDODAG$g97L{;n&Z{eZBm>K%Kp
zFU_eZ<*m6nl^f8EG-T?P+yS^<G8R|zC(#FxOflS&+pgQ;?D6Hye7zDqI=8~?DMOh5
z_eMUs_cG3u9W*@PD)?=$-MTQjM0qxC#T$5hs|4xmk~w$Wi!Yw!qcnSk$p;)j`*762
zRw&7ufTxs%cgx0MQ%YNne?O!zYKCVgJ919fj3Tj`{^IgXLcPJLd@lPyp_-=0$>Re!
zD{hJF$J$_IpCI}I1G(dQ2sgL&VSe!*^mH!Zw(Wt&8jg()Mna1yEJ+%LC)V{GlO&=v
zFB4rmwSBFXtI8SzZR4(Bs)k>DcpkraahgM{h<=2%=-;EY+5NO~-T->j7ElhPF#XC{
zX3A-1rtjA9-k~%KI^z)+pXQFM;b2yzC9_Bu-RoZY+n*BB2pTEI{if_l@(C61NI)m9
z_vCG3wi}w@PtVT4$5$58eUpMMD@TwiBe8xdGiKb_Z*g{e9QlXVf1};&s@NSmz0a)Z
zhtu%c<1$lj#=4mp*eiisx@J=fuEVnnOOd^m8PU1lP|oSr%}D=}T^+er(;eBHni_3Z
zRiNmv-qlNg7dH627vVm^G(?Gtv_SEUPN-cgTT<NyVbz=jY+lj@+gJBxYM%w%YnqB1
z6)UNtcj6=K_5tkPoP^db8s1RqD*SD)N<OkLV-dII9c6}tgLrs;3qHBI1=mVbm|39*
zP8=G?5ik)O7PMpj?^W&SD4;=bq&=71Yt7Xju|h9bPaC@O9qEOM1QSKWD`t)iGD&M5
zSM*@2rRGe(V=Ff~sg#`J`Nb9Z>`uBSEEcoYj58-!>BHB7G-QkBT=j_2F4s3}%eW?C
z*uYdP&zLXf^LxAKJxk?&@s4Ke{@se{_?SyE56UfCD<`@2n(44+j|nwnxvCMr;dKn*
zjbSvx4Bz`}!hV7o4cex=CNYvWL02Xo=)?3Y@jTiq*qr-yvvejtxwZmVOHwe`n!=r{
zlurEcwGh)J60@d_#f4LO)Og2X%^3ey+ETeelBV~?_3~Am9k0WU(qwF0)RS91yWx7l
zNLU|Lj$}rvepoXn#*E>rhR74HNa(+9i0<`0=lhKa)$7S}$!}iBWu1y%bW9GSmt+`T
zRB}_}S#JBy9F2iJo4wioQx5n3eL5p&e;Ph|TuC{9)5!V{AD%;YRvLQu=<rrjvtPGn
zIJRpto>nfPi)N15IsN36MNia;!CYc(?%sQmLNS5=x4vG!?is&%j}S*N^G04duOt>y
znsVcLU)(Dl%E{<JBu=2OAcFow=KpSx?s5`!@0@_lO$+eg+Hw5qqYL=p{s|_M-+&`~
zH<<fhes~cNuiJ+SbnV#cjhKjw4uqE8%J+}JgNm`R?w1W^Dz%neovzk=YLHsrjPO?6
zUl$|%PP3*?gzBhT?Uo+YJ&49<h*=e_+7J9H{pI0o5*duK!@A($_Jz2AX+J)HQi4yo
zOIj(FGBz&2#?^B$VRS!C9Mhkv^|#^U2PL%sD{$}9A?(jg!Kfi!%w&TNs296hoRERq
zzpE8S|4k_K{nzUK$NaE2;ai1R^Lt6gJ_MClt0A(Iq=14gCJ<8+vFHeYGgs3J*v4fe
za3XgxS4DPmPJfu0arX1Ly;RJaJP4T^lkm~Ke6wf#{^cX=X?K&3Y2C7ECiTWIp3;-{
zIFG7zAI=<Kg|ro8F>Yvkv}qBBCafbkkQ>y4d`#uSf>pO=RjuvC>$mE?izisl_X!GE
ze@3Xrg4PZa$H!UB&({kjdxzmn_5|i*o5K~*WlWE>4o@y_;E@{3xx;x9hV*S~Qf4)a
zWd;i#GIIU&4s2XGjaKeaWNb*ph(Vp1H$saFxjbxOD-LX%gNr4pcyfvBM%OoU!|@t!
zK3-tvfhGHx6EM9$E03oIME}2AtEBTE61oz;lis^w;g49RVok0QBwbCtF;;{R=1gdc
z(}#v~iJXez%6xosbqOxy&%v^}easA2)~h~<XYb|R(ER@CwLLsaVI6m~A42Nl@lei~
z&*@@0Td)RwySFqtMP}C0IsMGx7N1;SjZd#FHAzRbAe}U+g~=yixmv=jyq%iiYCZTn
z?Y$cozQ?llPb)17RIM5R%5JdSYRi;KWALnUE|*Lf8++}1elqr_PsH*huKOQI#)mgD
zjCbSKsg1b96OFQW%r&zdEhv6^dlwF6%z{or*|&KTDv!_SR{oV#w=21N%EKpeCK~5d
ztEK@|^&-8!{wMUxdf89-zk~*ZMqNGmHdmETki9TY{+|cDF^*<l)ey9Z^GEXJ1RUQn
zoXh4GUeJ~LDe3nyb9;SuYZE@Zoz7kJ8;o1!Lg6x;I-0_K0E=+{>^hoN+vsrGXjV(*
z1$}X8Iqm)=X44vpq{(fKd)`%#uB_i!EO&SvMbQ4Q-)ryPF~_<rDGHg;TM3$08}o@*
zg9%B-4y{9s#@fAZFe4+Ta~#iSh68f4yc$>6nx1NHSTf`J<uyz&u)-YYqa1O2HVng@
zN$t_IW2Acm3R5=g;BdFhPIqm$^C8rl>$|t~_jX^k|4att4+)x7?j&gH<!WX1RU9j$
zL75Tycjp51kd_Q6Y0n;ZG%#zNk`c5*ziu&T+ajdCWCX6VB!E=MZj1k^Qtsyd|Ky*m
z|237fF+U;%669>UM35`4T4eIx)r+bzT=Td4Z}r@3lqp@)WrAEgtiv+1*gqJ@*L1V$
z?$!R+yuubrbt*qdbAp`EMFhF#g%PD`kirsFW2EX{&oq+MW4$ZYTS`bGsH`6ojEH|-
z{WUH5{oTE}ezw$*hgYf4KO_7zA)L^UFpIF3u)7MRSauM!h?z*}OK3v)CxX7MW6-|2
z{&(s-m@MKa{10Hx14~zv*?`wlC5hla6~~L65&^L6TnXkqrIWy8z3>C`zWE|if4^sc
z$1lxyEZU@2V6p_))fB_@5+)S`3vyi_>vQ`=9dj+!|17xFTs*#Kxo#5e2k*V*)qeXO
z{%@dMbN-Ktd8Oh~J#}kosrl36dynnw4_sGQPhD3RCR~_tU0s+n6c7y(Rggv0mg<JY
zd8{i@Z%QI5Oi4efp_Pkv)wJY`e65DoCR>F$peRvAk!|0Ytl~T7KUMoq|GxA3HN*%K
zTt6cGBjNuLB+g?99SNEX^dSr;Sc9tm(8IO_y%a+D7s5Xfv;Zj^L5Ab+K}>(={eLIy
zlmFiF{qOqqZ(V;CY2*u*q6#30lu}j_#U}{22_F%DPWTPsw{BobL%B4Se$b>qFMUCf
z){<d*iXf|K4nc*h67fc@9WCDsGvB)Z->ll|um024PxNaY=*NUe!c@Y3!VSXD2qI;@
zCL5o-8!I*QzdAp-zvQ}iSv4y7Gs1mBHbIp~5yXJ+C@22Y;=h`MzTM3`^`Gc{k084L
zPs00zbb|c7za(fFyGZr6*LR}->k1W5C|KzhVGE%X;U|Q8cR$wP?49~w^VxTH_n)GE
zqEU30UYFNG6A01$0pZ^XuOrKwe*4boU$-LhgBmA(P-7Dae@FQJ+W+s&7ynu4|Hnj~
zJYy2Im4x3AUJ~k}{aye5z0tpJL)2Iasq+MN;$I1L_xz{8|2uQl+kf!J{u51qLI@(P
zAv`2Vx7S7QH~O2aAT{*Yl1P08H}t%|ci-WeyeE(3|5?eKU_!m;Jik36zu}v2#Q!%e
z_iaCWZT-ZGbiHW5k?@=#v05*g-sZVTsg0=0u%lcO++SvyWFkrwwVa#J*YPYjWx+~k
zUI&5hb!4LUa%*3|PP@{cPVMDX?hl3RemnlK^Z%<?9}+eb<Olx4c|%`||F<RLw|K9?
z`iTXZ(h`%)2*S=g%X^VVBvNvt5xpGdXh)qBtFvR3A&ck9THI8?ByvnRVG_!5>-95c
zF{lOQjZJ0)Wj9b#0==tml$t|{sPb8u3SB(K(^R4jjIK00Z1fwLwPyXt^`flUj|uAa
z{~`Q-*902G|F@v&yL?)2{p_{uy}u!hC&+|)r*SX3H)l2tWkp+Kd2$P$j(4;30xGkH
zl2lZI<+}OS*JmtL{Go(&7Y?w}O`fK5C7~2g)GsGqrN4_0bXBkK5rhR9kKerms$TrR
z3jx37yY<%3o=WaFAruk5B)DUx!F!=tnT^KvvybdO&BKN@R9%Tl-01Eiw>$mqR69Bg
zP$_p@@Qn9LJSEU?b$_p?P*>sRs&o!Y+oqEgwYgpVpp+gqKfIp)?mhi?VxgE2L6Af8
zyWxd;@&7Gp`YxZpQonje_y@u~g8X)GCHE!gl^Ipzy<(S*^4HMakcPum`Jb5ejyYR&
z@T?Ms>WuEat2~+EsD=kF@;4pPtu6UVGAO%1X*6?~9ZyLpb#kimzNjoEFOdFdh%XF3
zP(~<`Wva#2DshzC-XC|GH*_x#mpq*RjZkMo`7X%kyRYE?9l!s!ufI}1dnCOdMJObQ
z>l?yC^>f*D%6h5fWXc2U${W@Y3G`gU`FJ|>Kdzc(9}ucEOHvxr-P&?5L82TkE;&%X
zvnKDK#;yxQI*n)LiBrlhrR+%Mu-?B$c|~pBYM37^TWRR1btM%WNh`&b@8>OgF6XtD
zRgFyeMx=NJ|KF&TZ~oCM^|Lqf<qse{A-r+yi}teZbTIv`y!vIm(65ZQ8m1zNRJF+Z
zu!!{6(Tlb$ewERb$H!d`C^?Ouv0>F9`YT1R<`9w%vq#xmHdUrJGib7*#FUZ`E{3e(
z2h!j5P*-uTdT}t-&T#9NdbPSj_sXm8Witv}LkMqhIMyN6EBLST`|tbDTJ^K_lKp>A
zSWM6o%<Fn>$fjJr%4)5gVKr#2!K&;%iFS=Hky=N4E4{DAKY4)rKbUUE?SSA~6^e#g
zs~xp;zA_pqDV=Mhimu8FXcAPG*!BS#%Ot9mu6K2!OF~ULKQUh^6IAbAN%?>25VM_f
zQsK@AE?!Wtbh5Q{#9Q)$u(pCAEWX)BsD=OEH?iv}zgGQhv3$J$LO4W_i=-NT_1#NE
zYifRpse0?meDQ+vfJ;4VYNjc>i)1QG>YSvM{bvM0gFGMsqm(>)&j#HyPiR^VNtCWb
z2iDiT<9gRl!z|jXQaK%5DIN9h!Bo;;0z|D_G}+T+Emy1S;{~PYR&Uko`mj;wnXKl$
zgnz0B>ot#R;lJkbAMCDH{cNqqzdxabAgT7+o+=S#9<w7$wkunzJJysdI*;={Wyfs@
zV=HFR|08=%w9uGsNDhc`lm%6ZC`EgL?v-d-jTDb4HS04ze^zEEt~;_`XTjS%Az>q%
zK=MR9aD%=B)%mQP^glpD!JRXe=WoVvB_g(y4%d}x%8r@4sj*2^?fzW@*b)}Y3Bu~D
zwqh;(|G}tUQ&Fw@)j~oH;WFX1w3qu$iD<88OYYmbqTT5)Evn49qP?)BQC1JOEMwEZ
zjtBISOY|xolcDQTo3;m1ZC$U%YL0*Du+1Bi1xjG5@5Cc6zRBKTH$w8j<^j@Qj8K;c
zRG^qe#;BZ*g<F*oyS7|Vuhn~D!7c6T>#%l{<wg@~d`h+OUqhBZ*j=sq*|P5wVhIYn
zXs{>3jC^{^mivH->g};#d;GgJ=*iulH1X|x@$&l}S?_5wtIE`89k&19C<7x0>_qV{
zn^5C=$`Dnggwggf3ZkiosO&&ZIK^15#*XA9#2)i@E^+AvRiwOcO6e!Lp|Vtl;en$R
z3br8dG-<c%;ZVZ|>al37Oz7vb>T0`2%n#GZOgNPB-qn}}uCl0w-FU+H|Nk}rV~aHY
zn-cC58npd|4bAs7g??H+_HFu0d!F5AyJ=nWz~!2AciqVB%h^c!YfQ7UDmh@&NQVWu
z5>Sd4ZgRXUt-j!X0W)1qdKJy$1Bvak%>VhU>Rr9B6zymC+5BMiMhP9!lkMT%wGHWi
z!xU~Sj{|FJPexRzm`sh)+)&o5dantGEZQ1d!5#(5o~s<fnsDenb?i0pQ1Sm-PJdM~
z{DCAu-SIE_hZAnUrqxE>O15jRUnBb)@!mcIMyKP5tf`4r^8z#9lk}9zRqAfKX>2zi
z^FQ;Cttqx#mVd`JPQ?Q*Ibh}hZZs8L3$`#J73ck~hU$LHLgs)yZu5zYU+P|;mO70+
zDSe^!Ka)aPX>(nMh0^c4Xs2E%3$m1j3>2O9p%XByQMM2ff9Ti_C8M`3V4Dww6`hi!
zjM^^c<!WfHE9tLcCMR<g;ms3<@0c%Y(O+e=5g`P{aW!cF3DuJ6Iw7G(_S<>GbLhU4
z8;0K-5Qa2*l)hi|7o4Yie#unL8#(@!YE!7caL}Hs+dN>?P-g(>V~OPhsqW+2i{E&e
zV;7{NU6m;xw9@wJHy7Muw!_N(Jf5Mziz%G!V>om;h2+1Xzi2JNp~}Q8G9ve_vMW_j
z53Lnb*0kQ$3po^|oK(5WkV49)cC+n-8q6r4ys%ZDZqfL!ZaoXSMF{wgN&MR4YSEvS
z%l_B=Pa&5L%70-+hmq9Q{Tl!Fi5W7nT_cF)m=1~$<dQQofMb6{lEJWL=x{B^<^c^u
zO|@kYC||3{A+osU1v15MAFrY9!y+b=n`|Gmp^8-L))bPk%$s>&y-7-MX2bO|%1YyX
zXm{H`D5r(ZHyr=ESujz?V~yaD0@<<DE>M-<&9@t<GXTy|nJA&Kiw`uz6-Hb=mBqV$
zu11GzR%G+S-TX$zaV<=^-mOc2{UEfTCj9ej3HKfSSd0EDlNHNzahTBH_?KCxV_0+$
ziTn6>%>m_2Ikwpo13KHIh-H}`i#%!b%)H->G9GebnLM1Lw~km4y{{Z`8Z~R=01uMU
zI2N5Jk@hM`wqNOXJ|}&jlfKG=FSYDm$@V2o+sohd&I2Yeo;<kLHcz*AtK|Q_RWvLL
zYZyzF>L`}EW9=T8RN6EkB^xw}kh59#zzrVPBR<fvJ#t{X8lkJ`tdsC``k6bHWGm`G
z8#8CHs!-$pVb#6(KyH}7|BgsqZ!z`J|A(wp9;^oAe8k~8B}dkdd(X7irzO~GyN~w3
z<-?xztk`5@nFd1|hRQEZv2Ss#+Q;eWJO?9w%bZ5m3w_I`^DrSMp?+Q=9`Gg)*mSgg
zLVE6FpmM)=t>omYXvb3Vfc^XJV?GqmukwJe59u%FIJ?h_7KzO;w&3uhJn&-B3Dc%>
zvQQ&fBwU<a>9Cy+lKHmqvd;^s>zr0Y^u5mfvu(v1jG1G6tduuS9z}-bgx4k_sh7BK
z@vuJnYYsS+@M}UXj&}Vm(n$WhkAKPj(>!os>QGPP54NSBix=#rIZfAPIZG1?*3TvV
zb##{K?gAwpKefkc^nfZ{K0^me*`#^M!$*|QThAr7i!&qxcmzv@FLk_+$$IW;q<%lV
zuIBf91-|CM64&qcmGsw9D_5Bo`FRzyh^chSiE@7{g27#H>)bBez;GJ*AZJ9yE=e@o
z@pO96tKKeQOW(;xtnnpP@qtCRnb0VK@LEIBCWjUnOiH%5AnjYdQXl<g0|XNu*(j=?
z2PB3y|8pPzqQ4HR(sx3C@;LR{cFDW6rRIQ|j?EfjMv!I1q}Fb9xQvcjIm@$tb}Y5e
za8N-SdNvQ(WBF0Bj?Ss!fuanNj%No|_>l*EtL1=%)Ru)jl8NU5Jg@M#f$yE;J36>V
z<r@1>l~|*7bb`%DVyHXEeHeIVXTPqC1u2`7Ov(!hCh7_I$)=219mV4MM!cgrgw_yr
z0-{SY>MBY3%yOGP3!QJ_NP57+!{3UyZ}Cz?^jEY?0ii(~P(2jG7Hp~E0a?D9^NIHQ
zT_7~e+|s<@0cTLIS(dK%@;Ux>hL3AnEvAycM%TKdVZ}^|Xq!YzO6=kR=>i=*<)ZPq
z{eFfAY`)<UYsI2{fDJrf%5{G>%a2)b-SR)o8&4i6wHf7UnV(@E_pz^WtVY?4V;{RD
zL*$v;WaA!fhE2&eGC=Rje$=XG%^bp(1D9wQWLk_|b5{&H$*OM8U8t;cJ<h-X;Vnq~
z+E-qozusoSKOiXnqd^-$j4JG?hw_Bf_yO#gAK8cQW*N&e%&p~qodGGePm!<nANy>E
zik;4?oa{BsqmSHS`3&)ZJ)T9^i39DlEw(Pu^FRZY2mB2W=oE|-yF}7Jk|~hG){iON
zeR(c`_<%_)%b5RJ2SvClnLojsJYX}4(qqpZYgZuJkL<0Z`IP_P8#8(Kmy0)a;@$0I
zF5AJ2UacC(gs`NUPK|%Twio67I!+6Dh(&QZlcKO@0kRP%pSCU#AGl8}T#a<Q{s-?9
z3EwziwO;yH@qqlmO36@-9rt@prxb$Y8oF8;(^;W)C7eQflxp8KYE*{qWdjy&BmM1Z
zw@Z|I)1>yMHsnzYJ)Fi^5b9kO>qDCd>@oeYIDm4%CXsCu>UofX%KZW40hOUSe-K_&
zF!w93vICX6acc_G`IcM3d^wmFi(fT2Cy&<|Pj(@XnJ8YmK@AZ7ujeWgwk;#>@vOg;
z$@aNGvTAM~wH1^m9$Bkx1tT8OX?ZT=)+PPqq!wQ^w<zuOl1{R7Eul&==u~7?D&?W$
zIO`527e=bCB2(;Z2YLfPzK;Hy2TBLjI}enI-o`PmwO^OlTL;l;#oV0-%zU3SB!zKk
zDMo6!s?oYyW-7HYSxLsl0~$uQDfW~HNXllre8iV=9bU%is1L;hD`t9g>}sqB5w(HU
zJRn}t5qvKyLJTO!yLdopd#~jN^V}#UFc0B~^Co7U9I8B_PRD5}uk-e$?mS?hUMQx~
zDTdZ)`}n1d#bO#;$k>X6=Q&dO2pc-2?&eWjL22TVwc5*&R*jNzW9tcBb)JxN%Tu3N
z9OLSh&|*hB+33@GenO{y)6v@sP|}o3T&`#JfK;`}^-iZ{zmEQjavV$e9pRM<MTVIp
zY#-pwqm9f^)q857=KeL7t}XFw`%l)h){Hfpj5e*k|3f<c<ZjZIw3kgUo6e=zZyobz
zpi#{nZutx!@&IW{5<M&qrkb_IxEfHBDH4T|-eL3)1REaEQB8T9HLRJmmT)IOjHhET
z|NE2DaK0E$Louwn5cOoiBwuDc4>e5lxFp2zfCR^$m42pDm!Od%(czU+LOLDoW}X^N
zpdIPr0sU6E%@%U98Fi|fHZs)m|LBl#IhpMtW4lmXrj#vUbOduFI-hOXP#;<NOgdp4
z;jQKg4bs0#2Q+3ua!S@~2P$epYdzBaVpyG=!*>l>qv+BxkrcJ*Z%aUX7EO<vW&C&2
z)2<J7m9*QpN@CbWe_LNaDGlV5yhdHyJixKeas9A3lqVqBzZrWVlcN2EeO6rMfl$K(
zV%l;2dF*CRIEQ=`zq9mTl*s}Aq%4y9J;<DLp+=~X9m@ik=~{*G*o@M!>Kx${2YQpv
zVm=9)U}i-RqUCF!1!?3!o~<J^G09r(ZA>~bX3@4PJAs1k!a*;@ThTQ=mrB*q*siIP
z78~T4R;$$@xz#nTHdAeeR%>C(9cy*&MYjK^0kL2G_)YYe9k`lMuMSX;6#HfCeXfF%
z-v4iVZyuG^w&jPOo2pbL@4X~ryrhyE$shM6?^TkQq>c@UiZs$H3W|uR*o!ENeS^Il
zdj%C0JM015BlciND=0`~OQT`~sEEDC)7^VBYP|V=zqP*ob$noR&bjxFk#dab{`O|?
zwbx#AuDRx#E$xD4M<~3|a&CSQWj>ndsfO3vebj&8ba;rmOeePLYL=u0vP^z8>EQZF
z(tycwkytdhtHU(ixTrHw#JTPT8t}s3bhb2ht{@ZD5|P}Vz{)3F3)nfXxYI!gx#`IN
zckiMvYPv9&w-17jJghe{7xbRh$m5HO7o-tFW08+6jMpz9edK45q44FNkZQZBg@!L6
zAE>nmnOrB1p@J4a$VvlPAGpv}8qi)^OyTMVYCUQB;xwVDjKgQ{3E2RZj;wUbZ8wLV
zB3L{71+s4Hj%*GGR?O=kAH%=t57ff1as|})(86Kr0k{Vw(VF+N)ARwtUQc}#Ka868
zE!cTs2EhNvs&?yyFYb(Wnz|fREW?oX57uJ#O3eA&XFV{@x?u)%!&kejC6_NDOFo2Y
z`m98wiPg{MjMs^5nSit)lk7bJ6)ys$@}w_xM7A|V?f+SobW~(Vi5-F$_R?!M353N*
z^H9gNq0nD9aD_)d)cW)Wer@}LOZ!Yl<ApElZmp!D`GA%qpFw8G+R|AOo~8i`IauHf
zta4Q+Y}!j&rD(0v(?bs%_Xq5dIix&ig;OnN{WrxEX2-U>COpNn?toVI#dh&e62U{{
z0lNV%c>syG=zu0jO#{$uz~_@S!|{w2IHh6lH}`!&dk3m{45;7u2ioR1CG6LHuwInd
zJ-My3V#OQ*PAjI~pE9bW)$fD&+=ZfadYbwv6g@(XpP4asG;jd4aWx1KjJh9wnBp3J
zR{f8CPx-rN50vCaHuT%stPc{b9%KWo`%!qnThWI342di+T{9Z;h#RMSsI2JxJL#m>
zvQBWHaV%BWjM6lq@Xv*Unk%inBvaAV3N1S#D4VHd<aP6fJnHS1NdtQL^V9#kvv_U)
z443d-fWNY50UyP`g$CU4pv%1=(L&Ejn=L?hit^vV^{uU*l>2HS{gCYg43yu|_8D@y
zRFvbW!Ti@UpI-ARX5BjDfwjOkZ^=|R3Y`0626aRXpeI-}agQmAdH(E5AY?l~RMyq<
z0Picv?1{gHC}8auO#{&XvLSn5<HH7YLfI_V1>pmItPeiO50>;~PvF-iAiYpcL7};t
zb9jM;N8CK^ZN~>7@11Aa-W~u?$OF0(u3A5g46bhcQq<<MXfJ1v<8FwWYYGb>Ab7A)
z5pCZ|{wD9&uJkrKpu07vo;|;CdX6DIolF||RQz)<um#{!4x}%bDF-_4{r)?4KCL$`
z<OO?HQ|-g`U)gCpfr)gqu7s&eOf`(&w^Ph2&vGbIq(-AhH~0c2xT~d`MJb!F1_FZA
zl)Zu)(yWMSe!Um&EjoyMN<-y2pz2gF)PMoOnKzh6-neRZH_YSSXebOf_XC7MU<}0q
z5{!L-hr{sl{$(>fa6gHUyn>8|wV+Xi&|4Gj(0-%=E=1n=U@!0iCLo18U??fY)LM98
zEpUS&5j{PC)lg|Wxe@KCJX=hvH#^E<%-v_oi#8e{3WyHw8_j#2j{ksj$_0P<N%*($
z0PY1IJ2j+Uz>d+A+Klbw+_!m4>d-FjZsXV?h<66`b7TaX_p>Hn+HyT-xj(;r&>a-s
z4bUBOpC|VHoz<|h6MQKvVjthy9mPwyG;99ed=&+WQH=Uns<*15Z9fx64(yByXnlar
z{(x}MfYAp6fg=q>gmgj)Zd5HTz)fWl78rmUFa1$=HvqiB)(LhbDy)+n-spoW$o9OV
zx2lr3XH9p-q<CL6n9<z}lp`UKLRiV#f@+BdzJhqnOD7MYGO8<Rz#Y?rGeEBm6cnx;
z?kEwMX3oRU=$7jzOd6o`3B_$q3tWa7QExv2PR~CwaN)n1%%Hs^?xS6BKES0;n0vv>
z<2E9smo&rkOs)6*i+>LZtJMeS{r|#A;CPp8YkwWKPcz19)f&a9)Fqu!Y{*?zI3_Pg
zCzL3?c(R*Z%kojnvYvXJvLV20AWW`ZQFy?%W-tx=oCzK%)7%F|Du~vB03%Y$PlT$v
z-E5RZ#roY>kA<Qt!XVrbWr0B`oz@?fu2{w1MlT%NS+S^icMLDSN}?j5_V?9L$PT^0
zN4lb;x)W@B&Uh54&L^=F{3Odr)g?Db0|nSja3eu(SAVH1HYTJAy*AWea)VfH`x<uE
z1cqO6cqv-b)1AZKp!5hD9W*>rt~BqrKNA0x>*fMl35U+~fP4N1K;Iyjjp?`^8x52o
zWRG=38J4L#2U%gR!?QO150}HkDfHPP)oa~e@gc3l<qJ7{_Alo4Y~R{$ko(B@$##1K
zLZGtggW|+~kSiUhslQhT*|EY`?&XGK4KPt_3`RNaD9raDVTO9XVBF9yz%_{DTC^2d
z#r{%8sQMc-mzy175wX2%{n6+E&`BhKL=}NH!{y@sAXLV*RaDZn;*P3GerkbI>x6-w
z$<a;S)YmDYFoQgR3k8J*ty~~apd@@arIVt1^X2wO?i(8mDOPc~wRx2hlO`|Vet|Nh
zGcPdg8o7qwAFcO*d-?%>uzSur8dPFlLF}*jQZk@Ti*$5NO^&($L&fxMUz_5)4gY3?
z<ojjc=oL|`U%OlOd$wUGEle4O(yS20wRo;^-(1>P>Mn+$m_-kV;?(@=@zGsS1rziE
zbU(j_8d2AV0*q+X{unH~RtJJv*yi=BIlia~G(uX+M=GdCeURO2gC)?%rhMv*Y9_3H
zT5zx*D&V5AGB${Y%Lb#^B#R7kv#Hx;hgq(D`*JU-yTEm#uOilF1612s6a*ubhZ;um
zf&2_A9l4vO;z=tPxHeop>TXpqn4@JL`2r3rom04Xtj^XR?sT(kgomw(5*i}uyktIS
zkAGfd3bo#VHhBU5_7{M?0GIng>V$PXkfsC1{&8&}ZCpM`8qgiA(u$AP_(#KPHn8Y4
zOLJ0W=8Sll=LI)Cy?yHK&+;lB7)r|etY(QJ1@50fL@PQJB-3NMVA-|N3t8~`g+6jC
zhkT#YdKh3h$~GFqrR?}XSuokl;Q@AH-9j)HR5ooXAFC>yvZ$~<jS&B<6Z}x~iFhAn
zp_LI>H-@7&Y&g~huKl_bB*2)#?s74m)zZj-!u2{~V4=95+go<7^n{*A->f#28N@qx
zG!z)L0`l&K?lKFCM`upR&Jws4uRLxlnZHKy>aUgVsDCiEXruv62V9yLSyVL6_-8|u
z@iPEz8Wr)k{|I;hP%pMWQW=$l1;`{g`g^1&DP6x}J{kC}i4<G@ypE{<I>GeCXx$iR
z!>*NXm?7kdTEBA}YP#h!+!2BW)eL5i=KI{DVI=eV%Kl_uRoT$wbR4ZA{oLfl4ive&
zOjPM<{k(jXG!z>n<(n;`s#=x(SD3%oEyN2@D6XYq0_J$EESl<Acz$?<htymIkEj@@
z;Q2L_<0~8?nHxf+U$Cv3k|zjoO#%oodjN1xnSu+@K<Ix^E~_l7H%clyZYoFv`I*E!
zh|od@EY-Ser9+v{R>MyV%0qZOnoex=hUEwl=w)w)VDQLH3kDY*^J|@si~;$N&N2Yc
zah-a>NWf2kR?pLgw<gD22dE$XAIjQc60TWY9i4>#A7p>}Ynp#_)gWiarTtX1=`A+*
zdXEbO9p*mke6zCc+_<jRX~(v>tS_7lJJ6|tn9jsKr|KAaj%j@}$I!Lg?dP>~2i7eD
zgDIaRtd#VmbRu|#W2vr5BYU8bRIIdAP6Q3a$-VqBvMM3Kp{7h!KX*Bm76t+wCM{q*
zO18jy@z^Melp~u1v5Bw|3p>Ek7}OWuttZV*Wgs@7eo#u-6pYRt<vFQ7BN<YZW$#F@
zNe;JpFGX<eda3z=Q4PDSv*)ULGmea6jc9`gm=n<DI>63T*wFhyDk+$z$<YUtObM>L
z-2dynUqx1@k6F28WJE`)IN<}lbDwX@e0uIbE)139+x%r<U#*_!N3bLPf<a#?y-<b=
zLtj1`Fjh^~rYkXWA;TCXF+**9nh%g?^T-CwMpBkw(^!E5(^b<|o%e-P0<3@MJ@KQx
zQ2`q?QZ)sQPnK`Cp(vH54YoILl8;oLi3Tr;(H%fXny-zNn+B?oE}!Xb-6WVV<&lc%
z?A?CAJHL<;PO#EoQ{!cSpY!j~z^^g1=5DGpc)#P`k&^bsy;>YIxF|3Lhk}C1GMyX5
zIoAUR#i4}{&_{r=BCR^4Ut%sgqy@%-Ym}JxW34a{gAW%fMXhd7wcA{7%$uB#9M;8C
z+)>M$G@#dgs%Pr+LM3^A4~Ifl9C|LpSF^xs%Q){f?prFxqXz64l<mg;-ybD-%$JOg
z@|5%q5t6+xTDGt1FJZwp1=9M(P#jgxmY3J($kXy!vS^xPMe8YJe5K(kXyp1#@PZk#
zCplcv06Uz#00elM>j-#6WgL#<v7U^TbH=^_GI|gc0d@puc7|&}#yVY`lwU{*=YDQ5
zR?PO-0JcSkg$8)XC`~GikjFN6Xk{lN$_+C#mUKW}9X%P$4mcgFao)-q9oKvSOs(1K
zIj#d{s5RSXSgw;IQ_FvP)w1Y);iGqcw_AH1Q7<B~Ze7|Pg)6Dgp^7dXzr$tYVs9(|
zr?|d-MWEcvgS=;l`)AiCNWtM~nHFRCI1GK?Aa~SljZt`haXmqvmCu&rX~VIIaDjqN
zz`*{#YM#8jxd64k=RzLn<?z+4{oII>>o0GhBy-gq(7-_Tcdu?8QG$Ck_yc*!RJE4W
z7sf(swmd{eqDW-SkZuwZU?W5hC#g4Ou@4kc7HtK-u<>#zHWr@PKG~#OS3}Qb{oHPI
zC*1`$MK^fMwSLAR@2|mTfg48x@zu_HKs*Q9uLn41%wPhb)qa2|qH8btixxh0D0cCo
zueJ9J=RY1)K)Y}8A<_V;7G_syKqim0ZOP30oR2is9N+4v#A?0$j*`2%k>C+MRKdC2
z%y7v0;QLBM;}ncTY1UZTzrMfp>t)#HHyb97*DnqOZWDk*6p6fv%B43K$=$+PGHhTE
z_4gE1H*dMISYF-2;)Rl33#Rn8egxZ?8WSK**GMCazzY_j_Ggs(drz;<a_#g4T$`<U
z#G?|FUo>U}N)njE_3Y7Dp~gwY>0z=U-bdk{_+N;PNqzoc2#efUMxn51gj(h7HCxUj
zqCW&KcEdVAhon7ZXn>@XinBkV!JA1e7xw6VnW?8?h^;H8g!_r-g-$d;`v8MgxOZ?E
z4blL!>6rM}bjEjez$O*z|Bhu}BPZL}%C^VN!zTE4(d~|Vf9idYZgR(HI5z715}x-7
z=m?1!t0cv1wYMKGwU>qfqQUpE?1JTz^**~cQOZw^mbsJs(5{pIpG5)pBuAk{@*Log
zI9>us1T2;MlKC=bh_Cv(4T+Jep!loXE94o9NiLe+*Ws%tj|~J3@cE^<&yd~8L)71W
zJUhv?Gm}7DpbzkfO5^MVnKa5r?&eRlFo!7+G$uh<7=erioh5#hCw8sewTuJ|hXgxR
z@-q8KL?1_9;c7%UYKJ#+HeoLbT@t;e=s9PPR>S^5y4mZnJ8h?B<fHw~_V?oVae!4O
zz;F7D*8m(wg6G`(mwiJTF!_v0YZm)YQ&A^u20O#Xj~Z|bJ1SbZd0PANvG>(Ep74HY
zU+OVm%!1~Xr=X6*XlYrWYd*wtY~i^4HeQ_w@hlP&H#M*DLNFiX+#eV1Be{ph>r#Bc
z-K$&6P?B#s0EOpnu8<1{;#K)XK9jO^u)MgnT3+8-i?VvFWZ|?hG-zvY^4K6$Iz=0|
zSIWy<D`e05Ve0QbJvyr*ccibE1{h2^2x86rzDlTgaeWr(V1}ZFr)87mo2>&ttz5mZ
z!Ndy2U2FNtfiiZmHXxauZ|lfWtIpAeC+d>uDMtraF7urB2F<Qy3a0GG_4&RvgqnEM
zsdn3V0r72hLdWl}fNx#hi(J2!jR$E!hvh?A!T2xkRvm5sH979U_t(hVKzCbe!@P0S
z?m1>hUA@Hq+Vq(2QVrEiONDLjzo?9tI~T{v%7k932&sep->Z8kS-)g})Z}yS6K^XN
z?q1wlDK!O)r1Z=jIkG)g28Q)eG}FbsBWik&MrCW3=i4AJa9nTbd2V)ON=z?#S_K-Z
zPEr-H_ih-eo>erEJxg90Brq_T^0QM_W%@@~usDD*P{`D@Fdh5=n+o(?3y!h)s$nv1
ztf!T5&6l}4a<r%=e_Fzwv(_bXMsZy@x~a1mr{G>u_KlldInoKfTpd(26qn-iEGm-p
zJf(4gxqe)|0M|YMJk0d~zlQ=`+KA}j$Ou~U0eZonO@sdjgF{Ylr(Zv5fYxwIEnOhJ
zdcfY(5&qhAp)fU~aML>D3oYo!<pOj9ME$iaozYY77mR_(1rCcXd`smtDLgU?^<Sx)
zH*8<Uxw|uI2>3R5KIZJJJDl5Vq^V-1oY*}Pc=u9spLl2EJSHz0D)+CfmN&Jj3SQT2
zmg>S4vSen2xOLW@oDvg)LYB#(krWi7TrYb!j8V_~^l+1MBPT(<h%c<jo+*6-yU3v}
zBjoYb1ZjqV*-`~T#3C>#;Spc(@N%pyo9U;%jve_JM2B}&-VpSRpz%>_(&z>2DF&C=
zr^QsW(&PejE5a*op3)&!bj#6x8eao%U&Ex<=F8}4Hq5doq@8d%pp`7ZwS=kL7)49k
zQuhC?iJD~&4ufMDUTor@R*%|qU9soypo|5_VJ_8F?62&7`__6|nbyZffRfav#NODV
zbCsR0W>#~>Z24w8^goo#%mxB`y36g{xfa~7#W7i`3k+E?H&T_)wde1AX4b@h^0<71
zys6s`*decLalE@jL0$1$89!3*52lO*d%v*}G_plrfkyUkidAcYpMjdZ73UU!L4ZK8
zkW}Q%L5JK_waS?jf@R&}aJhYP8iWN@yS<U1dfs?-3cjY#C*z;{$USR%KtiUbJP4!c
z56wEPrkB0NpxY#kjx;dPy|$sywrMOr1P-^#5`GDJje1)u5!;XnC>Jtjh`K@QhK>TP
zBWwPqN|(w9OVk|WKRRHZYZ@T8T0ftHp&M2z58&TJ*?vv=Z`znn;9Q_!<>%20Ce|S3
zs?$b?TD_e7U{CS@c~Uk*iC-^o7~ID#kjzcP)v&Xd{X@D*ZQ&B2MDz7~B`Z)?Gt^;i
zH@~KvM<)~&pAUTRLTT3BQgeBooIA8Y?w6v%{k=W%x^9;o+CEM3g2^$V^6cgo+?S^4
zWZ$MZ?f=cX%$4Wy!kUe0A*nn!U)A~KOSmZQPZ<t@1i}IZ25d^6T$?SslOn{&^V1|E
zwllOpyq<HYL!vIJ7p(367<KS}DioiVXhTzVb~mWjJ1PO8_8i%;JCw<tp>*y5cC4L|
z$Pc(zXhUzzIe!em{lLEjlmS|yfw{vfvJ?-{{=ap|(ZO}VyqWuesL-#W>FA*Nzx|p|
zS~#^G1gqTgz*?{Lg$dT@qdQ`=Z63Y4ca+0hAXQfxm{vC_<1fV!CxZVEQ)N>}5B8Hs
zWvk>3QBu2EE}vY0(%G&>?f~Deax;IOyt}_&TB>(T;+$yQ+gUcRij`M&`&3EZlCvw-
zwW+cFP^5N;D&hMYG_&8>9IqLHH>B1J%fLjofJtlyJuFr=!C9|6EeV#YN-c!4qtCA|
zlB~25z`yGb*?+0|n;dX|QcsK)oD<;vL@$XmX<lN`g(`WTJD7nlE_zGueh<ZNslO}8
z)XOp5a<*WnbPr+lG%Sz?t|85m>9}mZ#O_#(-~R&ew*We#TTyHNX3S7^Hr9W&z`)C`
z5?-+OmPzwQS4aABAK642;C>ILROo;1oC`(FxXs+|>N)3Y!G75PXQz+DkYbOACD>f=
z_oj@MONVEn<nkt<WUJ!u`B@9wrh%TIfr5?luKu9BtjmxM%VQ<Tue)Syoh5JXp)fhF
z7oS}tp55GJ>Uh}xs`uhrhP*NE?U((jQxy&PdVvq1Vl^2A7nG_COHu2$t888|997ZR
zSk{O&^8ChfIkPWTg8dwo7tUYjd_EQi$m;WSP{Hm9BSyQUF=ezKvIMwHKQ7QhBE1z;
z7IlUWzY`)CDHn7BAJ7V<suQFEO$W6(9aK6+=NDPd>v5!h`2Pmb>97?IK&E8;zg7m2
zunIG6e!b=cWHd2@J0OI<lXATuKA?k49ZlbTZ)n3{11P2bk8XP5aKRY}Yf6yPo|w<K
zf3(PdeS<tC_sA3_qiepO0(l<t8p>`H6-3Fa+MRMZZH85@b8gtJGvfaCEtGc;j>`Lo
z-^i0&>2jxdyEIoHkoS*{$(#D4vMXh}bnN)GOo@dZusTED8xIbHK^&CyEi=^c_<D7b
zs!MCt;_>$0E>*idW!Xq+s)CRKzCa=J#jPX|=Tr&r)4kP@I(N$coIK#0Esz0}Q&S{(
zLAV&lxAnA&QJhvKN9a<ag~Ucgyfj_z4t&!o#RE=>o#BK=!!q!%T=qHweH~ORr~QlU
zelu?1?*Q%qSNlQ(v3rbofS^gn0>V0*=12pK0XVkV4H8RtWd~*mMs<#lTEWaUfc~7y
z^-8(lL_yy>NV#U%b)=1vvXlRLb3|WHDLOtIa(arA=ik(^<U0BFF7Wo9l6%aMsBlO7
zpND%V2?^>ULH^xA8y#ibh%l)u-7W7QpO9}KpR~X!dH3jqROW4!ArabcFlGEeX)$UK
zgE+F}Er=!^%z^@@qJg~iia~HuX{_2RP1i|?5G>IlGNr<-1c?aM8_|z{rJj0}lHy0f
zld_QdBmn5ZxOb_)#0__3B-6$qDB+|x#B9ALP;u}CbWnAo3*2tBAt7fcX@Kh5PT(7K
z;ch*@EgfUs&n^HzfU~_=>wi~aW6@Y>p#c!q(M>wsk_}Kfk+aL)5{idii}C}YXN2kZ
zrQK;B<cGpG2<e8tU2wx`E*mB}d;7s2)Si^&gnzz}5Q)8B$*F}{`-%UZYC68TyBD(E
zV(Ay+?LbUH{+@DV*8-`zx=X6B?2<j3=YSSGW!B`Oa`k+wJgYe-FYlj_raMO^|I`K<
zHMB2yfZiJ}G-i#I*Y(FiB$`0dw<ahC;pfv;uIFz8GdTo0-~y5XJ^^7u36*J5a(W5y
z@8wb`H9x}Dk%sQ``>7p+H4GXu<5}qtWq>AgAc2JVcYx^CQ5hs@XxyLF6>>m#u;y-1
zB)D1A=<wbn8z~D=MnI$_RCvp0*tB0xFaI6RdjbXkXj3*vP~)GCZB)uf%>x(*v}ctK
zZ<GTc<wKJVLTo7XlFNrY5r#uMF#SJzf$#TG{@lxEbXRUR)#v$zwD*pb$Hk*0afYAz
zIJ*~HI?x9G%^OD#4V1ET%jGp>`*-)#frd<ZT(wJ9EgYlJ#QQks_ivpmZysQ-H=LCZ
zjoI?5{<LgZIYqrB(9cui$3@D#=_6(Q=mFyAtJyYbV2m*=OiC|qllKkT>cRJq&#1=u
zM?W7pp%-jbi^=<kM=Z3E2|Cy><>yz)-~o=#C}yYIJ94BGXZXvb%g~BKpJ;H1Zl8;k
zQG=*vhv)koPk6-klInB8aF_Fy3DKRD`knhW@9ws&2j)w515HmYG(Z*3#zl_SbMrnN
ziFe{Z8er;&Z1x}ajJg0F560Nu&ay30(*WiFohul6&5f!T)`)J(wSMG4#D!(kLm~w3
z*?nO1(Y_ySD{ZB}a>b&r2lc;Kj}LP&^`a9%&qwgDZ~A)~IXFlvE+%2<Gvz&&?Dr3k
zO2dtGS-xPbbn6P4Zo(j`E!{8QHs;8Ort^RcfQyoUdb4<RvFR7g_IT{p)m_#aOD9WR
z`5}4Vcu_t)0pP(mkFu@A<LBE=ZWg71Kb%nO1O<z?^@pVL(t0owN8_V?<L&(pg;D$J
zaXKx<0sk19Cs#+w?lsy2cEYeOFs)Naq=#Cl8rr-JAFFekbHh|5(=qkQW$qWDt_9j?
z(s91ea!$Mt2aE;qw+;U|QFD|Eho?#xh`3I~|I%W?zY%t>Bn`kb78{i_paEal{usJ<
zCkMU&*atks8Zcp)Z7~}V0#*B|K^7hG1bJFE5oY}`rCrf&ej@(O4#bY^E0wvB^MMAg
z@9)938*d$!<LS$!zUm<G58OYwB;P&BmG7SB;dh>#JeUL?VcV*a9=v;WmB{d3a@@#F
zl9u}O^4+sSKmi`gmsbzZ$@ya&q;GFu+~^@|j5ukoJqG4-Mz0eOkE0WtA!s-noy<;t
z?C1t9$hMXJF&b0Eph}#kk;>CUA<Mf-Xiz7(%8{kgn;C{@Y!o=Obr*t!ibUteBl~_0
z_uS6dALxC8)*))00jHt!{WvGyiT_xDs{h^UCY{5Pn+(tZ6p~4EwbhCZ&Yy^!e)*&U
zUxZlnl){7FSoi5tO<#~O`1ki#{(op(waaH#%<d_TB{9(d(v54XR9}jdQBgGK+Sz~1
z2R`LEIvNX3K3FsG|1J1E=ly#V_rN>R_}$Y&`2e_IbzCM-7;62<f&GK!$i6jFQJ5)r
zjmi_asaU>mE>ZB|>1AoCJ|o*x=8La4{KBygtTy7M@y>AzQ#mK^utr=j*dgOahFKf^
zlup~<GkUO>ROi9~O>Y%?Bs?jd07G=3%ox{0E+2`2_cPpN;mNE_>fi;<SHmC^20BE(
zaZQ*zp%WaFyJG$4KEY0pj5T53nl|0~s4pfB7~}9CPaM94IOD^V1ISd!T<p{I&>t{o
z7rf#jpz4@EiytTm^%4BQ)-C8^-PD+E`+Ikk3+dzqla+;yt~@7q8K0*{F&i_F!v^)1
z%6zcr#&de!E8KG$7s}(?r{(y8WZAndQQ~3-TR*Uer-xiRl_npamCE-<%QgAI3T5)H
zsaVSLGGu!E2rL|KYVp{#c8)x&%SNMYI1ewoAXNpsfdBs1M$Ha=>X8Ph(|g8<@w`$S
zn_8e2&pi+=Tj7v$FMkxoC%8<&RhAnCiqy~Gs7m+RltntCiA!>yfDS5R{@z8MQll9L
z1)A-(Eujn0=dRG$MyD8rrtm)sKU~tl?o}oYP(jrN3JDtnB8@Qq>(ut{Sg`!0sW=$=
zfZmV?ddsFIJ=)X<P9BZiABAyBlMemwTxlqUAJ4QtUp$mbjvLlb%JX;2x8V0=<=;17
z#_u9IjCmgD@8!V%IU2)<^p|J%^W_KQWtIG3g-Ut(=rSHkme7y@HTQe^beA0);Yjiz
z*TN$%gU|}3s%XEA9r5M(XD61;=_f{Gnf7p@H^TkG$+CQQ5b#fLW}3_435AV9Jt8EI
zrUuDo!&_#+wVt@=@J|}i84>c_C)ym<X<TeX#vGFukOn9t@_xS52@G>Fh{hlI+xZ3v
z6Er+%MI>o}X*QhiqY{&X>hhT$vIOCo49TM~Yu@Mla{g`Kx&cuA8_@C5&j)@U<!5Ke
zpnjjXr8Zx{BliJ=2K17$+`aNG*!cI)uV8AIO3Q-+*}r3@czboTc8K?n84(Hp@A@M7
z@zqT$eA`?hX{pQ9+~-X`cqlz>mArUZWZ@H~U>qfKEk9jGM)z}Q(7rRD@;kf_?0=Q#
zU|@t1nj=7uHhQcjO!SwgQZAMBXr{qA8pG;kjgVsF45uP5s5z%YZcXDNv!xUt?uxK|
zPFc+hp2DSX`%>G~wd<Uc|CI3%7yAQT(!hoVX5Ke46%Ry5>Qo9QA@XScHgV0Pd5w0T
zk&#^_Wl5lN&F<Gr%ZPo0p#Lp96$cx@B4q<;foe5#^H^ouwd>_)4|7yRh?HE|C*MB1
zDnGoaz!a~PH%+B-{NQHk9c<GdbvL?ok#i?@%l9vC$xpBE$oDUA$({0S>DM<{y)-z`
zSH8)F;jpPpetdadHT0pmOiC`MOXL7Y$FtAvFbx{UzKvs{P+X(5-!E?_O6jS1xKJa-
zN*rkbOC{vP=JN59zOIjT4s$riM!CzGodICEmPjUS!<*rj%}gqp>pUbJdcu8c=)R$O
z0jDlgw>fpvD*tnH7!IJ4h{^(o8;Q#mNYB`$B4TNv><VwTE(pbULvRU>Ngnv!70_LU
z=cgxo!E@F}dCz97^G7&Fpd8&2f=~^*V2^|3J3&fMjFRX9hMtoNlY->Y)p?)+m|0-=
ze^k0c65<{Gd7L}-Dd&*`LL~3(Zu!t$jwyZva7*4dS4qzCT@oIK?VDlw(muTdWM5j6
zT*>=JP95DL<71-5&8@Ta3k{a+tX=Z$^Xu~C>)WaU@`!?*eKIsE%wd#1r9;m581trv
z%cE;FF04~u{<w6pES^qWBV0BPo{VMiR)tr4b9tO>UaE<bjm(PeCf84MZ=j6{+#@`N
zfw|&DPgy!0*|5NpIsFc$Foav{kahYd2O6;ApI^e@Gk*Y+O}J7PD?72y=gG|mg-tfx
zLm4oi!NcVlEZfux(Ju51A$APOZ7z)fFyw}DUkvA?KiGIh*v~7Bsj@dY0*i(A?>)2y
zH{4i((MVFJ*z%mkP_sGe`_Q@19(GRS?5s3}`=4G{%TI4=<hvKQCEqxAKn6$J_&9}$
z?%m)Ijw4?bJ$Qf=T|6S+y}W~mYSn}9o>if-oeqrTOFG48jL3ezN|{Ix7J4!9%Wqsr
zfZ?f&>OjK8K$y$nG6B!!=ZJzyU8<E1RI3&rg`Pke6A<-^$Y-ix&ZPOsm?*6?;<Tl?
zHhU-0rDa2vt`F)w3!8SpKVSF`-~ph~fMvK_4Ru^JYdKKapnXJD#I$l^V0;(^5#<}e
z*btjtNQLIAm{0lyT6}@w3;Lqcn4&fVSvxS@z}5J|@IKw7JbR9s5pQZXLEWAz8C&Ap
zwEem2WLwt){e8gBQ{`Rr4f*NqUHP5y?w<Vcx=zZAPfP6BVXeNF*D6ZR$PaID^Sk?i
zdwBS!WF6cpfdRg)?r-bGZCy9$rF3xnba`1r4;END@x|l?*U!%te;;idoTF%f`@|XG
z1M#2%z3_zicaodg&=aVr*GQEiVJkv!nRX*<ix<|19?%K9!A{In4qAOnN7M(o9<Ujy
z(Qbu*e$jKl{|opJ0GGyNDjlk`NdwFeLLR`pjy+Tkp!(dNScLomL5K<IEf4bh0{Sa2
z`iF&4@(|XKM@8_aEsrJs8M8ALTyDB7n;qgXob=~xD2ERieY;=-d|a_v7S4!LoDm&!
zxc76<dw6z}y=lqv(rCI4oYu?l-an8Z-_}cYRh~?l6odKSQSpENuDwy9{`UL#57m9I
znr_Ixo$C~z_}mve-*3<wId58&G+u|5^WJXtr6w=9eqp}QBZ?2rnFz-rL_^Rikq(KQ
zm+H}?lk!ajF_{LXlA|G58xTRC9Srsh^E}w`!+bv^qUZwGJqEREXJoqe0F5s3&llbY
zFxkNW4!8<vHQaPkympNH0!;(;mpoN&sF=Yp!2!k&?j+-ebXE{M)J@q17=jxE|KQl@
zuF4X2dY2I)HJ4(f`r>#c`O@9Se3@IP4iY;&KyKz5umx__W_g%jDla9=;0VX~FY}qt
zJ$e{j+$ALmUa$`<f!jy&`)?o1?*NbL%4EsHnX+j940&|7OkMl^hX(cc=M6VxV{)RR
zkI#Lf^Zf=d4D5%jW_c;lZl{9=_UbQHykMhTzp%iL27=*yM2EyVDjIIfa=mK~2>=b`
zKvx8l3w1_$8NDQPJ#2>v$yFg*4Aq0Vj%M43c{-SxZ2Q`=E`~MTo^#J|UIHNgnSksd
zpp`=*1&j-ONCS*=@Puus2lRtB6yg~xI$i&U{@1f>2Lyt+%YZ)cd_kO#c_URMtLG0?
z{(toARDJ-k1Jfk?`d)?{-@g#1S{=4;KJ(c}jK6vz*ZgHm=19Z6a^Si_{_vqmeh+xj
zbVpu3tx>=K@LiMo8}Bg|&BFZeYVGW2zu59#yq}f`H#wD=2oHtB%GgK)(_45a@r&tn
zaQ)&UtOc46Bus)wb2+0I5<mkpWXm$Ggbocts@|L-%BaX-l{|!E987^o2EC!_bf%VO
zEYVcmT9O+WDoTmYMs0k-5nLz!=~TEBK&6qxy%Z$UlbAb@3k*{E7JEtBiZ0lIbg)81
zNJpghLlh)Z`}FVC3DFasrGM|vG9bio!w&-S-$l{DfIeMiU}!g)G}>Q|?~0Yia`*))
ze*o>f_vY>%HB)GseO8?b8_sy~aCdFvaqeuZbBw>k*YJkvQzl5wjUxFS@c)PJp2{D-
ze`bZ>ecOb;U6yH+$G3W}RpTz&cD@Ji*P4sur4!{joe^N!;FmR2?U0ApHfvr0uhknD
zmsn|FZhUWfQcj1|d5DyoDXA73;99_76;p4Rml-0n$1_a>Qtn(agIJ-eRoQP84S@4O
zeos%*sh6F5hjTiW67Q-)9*!db_6B6@D6E=|h{r;UkOBJ;^8wz;_JwW84~!=e$6y#W
z`@l~u3|>&-fJi7dkpHFT;xGgWjY2>umfGA2QkNeubp_MqZs8nxcx55tcUEaxuvYtm
z-MzA2&L3VREj9ZvT1S*w?tb}xi5ok>Dz>AO){eFN8{^;RjiW{kk&3Gq<)?3-0RPPj
z_?y>a#td)sxprUZ^gg^_cVNo+D7jw&>n1E3bVzBb&6M3KQ(*O60~*)~Ua$>(z`$C-
zz!U5ZC-s)670?~RG5LArEYLux>X4ELau{;OfTd{3&FG`jFwKqgKrnMp=!X2@ct%Hb
z<&19NhYx%^dSHLwCf}w$fcim|lmtia58eV=jlh^eEX!h}0qyNh`>@46fCb6sC&UE{
z{@*G{NCk;-L!gZVT;Ukw$rwMzfzUPkb<KMCgl&|f6N@BnbRX#z&|NMaTLxR;QEi@m
zd|Iwv*d`JE0$X*=RcF;TjQ>Y(9ugHHm(FF$_ir2J$M;Vp|KdsM-|x#6*7lvj`*jEU
z_YIIM7j`I11`Unx9%jkKV=EB#&=U@6uzXu&!|Rt4t$ZLM9`3gli_}Ol+I7qFF!eE%
z2X39yBTJbeFSD=mC*ixeWHWftnCcD@-H-UE^4Leo@AUICJLGiazR;Sr5WoLDz-8b$
z^MO_zXC^HQo7@vJ|F6BT5QGvMx0SCL=D(6!%uOLo;w_cj6Joc6_}`Z|7J>$}Z|JMr
zYvp0-D%rI@MtTR@bh(qq^_Rw*u>I55tMRP7h57z?#%g8XclwCdABXX8eX)&eem#98
zbKiCa{Qc3!+i1uBIlNzYz}u^<oH&rA9TDKcKu;EWG>wi9k<i}WQd7K1IUms*?)t^0
z65wmm4@@Er&^dh}+^G}52kdD;Z?_qWmkSzj4qBc#yfgeiu~#!QoKzg|-kv<@5P*)3
zQ!Y3GXeAfYfBeK&?hnnpF-+U*i|iTRlD&&ZWYX9Z2rzo#zYsWzh03{o{Q(2z-2N!Q
zP&uDIT+U~VmJ6BV5cfAh&Sg%LqdUgS#L>N=>(_+J<D{{0;W>x!jr-sO4X5D7Lm!Zf
z@}fRRQdZBhs`AZ|b~t_x{>=xwcc)$0r8@nyX~K$sHohqd0VeeqU}Vf!U(j5eB`X$=
z1E=dDhtlx3T6(i{f3Q=kKm!b1;ByIz29_u-dP~(@@ByvR(tLn402dtC5_2;gX#k>|
zfjmx(PJ<D_A{3n5t{u?LuXQ>S-`2!L`29}+a{;Yr0N0Qkl-V<FG?1I_rBeHn3DE|m
z>c8n9EDEB5+HKpl4oWXX{h$eK*n}XzuCgOJP9BtRhtxz_0Iqxur$GazJ-9#`?wpYY
zv&UJVF`rdOjKAwY{E@EX{kj8gZk=S_OsK~1UVx#oSQ(q&K0Yr;_9Vi)DH7i6>*eL$
zgO>flKF9+*B|mGv)lxDyz7P0-0UB70ptX5c8t5D7hP8lccj$07Lh=rT+S`#>{|j{)
z_L5I)!LYH&SCw8cJLYtxt%&$`$Y_ppIv2W3Lc#d4x(kdSq`--EUFZB{c!Viye5U^o
zUSdTT=l-xrKe=#Zfjqy1eIb1O=@<4Me!kD)u5-WQfPC8oUm&{nU_|RGPRQut5sotA
zpAG)`WwE1?I-%+eESK<1fJ4d$I2@E++9^9y=E#F8$cFebe&M?Z2eB6Hhg`5);>T)R
z0iP!gJgZ7nwnR+>{ncpo@~1ptQN2Sh%+0XUfY$#+hj+3W62S-RE_lPh)TS&zJh!TV
zhHHNda48coh9Gx8?FFO(7`844%BIC!!d>8>F0x~yx=KQvkIMD5U~&L*JOlxPRj!8x
zQ~Rh`Z)4T~NlP9hwU^hb_%G!jik;Kj`Xf?%b+@cs6s!C_>&g#<28z^(e%D+o*9s2F
zfPNO!-Jccy2Zr~N@}i^ieG4p>EoG|5_pfJ3!PzbH`oUQx6Hv<G9<lk(J~@>>PiQ|N
z?g`u%tXl$8%XLQ18`5%pzN9YKG!Pn0K0v2K`V@c$GQ-FRZ2G^XdEF49$Otv^fdG|K
zy&b&(WdUp8xn1xv0}s>94%r{6C)lvS4Y=1d!1tj3gRe@nWPc+QMjhPPTkhtKkfy8f
zjzrF{r?7%Oy*3LRZm!A=z?=_^`G0<salOzDsThGh-~s8_Ii*W()+$I&S~EgZ&Wc5F
z;k$Rv;uCO9zI$FSxo7rDpaFw`{mcK@zd?T%+@Y5=DCA|Q%XckwN~uI|%jEg}OR{V8
zB6(5+$p+4;^mcm>8n{=sOOg{~AP3r%P~?cS;`++XOZ2Ef^gL;xYQAht)bfB{3&;nw
zUrAnO82G;>?JC!S{7mlENCUyZlRpf`TEH+nX?Ns$zX$M7P2Afbah*Zv+&8uw-68#u
zWBweKkd!+O8VQ0WcBt0hFjRKtxUO>L7~CV7|5NP?k+a3RFT|dp)xMCSIjN9}5dT}Z
zTk6ZU$mZ2?642AOM_@<jA985-3iyT;YgZ1q{k%7xRmh3MTjA&NY4QB7zUb#%v*MqP
z^z`+TqZz64;W;hUH<e@3yC+v9bLR@>!T9_hoYYAJa8|D?-6P{ig{iM1-lO{Wl$c?`
zYIpSb+G^~Y5k1We3fMh0lqM(+O8%f}0Ko@}4~#OfIaG{5;VFKkJCp;A=O92|lhd=k
zydQr+rw0ODCM(7D-vS;0TFHi756<qSV}hZT15aTv&Rox&{T-1c7{Nt(I#H-iH!wk2
zzM3nLjscE?&q38K*OwqC$a3X9@$wF&qw3Ald~1tbKDAUPj&bcfFf)Fb@(=nBE<AMm
z`;q=%9P0PY*JaQ4HNS{XA79*x>f5^JfPX5X_wGp6)=4;{uw&#@d1rP?aDb1*kB5Hu
zK6W>7R3{B&?Kc$u8P&KgDNgE2QV^)NNm_2hhG?-RGph38mH8^GPERi_cF_U-_IX7E
zU=YY?l6OGU0Oj%n8^E6}h6BcTok{bA=-uWQ5x*{zR9cb|{8Rj$>p?3T;D{`qY;=aw
zkVa#zAgaC48%c$Oq_G%Y4YX`Sd%+Ig&mSo#(gr}P?JFCWzzfm{laxdx8(TUM$3e1j
z*$_Z9a>5LkgvsHE{j_mKTG%-EgZz8Qw)If)-=@ni<bmh#4KiBb7-FFTItILKtdI?B
z7yr@dzybf<RBl?g6rHHj&IafZY2bF*Nf|XvYd7i1{K7&53|cw7YoQ{xnUf-=>4uJ!
zQUR>c88cY%CHO!^&TN@CxwqBA&Y_<=)*C@6<A8tU<ziMFi$I_<8{Nug9G5m8H55Yh
znxymo@<AscUUvc7t#*dL_XGS0aC#o{U!MRJojb|}!J;IDCyPx<7=<8`Xt{PG63OG~
z0jGsha<bNqIXAA)y*=G!)9Oi5aB3agb`je9Fh}jM=_C5R0U~(yxJX_+Dpo_SoI~E$
zN%O;NvUKq*@#^t;F`l2=Df2$V{J|sfzuZ9Lkw+EE(cmX^<VWy<C-(|v&h!}T7u(YS
z`M{x_3-RpNlD2*dqMd0&goT7b%%FjmTkGWH-ih$6^t4*exsx`g2g!|`vBW>qA%X_r
zXnKC1-WY6K=7Z=|`tE2NC_C0uIUCz|*6ug$0mQG%b-<Jh@ORpiuLG<fVwL|X9By3P
zMQsd}0Ai(q2zWIxMQbl*Fmim@))0M1x^;oc9yVj=d%7S#bk9cQ{kse63bgBt52Joa
zX;};~g1c2GBzeUwS+@$pMZ;C)2l&(5T7`m!d!;gO_T*no-{agl2mJGo2{Yqige;Sv
z=#&6w6FMEeZYq}zYvzL~ncHRrl431Td;nka9=gJVX$uq$tXKfw@oL~-(EtKgAsOAc
zv>0ABHUXz!Zx1=JX|O!LGR07$mCkGwBMl|PB{k7c2K4SE6(<?juW6vExHp_lZ7kLK
zD{x*4_-N%z+{5JM2>^?qsnh<C^}ni4GQkLhPzw#zoDY-bv*1u}5mfQ81CIT@J4@2S
zFv&q4fxIK}lCf!wj2q_YAE0tX6mG%}8eu$2Ppl=WH^!s$l7D6!oPh_ZMtk~r%CXE%
z@}UI|LKu350-)kSO^J*hWeXy4?!=d#x5EF3VNp_FeFgZZvx%kwI-h-$xfup$t@AZs
zHhBW&0sSSUfkRje$Ojk=%}Ckjw|B^k>a9|Lb&af9s6A&mLuO70lB*{tN^|9G;Gfyf
zAYRkqy!O&?*|@|Xae5t*!`~M?fB{IL0muVYrvlo``$WCaJb;5<$ejDmN8I<H0gtWo
zA14kt-I9oimST9cDjMjAdJv&VBJSG88{WGMbi|`z6-OimbBQ2d9P`4}6eg-XQ07_@
z66h(_#i?rdY}yLm8x7~=^r0m2_q9zA|DIlQ^6(Z54b;f*;3)Rv+k5h;_KL)ej&|s%
zbH_jTycPc0z{K&R<uRR3=x{_nfDU|sgYu~(+k^yazJxp5O>1Y%y9OP&$l%ojY4a5g
z@SY&QZn9u{q^v`fP3&-_WpMAPY)3oR43+v~jMj|>P#7}P8G=uqU7IAAj}DQ^qq$HZ
zL?XgnZl2Zto1}rJ;=U^1tNC&lNBRtXwBn^n3%D1Fsti@#vXxT-8;=O-0B=_84^)B)
z<ZVF&%)yNT4mALHA9cltQzNm{W!_ip3y>SM<;GH#OXPL+dbyLoOa_N*EeY3x1KW}J
z?H)otsZBFrYI}6!h)fuRgwYsIHrTIEfSfxHh4NEu5a9DmXVD*D*UE$HBAGLDqIh_;
zxhuA!hV6U`7;W7|=i`~vCP@9A%km?f4=D?<BX6Hpz<YTIoKJfSBbicG&z8pO(<<VT
zk*}nIjBRsWzMT8SxKTlpcXS#O+5q*pmf$}Q8HVn`<w+_hYiN*`^*F2<>*33*YPHaZ
z7a=w$f*b<SoH|b)uo2)=Ct%{;@re3Yc%U2LHNa)BSqG4H;8c>~vH_~rOZ-U3#b`i?
zyWF_|heD)kWA50a+eS$0iYTcoL|nn0b@K8~ifmbpm~o5T7|^q;q-~fgB}UE$xpX{P
z7R(%}HVNzm14Hx9AV3U${(5h4OMZBDN9wL$l*w_Ut#r~>hd<|foA|eHWNLhj)Kpyp
z5!QePxF@)UePM+Zo!^H@w(aurA++4k6*Kack#J9|kI4M#tr?Y{cNbZo7%g>0w5U=?
zu#5%+Y@@HwlZrFrW&UJ;*ko*?^{iM=mCHkyOF&tj;xJjipqnxx+jr3JHxtct1+*&*
z+Gs%I|2KGmio-O3%Z*}y4?I{8QCGl3GYA|ijg)*?GUx$|XB04x{G(zdn1hGpol8?B
zJfy4I@f=7U1OE}~2{%gC?x{etO-4lhudm@MkAi@fxzEPNjtH01OAI116-7|Ry|^wn
zOHWJOxYj<xW(U6H_(}LT8;%_tEw`>^gBTfzK>d)`5mKAM-3%q#_YLP^D>x|YmrsIM
zlx=j_#^CUtayE08JiCF+Y8a7McUHl@0>MX(W%E>;?eGvs0fYIw3l1Vwu9Vr22Z09+
zK)i3DwXBZWF{k5poVU9lbilvuMDc>oc=)+fgH{~Rf@d=oR4O{Y3@LQ34u+uOZ~gn=
ze(-k6LvR72YMaVtL01qiQ^p2J>FJsHTE-NlNLlt`Xw5BZUyQ%?VZM}fFfk@lDhu|i
z;9;6!sEYs4d`+q5$BrE2Kr3x^^i!|n{f-^@l=BfoBjj4)H_#JT>gXnmt$<bz$^w_O
zQzbq&5*@WoW$uEPCJdF^1(^5HlyM{wYk>I=1yOb099gp<46c}tR&B}w+gBisZV6*I
zNCS~j*M_0S2O=c!w>COU9$-yKYLDL5zg^Tn#KYtT>i{l;(Wt2YCKbs?5L}|2NCqR}
zc$CDC)cRhg<vX_@k}(8ZdP!0)Y$&5f9C<{PAJGPt1G4Jka#>(NJfcv5msw%n^x<;%
zS|&D$G#(aUY88VQlt}T#{l7@ekNvy82>)z=ggT&qZ*(d{MY&O%rR>J&@Y9-;V$6-P
zE@-?zvcDg)XU&u+H*_{Ni;ua1Y-X$E!of)>!(lTdnLQ+qnF0H5F7dCOi<?UaD#uc1
zXA<)n94XGJ>XxnX?R>=r{>@v^2sa5X4T`vqWOLl4a-T?DF?EH}s2dm|gHh{+f1fbC
zhg6+K@?q$URr*fu4J`3xjIekEf5O)W9Lpb9Y(jv^ROEZ{P)P!l635Hq8!#Tzkp!w%
zvemZ@d01+<N$;T6qr{heDSR>h?O)hGG)T^$*e359nZ%+<Yc`rL$m5%bC247#THt0(
zM5V<Gh<K=_Ziv3c+rR@h8FIg5nQUDZjV*IenI0R6m^@FbqLBEfJXmrp3i+J0Lm`K{
z61sswp^mf0u0veHsTcl)y+AwoCmo;>$_CQ`G&Z;#=0%fHtRN2sD6l{=3gYS2;gYp2
z47K8P2geNd#NswoZl0ekHF-1T%E_sclQ9YTCBY92utDa0q`K@y%}yj6S|eF|=PSoz
zwMk?`A&Av4>$By^-jz_p|NLMy`w#g=@NYI48saa<GLY%|0epy%0fil>AK8=J2jNS&
zQe{qhdmo9c5M%HL9}J5L>c5_zFH^_$LTQabY8{{~aIbJW9Lf4A9#3|fwGI2gYb?d4
z6B0bgkC4Svbk#)j<xWTH1g8Q%A_sm1|8~6KU!$>00GIM14Hx^9e6dimZlv~tZ!8&!
z0yDkT{t(Y8{~=mHsQqHjVQN8V8WTdKJO_)z9Xc255FENzyuFX4fy$YLxxr4$Gq_@H
z-!Mldj$vcJ6#Sz2H#^m%y9aE>$gEp;QhCGCBZ{6;^pvIV2qP$%F}JB|qam4F;v_V<
zn+m<J&PQMY42E<jr2FN)f=LoL!V5tLA<}q-4n#~!F<hQp8I0Io?iJb`3Hpr_UH{fZ
zq3h!(;@^B24F&>SRzk;hY)(;(95wz_<`j$VsJ>vNN<e16vEjW6F#hUCRDW+dv@K30
ziB<{c;AY2UV=CDcl!lM4XMmMXlpft3C1h(uW`m!3{8jL8c8VFUl9$EH!|Tj|$plu%
z)Ccjy$OGz%lMP9nJ;>@rHa)f%N+!UO5XlHsS_bHbnk%M(|Bpa*6z1^<z*a<)3?0iu
zgB;~W^Tn1U<v_+0x5EQI6aS<GG)Vby6~Lu~0j|TJz+I{k9nJMX*AN|x*n&}rsCHVu
zP5kpA&#s+hLn4a8l_y&qN_5gW@`9TMsWNxk&|g&c=R2+V59`}Y`i2DkDuzc|Kj%&x
zCe<ZrNOZ|WcH{xH6YYloZ|QoZ(PzqJy<A51?*X+5RjJH&Jx^_?8GPJ=+)b*63mggQ
zK*Sm!jOS}-AHXGh8Q`Cp)3^2U3-E6?f`(~O$_J<^?CLl-4!OiHa!s&!LZghwt#hML
zc*<%2N5#;n!M<{4-$Z$WT)z|!b@I`jD)DGu)>0L8$f0!gqA$Is@K0Uea$}APKD~ME
zf~-hP5Fc-wp7%=|cYcoh!QoN8r06vEfOomb?KL3z=-`s4RqN!`zIc?_>8aFYYZrzi
z1ZO6;PqTn~RzzVH44sgK>p<P5!Kj+qy*>PMsm=xbYZGOyk3R$dYz&Q4KJ*4W1Gq#D
z7pWDqyi}cGdw&v^e41p8@>aWEO1)`oqLc*0f+JdCq?6D#R&K=pV6sxDxAl@Qy>4(H
z$0P%1kMEUNDj1nT=J)0G)0=WOYmW@WUf%;js$cqoww|K~^uV_1hTagubxLmt=`fHa
zck<>-+S(yV!`dAsdAw!Es&IK&91lB@PFBZt;9=n~)cf<bidSvCr~%h~TI1ck@-y*o
zHiMVY(S*s&nC;f(XpvEEG7y}O0CY1cWs8A|M7Pe5ll;R7K+8j#jmr7TZB7Rrt$|#)
z4(8KDSu|rHl83uCK(+P4Pq}U|@yLcX3+4XpJgwiQo?n61`P1-Fe<xp3)*=Sf@0Z<t
zfaw`3CHmr7gXH?9W%2@Qa+*w-hMgnu94=OO3ua2ekr-6LV0acw=W!i~MJd&hsOiia
zUN$9@i!c5j*J1!|*ad$f{M*sNKgY|ceBcJeB^}VmkUGOhMOYIIxI)tMsT~ZFh5-fy
ztt?<j%~E-AWr+$pVeuK$c+ghEpL@NBXIH3cW=&AKJlb{W>p}g#0%j?(WGXSQF$qm+
z!BJV5FsYR-_;X)wx!-UYqM;Ez<(r)o)z<jc?Nv%QtmOa%n_^^C?G|M#j)Skj80-rI
zQD(PY{F}O<|HDL)<M9{9zu7px?%x8A189_T_(=1d{sdc$WvFBfN+w0C?374Gp;9tp
z_tRLKAo)k);8NR5IhU9Z{u0OTUAw@ABO3KTvbIah!^_a+Bf*f$Pz1d`bo+0gmMglT
zo>$YxEoJx7djA`6SSpc=r*_H2*l1-3{K8H-;@@n<t9xe^Opt#x9_5%AWJ+N58=b6@
zBlYO=80dzB+jPsYv_%<!F++c2qQ>#~E8*XK310kn046fvhO{*u7`W);*+DiZ1|ZGe
zNK~pEkF;A8VMK_7Q^81Ch@b;A4U5YLTs8WUYuuK_j~^=8$2Oz>(_JVS5%2NCi*jqG
zGTQd;R%Oe^B;<bZ_f|Il<dq3>_d0w%n8`{dEHrih<?^KNqMSLpS*FIJni3Kgenv-K
z<KJw6&LV-n?np=#f>69MSPM{s8(C|a$CqWcHzJ?gNBBQGQwsP`02M=SqDCKoW&HCc
zcrj%}+L&8cM<o972L)6ROdQco7Nf{~!bD$*4AluKeo4O1<m2;ZjFO8dHp!FPvtoR(
zM5ZuXA>)2X3r)c1!98mwDx#0VJrj|#lav*ixsrcts<qG!Z9j|`!t=~}__QuZa!+l+
zOGZneUyqM%Slh?HIWp#vb$eL1an=N1Su))ZqosXC%)h%ha{k{2bOHQn@NW_vI{@$n
z+yiJmqG5-BTvWr%V>`QA>pk}OxA&Xdu5KP~!eq6nYo|#?UYb0=i!guWku{i5Rwb5w
z#%#q!(o~ZzXOC`_iQ@*#lDQMW<F`v?5vtc**efY(5+pcK?_5a>F(U`c=_4CKNHA0|
z<0WmtXh-`3<VnlDGjc6AO|~Y_1T8_g(0cRwdH8SdE8F-Rhxs9(C*V(ue>*yW<I&#-
z0UpEu$cA%V_-x#M>>1h?>4ue<FhX*UAW3;SRPU@e0ly<Uq8cBX5UC1V%{$ob8}FQe
zGg`7t7#pdQPwz-UWaE8gG*`GqOz5*>dDD<D`Db@X|4>_&17<Xz7!xI@53hsH_bl+w
z%;%R>yKJ8^LvJ3Ql={m3l6`o&ESo<{!uw+D=HBU7$3I8(34m%_7khv|0{=Jh?tDat
z{t5B#k012_%@96=2HIK|xKHd8)J+v1Og2VJ&Y=ZTTe1=1+fccnc7V1kWT~VT1`Ch8
zu0JVtW$BW!V-e<bf2)#t&eRdod=~~N#)HGZ=UqcCB3gB3^LLGTxF1QV>@wSPelMIo
zM($M{vf`f6@U#K(Jz58x1^wSqM9F1H-IXndoX(gp$;K#|G^USAt6=H@F(R#YJZ*h3
z?`;P-{{sMjUieq^K>9<^xG?wuC?I^44k+==i}y#N^1iZaZXZdU8G__>p^~%+0jWvD
z<XGBxDL6JuZs#wRhKhCARimaHv}|<Ars;+1cc%DxbN`SS4L9~7G9gLUEsK+|5MKu#
zO&)(deI@2E<Nhwlt&((EwPd1XA4Rph25sZJb2URkg7umZ9N;DC+ZIXV?Qe7hJmx)d
z|MuYtRL0q<DrUU7k0^OtF%!dL4BCwZggd0MGDYqbtU&MQ$no8iP>yeeBrlGX<#YN;
z;;g>1dR{18YQj{4;!lwKNE6)uF;<j0WByF>Z!!k<5a0&jhT)@hFenUe^cx34ZxoN<
zR5K`TF%lLbga=+Vujp(-Z3-OEly(ipjNa5??Z2}FL5iCt|M*fdwkJ<QA&EZ9@xb0+
z2OUsTin+l`&TUq9ytj|e%GPx=l}yJ<HqUBVl;FH_V2$h_sIF&hN5&NJ6E)|t$S~sJ
z$?XFuZZ!uyzo&{B+@2gSmrt*f`fFPe|53e5mB~~ABXA1PdO(z2go^~f;3c%7EYJ76
zYB5|Z=Sgk;RLMw*R4LocPPTL8w(AOj^5361{!KdI5xxDt04D)$Iv(I}3PlV`ni-2q
z7)Qsz>5Td#Caq!OA{H-4@+w6Kbh%5B+M<=vuuOp~)?igX$guZDG#hk2PMZ)Z_sfyZ
zns!_mqf2r&DSOV5-AgdHQ2_&Uy!y%>>D$W(2I?+Sb}?1)dlf4VyYFpO!CNpR8uX!6
zHDu!iRLL|XdZ53om=`U_b|d9h3G{vlr`FD4=rMY(^g#HMmp2Xg3C@K^Bt~Y$`dLG<
zoIC4uP7~c(z<&j}umk=H*MEiXkG&tg{&#?605zHIt#WG55a`<(wd7HpBzuybE}3+|
z;+EtG>xALCmru-tD=zAPjT#)F6w7VV0i&2x*Gz)oh>CU(VZTLgFxv9pB0toNx+AdX
zX+h%c!{dkpTcFkt(m-V%A{}V&MXrFxoBNO@r@zB;ZduBy|Lu%48ve3z`6wwoJ|EUk
zoqCx))%XV|1O7SxE3+pf)CO+10iR@$AP4;suo=*XAHc`P-+oU18oxjF{rCcAJEDQ%
zG2o+X1MYzXvWIM1+Fz=2U{|O@nl99iHH(}o_gkzDM$4@Y@~|ukL%%?Fu8Wnav0>87
zzZ>wVGh&a33X%&)!KP~<I6!EiLjp71sBAaz=OBIwT-S@wCaGMad^s~?vQm=1|B&29
z^b>79#5*@7p}l%Yd`u|v|E!L|%NI#~X)*$bSpk{AMAWQ^4GRbo2{cz3QkgSNHZL0>
zVZk~99bfVh;3!e{9|id5uCe#2<L~<EpMUjp-;Xb$p^4H=0pO!+1MX4YbWG{LVM%`}
zI}Ht5Icy6SM?^zqI_FfQBN~j(jAC!9N>P5g=MK(AZfKNCDuNJ!te0ANWFbPz?x}KY
z&s@2Zy;f>UQl;Y3dQ>-^s;VQJ{GASsm6sqZqIe;prZ@!~(V>#IE>12YYtHS0wT229
ze_73{#{>qB(+0%VDhbrOTAoxSqSw<9W*vd_oSK06Ri6Ol{doYY-r9%>`P}jU`51R>
z;pe;`UqvGW9Z}u@K8YtVP&L@kO%_h=E$1`Gi@^++EjO9r&{ANy#uONl)r2UaNM@;k
zOTSI#0pv!4)ldsgB+`Z}dpAy&y_=@UwzYARx_Z3I1+Z&Fyrid2l@t3C<WU729GN!^
z&#@wU%bo35=9zDNJ5nnvnUA>Vx=*<e9l+dY2;IHQix5^hL6*$u`z2a%`u{8i{0GM|
zw?F$i<8R;2m;U}G-j6RNPvHKM9&c?L9`UzUv&LY?>yd-JWz(`qDLghs864@7t=O;H
zJZQc^v0PWewx<WUZeU~i8o9tU>{3;dU)5@np17u;A3-^_aT5x^PnB0#(G}!>E$^H2
zemw%l*Gm1BL@COehE7Gvuz_B!;sRWKiPJT5Msi5%{Wv-<WIy8Uml*#q#r?1GethY_
z0nlNYT95w;XoYk8Yli&^`8Mfc%n)B}yP@0N7l*vR^QEa`C3pn<dXeQsFVApJB0VVn
zK!1MHgr*CHTe@?Yz#P&F%zJRZV)d*y0sn87T4s`fhVoT%>(WBy0mVK4@PYJ<>Es|Z
z+IO~%-{gWcxjq6+18_9j!2Pc={+~+=zZU)BtEo%)&j3oltfWCrNGn=!z`v^-nAISx
zS65`i4nzz$LNB&JT+5mTrxb{6S69fBsw8Q?$;`MYOnzr0(8;MxR<42DIR&`Rdw6eC
zWs*F&x)Pc75&ua|71L_2Sr{oX(f%sgJYVXnGoNsc_<sgS1^g#~3!T3`j()B2w|_@_
zzyBET$0+<WfIDCZfUBZaR`@9XadRtF&@4+71^abD-X|}pZiA2!ub(6>j*`@s!)4dH
z(UQJ-oE+E^E19XW>Nl_PZ>tv!k_A)ysW{;1fj$Nb&3LGJ&PFYp!d5SI)d?5ZNa2)(
z_?6V6eL@W2A7lLg)cCi5KSqVLKyBC-z$4=Sql*OY`685<`v4w^UKj2BV)h^Me6D!>
zDt_Hx*?)E0zyDXmzc~^ZAvz`eCGr3N01^OIfFA%>=78U>aP~`H``P$sXSvTS2h0Ne
z9l(X2*Zgkh<NvDoH^)JJKZcCNK!M@^1cU?j0w_Y6yy4fPi7&!GJ43xbcRCLM8GsPL
z-vB-X_Z)+N#J@=iPDczS6^_3JL;^?;cL3i3Tndu7{v~|jv+!@?ot>xy>;^;u*vU5Z
zJ5FEK>hvG+-)cx)U%(Lm6@XLB7cdWS3Q!H8$VC>+DfziH&@TQ>e6#VlfLg#=z)S$O
z9seHC&febjhd5sSNBldE$0wg*=(%2yNBlcLS3opi1>hUNRRE`G3xE+3-vg+U;d(+*
zjX*wP@S^#LAMyKJ03YJRY~(OtDPTCj1Ms&165?m_`L@36AMxMT$b7+dpoMY-omu`8
z@Gk*G*M9+Y1dwk~wipH&0T>4`#^b-y020ptKmfoEK+Odo{@(y>jE%OV$N7TZsz?6B
z_!mQ5{rmk_U;Wnpdg51K{l@Mbe|ET`i06M{yMd=)ePumYx7$6?sQ&!bU-Jfo|0U`R
z)>r6LYYYEip8N7<k#EiOf2GeG&2!bFNRfGN>5_SBY4HEEog3=?*7m>p%9kx#`pesX
z%X91dzWPeNvC-CmdSj98T)i>TcCJ3jcB*<{_kPHKhKSw!RS%rc?fRp7WY-_nqelA|
zphwQ<MfQJ35ADwl;w{ns26Wl}lwEc@clZE&g7djU|M5lbos<539X=4B=zQ+*!T98l
zoi{pm_^;bJSM#sc4Mkr${QHZ~Jx_Fa{Hx!zeXic$-VLgyb{hDZf7kE-({;e|{?G3~
zk@|4!f1iz_M*XPy{;&SpazS7I>f`4hBSPoDI}^1&x4!?Y-?leR(5qI{$a&g1pNsh^
z`q*k3t7&h0KjwXr{S!`%f_$RU{_idrjl(B{RXTh!SgFGo`l@r=`^kG9J^`H3;S+Fb
z&#4q^wd*nZ=g>pNn(ca|Shrn|e#`s+!SVeLJurBKT@Tc$ZH(0W?B1x}XSY~b7ANaB
z`|9Vd4eC?F`c3M4c+oP-miDZp_*?!>{nJ=5&n#%Obca{fNB-9KcaEC1b;}LrpDn$#
V-h4jdyWi9_EM1ec<~J1|{(k}4-6H@1


From 93b4c7133b958cfd484b2de020a02b76dc314b6d Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 17:40:21 -0500
Subject: [PATCH 54/56] [Vulkan] Update to Vulkan 1.1

---
 src/xenia/ui/vulkan/vulkan.h                 |     3 -
 src/xenia/ui/vulkan/vulkan_instance.cc       |     2 +-
 third_party/vulkan/GLSL.std.450.h            |   131 -
 third_party/vulkan/vk_debug_marker_layer.h   |    44 -
 third_party/vulkan/vk_icd.h                  |   152 -
 third_party/vulkan/vk_layer.h                |   182 -
 third_party/vulkan/vk_layer_dispatch_table.h |   454 -
 third_party/vulkan/vk_lunarg_debug_marker.h  |    98 -
 third_party/vulkan/vk_platform.h             |    28 -
 third_party/vulkan/vk_sdk_platform.h         |    69 -
 third_party/vulkan/vulkan.h                  |  7011 +---
 third_party/vulkan/vulkan.hpp                | 35695 -----------------
 third_party/vulkan/vulkan_android.h          |   126 +
 third_party/vulkan/vulkan_core.h             |  7470 ++++
 third_party/vulkan/vulkan_ios.h              |    58 +
 third_party/vulkan/vulkan_macos.h            |    58 +
 third_party/vulkan/vulkan_mir.h              |    65 +
 third_party/vulkan/vulkan_vi.h               |    58 +
 third_party/vulkan/vulkan_wayland.h          |    65 +
 third_party/vulkan/vulkan_win32.h            |   276 +
 third_party/vulkan/vulkan_xcb.h              |    66 +
 third_party/vulkan/vulkan_xlib.h             |    66 +
 third_party/vulkan/vulkan_xlib_xrandr.h      |    54 +
 23 files changed, 8392 insertions(+), 43839 deletions(-)
 delete mode 100644 third_party/vulkan/GLSL.std.450.h
 delete mode 100644 third_party/vulkan/vk_debug_marker_layer.h
 delete mode 100644 third_party/vulkan/vk_icd.h
 delete mode 100644 third_party/vulkan/vk_layer.h
 delete mode 100644 third_party/vulkan/vk_layer_dispatch_table.h
 delete mode 100644 third_party/vulkan/vk_lunarg_debug_marker.h
 delete mode 100644 third_party/vulkan/vk_sdk_platform.h
 delete mode 100644 third_party/vulkan/vulkan.hpp
 create mode 100644 third_party/vulkan/vulkan_android.h
 create mode 100644 third_party/vulkan/vulkan_core.h
 create mode 100644 third_party/vulkan/vulkan_ios.h
 create mode 100644 third_party/vulkan/vulkan_macos.h
 create mode 100644 third_party/vulkan/vulkan_mir.h
 create mode 100644 third_party/vulkan/vulkan_vi.h
 create mode 100644 third_party/vulkan/vulkan_wayland.h
 create mode 100644 third_party/vulkan/vulkan_win32.h
 create mode 100644 third_party/vulkan/vulkan_xcb.h
 create mode 100644 third_party/vulkan/vulkan_xlib.h
 create mode 100644 third_party/vulkan/vulkan_xlib_xrandr.h

diff --git a/src/xenia/ui/vulkan/vulkan.h b/src/xenia/ui/vulkan/vulkan.h
index b091cb63f..7d4887418 100644
--- a/src/xenia/ui/vulkan/vulkan.h
+++ b/src/xenia/ui/vulkan/vulkan.h
@@ -26,9 +26,6 @@
 #include "third_party/volk/volk.h"
 #include "third_party/vulkan/vulkan.h"
 
-// NOTE: header order matters here, unfortunately:
-#include "third_party/vulkan/vk_lunarg_debug_marker.h"
-
 #define XELOGVK XELOGI
 
 DECLARE_bool(vulkan_validation);
diff --git a/src/xenia/ui/vulkan/vulkan_instance.cc b/src/xenia/ui/vulkan/vulkan_instance.cc
index 1eb967b9b..a383cf116 100644
--- a/src/xenia/ui/vulkan/vulkan_instance.cc
+++ b/src/xenia/ui/vulkan/vulkan_instance.cc
@@ -31,7 +31,7 @@
 #include "xenia/ui/window_gtk.h"
 #endif
 
-#define VK_API_VERSION VK_API_VERSION_1_0
+#define VK_API_VERSION VK_API_VERSION_1_1
 
 namespace xe {
 namespace ui {
diff --git a/third_party/vulkan/GLSL.std.450.h b/third_party/vulkan/GLSL.std.450.h
deleted file mode 100644
index 54cc00e9a..000000000
--- a/third_party/vulkan/GLSL.std.450.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
-**
-** Permission is hereby granted, free of charge, to any person obtaining a copy
-** of this software and/or associated documentation files (the "Materials"),
-** to deal in the Materials without restriction, including without limitation
-** the rights to use, copy, modify, merge, publish, distribute, sublicense,
-** and/or sell copies of the Materials, and to permit persons to whom the
-** Materials are furnished to do so, subject to the following conditions:
-**
-** The above copyright notice and this permission notice shall be included in
-** all copies or substantial portions of the Materials.
-**
-** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-**
-** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-** IN THE MATERIALS.
-*/
-
-#ifndef GLSLstd450_H
-#define GLSLstd450_H
-
-static const int GLSLstd450Version = 100;
-static const int GLSLstd450Revision = 3;
-
-enum GLSLstd450 {
-    GLSLstd450Bad = 0,              // Don't use
-
-    GLSLstd450Round = 1,
-    GLSLstd450RoundEven = 2,
-    GLSLstd450Trunc = 3,
-    GLSLstd450FAbs = 4,
-    GLSLstd450SAbs = 5,
-    GLSLstd450FSign = 6,
-    GLSLstd450SSign = 7,
-    GLSLstd450Floor = 8,
-    GLSLstd450Ceil = 9,
-    GLSLstd450Fract = 10,
-
-    GLSLstd450Radians = 11,
-    GLSLstd450Degrees = 12,
-    GLSLstd450Sin = 13,
-    GLSLstd450Cos = 14,
-    GLSLstd450Tan = 15,
-    GLSLstd450Asin = 16,
-    GLSLstd450Acos = 17,
-    GLSLstd450Atan = 18,
-    GLSLstd450Sinh = 19,
-    GLSLstd450Cosh = 20,
-    GLSLstd450Tanh = 21,
-    GLSLstd450Asinh = 22,
-    GLSLstd450Acosh = 23,
-    GLSLstd450Atanh = 24,
-    GLSLstd450Atan2 = 25,
-
-    GLSLstd450Pow = 26,
-    GLSLstd450Exp = 27,
-    GLSLstd450Log = 28,
-    GLSLstd450Exp2 = 29,
-    GLSLstd450Log2 = 30,
-    GLSLstd450Sqrt = 31,
-    GLSLstd450InverseSqrt = 32,
-
-    GLSLstd450Determinant = 33,
-    GLSLstd450MatrixInverse = 34,
-
-    GLSLstd450Modf = 35,            // second operand needs an OpVariable to write to
-    GLSLstd450ModfStruct = 36,      // no OpVariable operand
-    GLSLstd450FMin = 37,
-    GLSLstd450UMin = 38,
-    GLSLstd450SMin = 39,
-    GLSLstd450FMax = 40,
-    GLSLstd450UMax = 41,
-    GLSLstd450SMax = 42,
-    GLSLstd450FClamp = 43,
-    GLSLstd450UClamp = 44,
-    GLSLstd450SClamp = 45,
-    GLSLstd450FMix = 46,
-    GLSLstd450IMix = 47,            // Reserved
-    GLSLstd450Step = 48,
-    GLSLstd450SmoothStep = 49,
-
-    GLSLstd450Fma = 50,
-    GLSLstd450Frexp = 51,            // second operand needs an OpVariable to write to
-    GLSLstd450FrexpStruct = 52,      // no OpVariable operand
-    GLSLstd450Ldexp = 53,
-
-    GLSLstd450PackSnorm4x8 = 54,
-    GLSLstd450PackUnorm4x8 = 55,
-    GLSLstd450PackSnorm2x16 = 56,
-    GLSLstd450PackUnorm2x16 = 57,
-    GLSLstd450PackHalf2x16 = 58,
-    GLSLstd450PackDouble2x32 = 59,
-    GLSLstd450UnpackSnorm2x16 = 60,
-    GLSLstd450UnpackUnorm2x16 = 61,
-    GLSLstd450UnpackHalf2x16 = 62,
-    GLSLstd450UnpackSnorm4x8 = 63,
-    GLSLstd450UnpackUnorm4x8 = 64,
-    GLSLstd450UnpackDouble2x32 = 65,
-
-    GLSLstd450Length = 66,
-    GLSLstd450Distance = 67,
-    GLSLstd450Cross = 68,
-    GLSLstd450Normalize = 69,
-    GLSLstd450FaceForward = 70,
-    GLSLstd450Reflect = 71,
-    GLSLstd450Refract = 72,
-
-    GLSLstd450FindILsb = 73,
-    GLSLstd450FindSMsb = 74,
-    GLSLstd450FindUMsb = 75,
-
-    GLSLstd450InterpolateAtCentroid = 76,
-    GLSLstd450InterpolateAtSample = 77,
-    GLSLstd450InterpolateAtOffset = 78,
-
-    GLSLstd450NMin = 79,
-    GLSLstd450NMax = 80,
-    GLSLstd450NClamp = 81,
-
-    GLSLstd450Count
-};
-
-#endif  // #ifndef GLSLstd450_H
diff --git a/third_party/vulkan/vk_debug_marker_layer.h b/third_party/vulkan/vk_debug_marker_layer.h
deleted file mode 100644
index e882b02b4..000000000
--- a/third_party/vulkan/vk_debug_marker_layer.h
+++ /dev/null
@@ -1,44 +0,0 @@
-//
-// File: vk_debug_marker_layer.h
-//
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and/or associated documentation files (the "Materials"), to
- * deal in the Materials without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Materials, and to permit persons to whom the Materials are
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included in
- * all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- *
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
- * USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- * Authors:
- *   Jon Ashburn <jon@lunarg.com>
- *   Courtney Goeltzenleuchter <courtney@lunarg.com>
- */
-
-#pragma once
-
-#include "vulkan.h"
-#include "vk_lunarg_debug_marker.h"
-#include "vk_layer.h"
-
-typedef struct VkLayerDebugMarkerDispatchTable_ {
-    PFN_vkCmdDbgMarkerBegin CmdDbgMarkerBegin;
-    PFN_vkCmdDbgMarkerEnd CmdDbgMarkerEnd;
-    PFN_vkDbgSetObjectTag DbgSetObjectTag;
-    PFN_vkDbgSetObjectName DbgSetObjectName;
-} VkLayerDebugMarkerDispatchTable;
diff --git a/third_party/vulkan/vk_icd.h b/third_party/vulkan/vk_icd.h
deleted file mode 100644
index b8c7efcb6..000000000
--- a/third_party/vulkan/vk_icd.h
+++ /dev/null
@@ -1,152 +0,0 @@
-//
-// File: vk_icd.h
-//
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#ifndef VKICD_H
-#define VKICD_H
-
-#include "vulkan.h"
-#include <stdbool.h>
-
-// Loader-ICD version negotiation API.  Versions add the following features:
-//   Version 0 - Initial.  Doesn't support vk_icdGetInstanceProcAddr
-//               or vk_icdNegotiateLoaderICDInterfaceVersion.
-//   Version 1 - Add support for vk_icdGetInstanceProcAddr.
-//   Version 2 - Add Loader/ICD Interface version negotiation
-//               via vk_icdNegotiateLoaderICDInterfaceVersion.
-//   Version 3 - Add ICD creation/destruction of KHR_surface objects.
-//   Version 4 - Add unknown physical device extension qyering via
-//               vk_icdGetPhysicalDeviceProcAddr.
-//   Version 5 - Tells ICDs that the loader is now paying attention to the
-//               application version of Vulkan passed into the ApplicationInfo
-//               structure during vkCreateInstance.  This will tell the ICD
-//               that if the loader is older, it should automatically fail a
-//               call for any API version > 1.0.  Otherwise, the loader will
-//               manually determine if it can support the expected version.
-#define CURRENT_LOADER_ICD_INTERFACE_VERSION 5
-#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0
-#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4
-typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion);
-
-// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this
-// file directly, it won't be found.
-#ifndef PFN_GetPhysicalDeviceProcAddr
-typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
-#endif
-
-/*
- * The ICD must reserve space for a pointer for the loader's dispatch
- * table, at the start of <each object>.
- * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro.
- */
-
-#define ICD_LOADER_MAGIC 0x01CDC0DE
-
-typedef union {
-    uintptr_t loaderMagic;
-    void *loaderData;
-} VK_LOADER_DATA;
-
-static inline void set_loader_magic_value(void *pNewObject) {
-    VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
-    loader_info->loaderMagic = ICD_LOADER_MAGIC;
-}
-
-static inline bool valid_loader_magic_value(void *pNewObject) {
-    const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject;
-    return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC;
-}
-
-/*
- * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that
- * contains the platform-specific connection and surface information.
- */
-typedef enum {
-    VK_ICD_WSI_PLATFORM_MIR,
-    VK_ICD_WSI_PLATFORM_WAYLAND,
-    VK_ICD_WSI_PLATFORM_WIN32,
-    VK_ICD_WSI_PLATFORM_XCB,
-    VK_ICD_WSI_PLATFORM_XLIB,
-    VK_ICD_WSI_PLATFORM_DISPLAY
-} VkIcdWsiPlatform;
-
-typedef struct {
-    VkIcdWsiPlatform platform;
-} VkIcdSurfaceBase;
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-typedef struct {
-    VkIcdSurfaceBase base;
-    MirConnection *connection;
-    MirSurface *mirSurface;
-} VkIcdSurfaceMir;
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-typedef struct {
-    VkIcdSurfaceBase base;
-    struct wl_display *display;
-    struct wl_surface *surface;
-} VkIcdSurfaceWayland;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-typedef struct {
-    VkIcdSurfaceBase base;
-    HINSTANCE hinstance;
-    HWND hwnd;
-} VkIcdSurfaceWin32;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-typedef struct {
-    VkIcdSurfaceBase base;
-    xcb_connection_t *connection;
-    xcb_window_t window;
-} VkIcdSurfaceXcb;
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-typedef struct {
-    VkIcdSurfaceBase base;
-    Display *dpy;
-    Window window;
-} VkIcdSurfaceXlib;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-typedef struct {
-    ANativeWindow* window;
-} VkIcdSurfaceAndroid;
-#endif //VK_USE_PLATFORM_ANDROID_KHR
-
-typedef struct {
-    VkIcdSurfaceBase base;
-    VkDisplayModeKHR displayMode;
-    uint32_t planeIndex;
-    uint32_t planeStackIndex;
-    VkSurfaceTransformFlagBitsKHR transform;
-    float globalAlpha;
-    VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
-    VkExtent2D imageExtent;
-} VkIcdSurfaceDisplay;
-
-#endif // VKICD_H
diff --git a/third_party/vulkan/vk_layer.h b/third_party/vulkan/vk_layer.h
deleted file mode 100644
index 147dcd43a..000000000
--- a/third_party/vulkan/vk_layer.h
+++ /dev/null
@@ -1,182 +0,0 @@
-//
-// File: vk_layer.h
-//
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-/* Need to define dispatch table
- * Core struct can then have ptr to dispatch table at the top
- * Along with object ptrs for current and next OBJ
- */
-#pragma once
-
-#include "vulkan.h"
-#if defined(__GNUC__) && __GNUC__ >= 4
-#define VK_LAYER_EXPORT __attribute__((visibility("default")))
-#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590)
-#define VK_LAYER_EXPORT __attribute__((visibility("default")))
-#else
-#define VK_LAYER_EXPORT
-#endif
-
-// Definition for VkLayerDispatchTable and VkLayerInstanceDispatchTable now appear in externally generated header
-#include "vk_layer_dispatch_table.h"
-
-#define MAX_NUM_UNKNOWN_EXTS 250
-
- // Loader-Layer version negotiation API.  Versions add the following features:
- //   Versions 0/1 - Initial.  Doesn't support vk_layerGetPhysicalDeviceProcAddr
- //                  or vk_icdNegotiateLoaderLayerInterfaceVersion.
- //   Version 2    - Add support for vk_layerGetPhysicalDeviceProcAddr and
- //                  vk_icdNegotiateLoaderLayerInterfaceVersion.
-#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2
-#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1
-
-#define VK_CURRENT_CHAIN_VERSION 1
-
-// Version negotiation values
-typedef enum VkNegotiateLayerStructType {
-    LAYER_NEGOTIATE_UNINTIALIZED = 0,
-    LAYER_NEGOTIATE_INTERFACE_STRUCT = 1,
-} VkNegotiateLayerStructType;
-
-// Version negotiation structures
-typedef struct VkNegotiateLayerInterface {
-    VkNegotiateLayerStructType sType;
-    void *pNext;
-    uint32_t loaderLayerInterfaceVersion;
-    PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr;
-    PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr;
-    PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr;
-} VkNegotiateLayerInterface;
-
-// Version negotiation functions
-typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct);
-
-// Function prototype for unknown physical device extension command
-typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device);
-
-// ------------------------------------------------------------------------------------------------
-// CreateInstance and CreateDevice support structures
-
-/* Sub type of structure for instance and device loader ext of CreateInfo.
- * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
- * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
- * then VkLayerFunction indicates struct type pointed to by pNext
- */
-typedef enum VkLayerFunction_ {
-    VK_LAYER_LINK_INFO = 0,
-    VK_LOADER_DATA_CALLBACK = 1
-} VkLayerFunction;
-
-typedef struct VkLayerInstanceLink_ {
-    struct VkLayerInstanceLink_ *pNext;
-    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
-    PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr;
-} VkLayerInstanceLink;
-
-/*
- * When creating the device chain the loader needs to pass
- * down information about it's device structure needed at
- * the end of the chain. Passing the data via the
- * VkLayerDeviceInfo avoids issues with finding the
- * exact instance being used.
- */
-typedef struct VkLayerDeviceInfo_ {
-    void *device_info;
-    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
-} VkLayerDeviceInfo;
-
-typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance,
-        void *object);
-typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device,
-        void *object);
-
-typedef struct {
-    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO
-    const void *pNext;
-    VkLayerFunction function;
-    union {
-        VkLayerInstanceLink *pLayerInfo;
-        PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData;
-    } u;
-} VkLayerInstanceCreateInfo;
-
-typedef struct VkLayerDeviceLink_ {
-    struct VkLayerDeviceLink_ *pNext;
-    PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr;
-    PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr;
-} VkLayerDeviceLink;
-
-typedef struct {
-    VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO
-    const void *pNext;
-    VkLayerFunction function;
-    union {
-        VkLayerDeviceLink *pLayerInfo;
-        PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData;
-    } u;
-} VkLayerDeviceCreateInfo;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct);
-
-typedef enum VkChainType {
-    VK_CHAIN_TYPE_UNKNOWN = 0,
-    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1,
-    VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2,
-} VkChainType;
-
-typedef struct VkChainHeader {
-    VkChainType type;
-    uint32_t version;
-    uint32_t size;
-} VkChainHeader;
-
-typedef struct VkEnumerateInstanceExtensionPropertiesChain {
-    VkChainHeader header;
-    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *,
-                                      VkExtensionProperties *);
-    const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink;
-
-#if defined(__cplusplus)
-    inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const {
-        return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties);
-    }
-#endif
-} VkEnumerateInstanceExtensionPropertiesChain;
-
-typedef struct VkEnumerateInstanceLayerPropertiesChain {
-    VkChainHeader header;
-    VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *);
-    const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink;
-
-#if defined(__cplusplus)
-    inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const {
-        return pfnNextLayer(pNextLink, pPropertyCount, pProperties);
-    }
-#endif
-} VkEnumerateInstanceLayerPropertiesChain;
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/third_party/vulkan/vk_layer_dispatch_table.h b/third_party/vulkan/vk_layer_dispatch_table.h
deleted file mode 100644
index 435c625c6..000000000
--- a/third_party/vulkan/vk_layer_dispatch_table.h
+++ /dev/null
@@ -1,454 +0,0 @@
-// *** THIS FILE IS GENERATED - DO NOT EDIT ***
-// See loader_extension_generator.py for modifications
-
-/*
- * Copyright (c) 2015-2017 The Khronos Group Inc.
- * Copyright (c) 2015-2017 Valve Corporation
- * Copyright (c) 2015-2017 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Author: Mark Lobodzinski <mark@lunarg.com>
- * Author: Mark Young <marky@lunarg.com>
- */
-
-#pragma once
-
-typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName);
-
-// Instance function pointer dispatch table
-typedef struct VkLayerInstanceDispatchTable_ {
-    // Manually add in GetPhysicalDeviceProcAddr entry
-    PFN_GetPhysicalDeviceProcAddr GetPhysicalDeviceProcAddr;
-
-    // ---- Core 1_0 commands
-    PFN_vkCreateInstance CreateInstance;
-    PFN_vkDestroyInstance DestroyInstance;
-    PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
-    PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
-    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
-    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
-    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
-    PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
-    PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
-    PFN_vkCreateDevice CreateDevice;
-    PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties;
-    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
-    PFN_vkEnumerateInstanceLayerProperties EnumerateInstanceLayerProperties;
-    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
-
-    // ---- VK_KHR_surface extension commands
-    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
-    PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
-    PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
-    PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
-    PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
-
-    // ---- VK_KHR_display extension commands
-    PFN_vkGetPhysicalDeviceDisplayPropertiesKHR GetPhysicalDeviceDisplayPropertiesKHR;
-    PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR GetPhysicalDeviceDisplayPlanePropertiesKHR;
-    PFN_vkGetDisplayPlaneSupportedDisplaysKHR GetDisplayPlaneSupportedDisplaysKHR;
-    PFN_vkGetDisplayModePropertiesKHR GetDisplayModePropertiesKHR;
-    PFN_vkCreateDisplayModeKHR CreateDisplayModeKHR;
-    PFN_vkGetDisplayPlaneCapabilitiesKHR GetDisplayPlaneCapabilitiesKHR;
-    PFN_vkCreateDisplayPlaneSurfaceKHR CreateDisplayPlaneSurfaceKHR;
-
-    // ---- VK_KHR_xlib_surface extension commands
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    PFN_vkCreateXlibSurfaceKHR CreateXlibSurfaceKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR GetPhysicalDeviceXlibPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XLIB_KHR
-
-    // ---- VK_KHR_xcb_surface extension commands
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    PFN_vkCreateXcbSurfaceKHR CreateXcbSurfaceKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR GetPhysicalDeviceXcbPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_XCB_KHR
-
-    // ---- VK_KHR_wayland_surface extension commands
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    PFN_vkCreateWaylandSurfaceKHR CreateWaylandSurfaceKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR GetPhysicalDeviceWaylandPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WAYLAND_KHR
-
-    // ---- VK_KHR_mir_surface extension commands
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
-#endif // VK_USE_PLATFORM_MIR_KHR
-
-    // ---- VK_KHR_android_surface extension commands
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    PFN_vkCreateAndroidSurfaceKHR CreateAndroidSurfaceKHR;
-#endif // VK_USE_PLATFORM_ANDROID_KHR
-
-    // ---- VK_KHR_win32_surface extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkCreateWin32SurfaceKHR CreateWin32SurfaceKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR GetPhysicalDeviceWin32PresentationSupportKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_get_physical_device_properties2 extension commands
-    PFN_vkGetPhysicalDeviceFeatures2KHR GetPhysicalDeviceFeatures2KHR;
-    PFN_vkGetPhysicalDeviceProperties2KHR GetPhysicalDeviceProperties2KHR;
-    PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR;
-    PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR GetPhysicalDeviceQueueFamilyProperties2KHR;
-    PFN_vkGetPhysicalDeviceMemoryProperties2KHR GetPhysicalDeviceMemoryProperties2KHR;
-    PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR GetPhysicalDeviceSparseImageFormatProperties2KHR;
-
-    // ---- VK_KHR_external_memory_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR GetPhysicalDeviceExternalBufferPropertiesKHR;
-
-    // ---- VK_KHR_external_semaphore_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR GetPhysicalDeviceExternalSemaphorePropertiesKHR;
-
-    // ---- VK_KHR_external_fence_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR GetPhysicalDeviceExternalFencePropertiesKHR;
-
-    // ---- VK_KHR_get_surface_capabilities2 extension commands
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR GetPhysicalDeviceSurfaceCapabilities2KHR;
-    PFN_vkGetPhysicalDeviceSurfaceFormats2KHR GetPhysicalDeviceSurfaceFormats2KHR;
-
-    // ---- VK_EXT_debug_report extension commands
-    PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
-    PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT;
-    PFN_vkDebugReportMessageEXT DebugReportMessageEXT;
-
-    // ---- VK_NV_external_memory_capabilities extension commands
-    PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV GetPhysicalDeviceExternalImageFormatPropertiesNV;
-
-    // ---- VK_KHX_device_group extension commands
-    PFN_vkGetPhysicalDevicePresentRectanglesKHX GetPhysicalDevicePresentRectanglesKHX;
-
-    // ---- VK_NN_vi_surface extension commands
-#ifdef VK_USE_PLATFORM_VI_NN
-    PFN_vkCreateViSurfaceNN CreateViSurfaceNN;
-#endif // VK_USE_PLATFORM_VI_NN
-
-    // ---- VK_KHX_device_group_creation extension commands
-    PFN_vkEnumeratePhysicalDeviceGroupsKHX EnumeratePhysicalDeviceGroupsKHX;
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX GetPhysicalDeviceGeneratedCommandsPropertiesNVX;
-
-    // ---- VK_EXT_direct_mode_display extension commands
-    PFN_vkReleaseDisplayEXT ReleaseDisplayEXT;
-
-    // ---- VK_EXT_acquire_xlib_display extension commands
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    PFN_vkAcquireXlibDisplayEXT AcquireXlibDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    PFN_vkGetRandROutputDisplayEXT GetRandROutputDisplayEXT;
-#endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
-
-    // ---- VK_EXT_display_surface_counter extension commands
-    PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT GetPhysicalDeviceSurfaceCapabilities2EXT;
-
-    // ---- VK_MVK_ios_surface extension commands
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    PFN_vkCreateIOSSurfaceMVK CreateIOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_IOS_MVK
-
-    // ---- VK_MVK_macos_surface extension commands
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    PFN_vkCreateMacOSSurfaceMVK CreateMacOSSurfaceMVK;
-#endif // VK_USE_PLATFORM_MACOS_MVK
-
-    // ---- VK_EXT_sample_locations extension commands
-    PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT GetPhysicalDeviceMultisamplePropertiesEXT;
-} VkLayerInstanceDispatchTable;
-
-// Device function pointer dispatch table
-typedef struct VkLayerDispatchTable_ {
-
-    // ---- Core 1_0 commands
-    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
-    PFN_vkDestroyDevice DestroyDevice;
-    PFN_vkGetDeviceQueue GetDeviceQueue;
-    PFN_vkQueueSubmit QueueSubmit;
-    PFN_vkQueueWaitIdle QueueWaitIdle;
-    PFN_vkDeviceWaitIdle DeviceWaitIdle;
-    PFN_vkAllocateMemory AllocateMemory;
-    PFN_vkFreeMemory FreeMemory;
-    PFN_vkMapMemory MapMemory;
-    PFN_vkUnmapMemory UnmapMemory;
-    PFN_vkFlushMappedMemoryRanges FlushMappedMemoryRanges;
-    PFN_vkInvalidateMappedMemoryRanges InvalidateMappedMemoryRanges;
-    PFN_vkGetDeviceMemoryCommitment GetDeviceMemoryCommitment;
-    PFN_vkBindBufferMemory BindBufferMemory;
-    PFN_vkBindImageMemory BindImageMemory;
-    PFN_vkGetBufferMemoryRequirements GetBufferMemoryRequirements;
-    PFN_vkGetImageMemoryRequirements GetImageMemoryRequirements;
-    PFN_vkGetImageSparseMemoryRequirements GetImageSparseMemoryRequirements;
-    PFN_vkQueueBindSparse QueueBindSparse;
-    PFN_vkCreateFence CreateFence;
-    PFN_vkDestroyFence DestroyFence;
-    PFN_vkResetFences ResetFences;
-    PFN_vkGetFenceStatus GetFenceStatus;
-    PFN_vkWaitForFences WaitForFences;
-    PFN_vkCreateSemaphore CreateSemaphore;
-    PFN_vkDestroySemaphore DestroySemaphore;
-    PFN_vkCreateEvent CreateEvent;
-    PFN_vkDestroyEvent DestroyEvent;
-    PFN_vkGetEventStatus GetEventStatus;
-    PFN_vkSetEvent SetEvent;
-    PFN_vkResetEvent ResetEvent;
-    PFN_vkCreateQueryPool CreateQueryPool;
-    PFN_vkDestroyQueryPool DestroyQueryPool;
-    PFN_vkGetQueryPoolResults GetQueryPoolResults;
-    PFN_vkCreateBuffer CreateBuffer;
-    PFN_vkDestroyBuffer DestroyBuffer;
-    PFN_vkCreateBufferView CreateBufferView;
-    PFN_vkDestroyBufferView DestroyBufferView;
-    PFN_vkCreateImage CreateImage;
-    PFN_vkDestroyImage DestroyImage;
-    PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout;
-    PFN_vkCreateImageView CreateImageView;
-    PFN_vkDestroyImageView DestroyImageView;
-    PFN_vkCreateShaderModule CreateShaderModule;
-    PFN_vkDestroyShaderModule DestroyShaderModule;
-    PFN_vkCreatePipelineCache CreatePipelineCache;
-    PFN_vkDestroyPipelineCache DestroyPipelineCache;
-    PFN_vkGetPipelineCacheData GetPipelineCacheData;
-    PFN_vkMergePipelineCaches MergePipelineCaches;
-    PFN_vkCreateGraphicsPipelines CreateGraphicsPipelines;
-    PFN_vkCreateComputePipelines CreateComputePipelines;
-    PFN_vkDestroyPipeline DestroyPipeline;
-    PFN_vkCreatePipelineLayout CreatePipelineLayout;
-    PFN_vkDestroyPipelineLayout DestroyPipelineLayout;
-    PFN_vkCreateSampler CreateSampler;
-    PFN_vkDestroySampler DestroySampler;
-    PFN_vkCreateDescriptorSetLayout CreateDescriptorSetLayout;
-    PFN_vkDestroyDescriptorSetLayout DestroyDescriptorSetLayout;
-    PFN_vkCreateDescriptorPool CreateDescriptorPool;
-    PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
-    PFN_vkResetDescriptorPool ResetDescriptorPool;
-    PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
-    PFN_vkFreeDescriptorSets FreeDescriptorSets;
-    PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
-    PFN_vkCreateFramebuffer CreateFramebuffer;
-    PFN_vkDestroyFramebuffer DestroyFramebuffer;
-    PFN_vkCreateRenderPass CreateRenderPass;
-    PFN_vkDestroyRenderPass DestroyRenderPass;
-    PFN_vkGetRenderAreaGranularity GetRenderAreaGranularity;
-    PFN_vkCreateCommandPool CreateCommandPool;
-    PFN_vkDestroyCommandPool DestroyCommandPool;
-    PFN_vkResetCommandPool ResetCommandPool;
-    PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
-    PFN_vkFreeCommandBuffers FreeCommandBuffers;
-    PFN_vkBeginCommandBuffer BeginCommandBuffer;
-    PFN_vkEndCommandBuffer EndCommandBuffer;
-    PFN_vkResetCommandBuffer ResetCommandBuffer;
-    PFN_vkCmdBindPipeline CmdBindPipeline;
-    PFN_vkCmdSetViewport CmdSetViewport;
-    PFN_vkCmdSetScissor CmdSetScissor;
-    PFN_vkCmdSetLineWidth CmdSetLineWidth;
-    PFN_vkCmdSetDepthBias CmdSetDepthBias;
-    PFN_vkCmdSetBlendConstants CmdSetBlendConstants;
-    PFN_vkCmdSetDepthBounds CmdSetDepthBounds;
-    PFN_vkCmdSetStencilCompareMask CmdSetStencilCompareMask;
-    PFN_vkCmdSetStencilWriteMask CmdSetStencilWriteMask;
-    PFN_vkCmdSetStencilReference CmdSetStencilReference;
-    PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
-    PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
-    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
-    PFN_vkCmdDraw CmdDraw;
-    PFN_vkCmdDrawIndexed CmdDrawIndexed;
-    PFN_vkCmdDrawIndirect CmdDrawIndirect;
-    PFN_vkCmdDrawIndexedIndirect CmdDrawIndexedIndirect;
-    PFN_vkCmdDispatch CmdDispatch;
-    PFN_vkCmdDispatchIndirect CmdDispatchIndirect;
-    PFN_vkCmdCopyBuffer CmdCopyBuffer;
-    PFN_vkCmdCopyImage CmdCopyImage;
-    PFN_vkCmdBlitImage CmdBlitImage;
-    PFN_vkCmdCopyBufferToImage CmdCopyBufferToImage;
-    PFN_vkCmdCopyImageToBuffer CmdCopyImageToBuffer;
-    PFN_vkCmdUpdateBuffer CmdUpdateBuffer;
-    PFN_vkCmdFillBuffer CmdFillBuffer;
-    PFN_vkCmdClearColorImage CmdClearColorImage;
-    PFN_vkCmdClearDepthStencilImage CmdClearDepthStencilImage;
-    PFN_vkCmdClearAttachments CmdClearAttachments;
-    PFN_vkCmdResolveImage CmdResolveImage;
-    PFN_vkCmdSetEvent CmdSetEvent;
-    PFN_vkCmdResetEvent CmdResetEvent;
-    PFN_vkCmdWaitEvents CmdWaitEvents;
-    PFN_vkCmdPipelineBarrier CmdPipelineBarrier;
-    PFN_vkCmdBeginQuery CmdBeginQuery;
-    PFN_vkCmdEndQuery CmdEndQuery;
-    PFN_vkCmdResetQueryPool CmdResetQueryPool;
-    PFN_vkCmdWriteTimestamp CmdWriteTimestamp;
-    PFN_vkCmdCopyQueryPoolResults CmdCopyQueryPoolResults;
-    PFN_vkCmdPushConstants CmdPushConstants;
-    PFN_vkCmdBeginRenderPass CmdBeginRenderPass;
-    PFN_vkCmdNextSubpass CmdNextSubpass;
-    PFN_vkCmdEndRenderPass CmdEndRenderPass;
-    PFN_vkCmdExecuteCommands CmdExecuteCommands;
-
-    // ---- VK_KHR_swapchain extension commands
-    PFN_vkCreateSwapchainKHR CreateSwapchainKHR;
-    PFN_vkDestroySwapchainKHR DestroySwapchainKHR;
-    PFN_vkGetSwapchainImagesKHR GetSwapchainImagesKHR;
-    PFN_vkAcquireNextImageKHR AcquireNextImageKHR;
-    PFN_vkQueuePresentKHR QueuePresentKHR;
-
-    // ---- VK_KHR_display_swapchain extension commands
-    PFN_vkCreateSharedSwapchainsKHR CreateSharedSwapchainsKHR;
-
-    // ---- VK_KHR_maintenance1 extension commands
-    PFN_vkTrimCommandPoolKHR TrimCommandPoolKHR;
-
-    // ---- VK_KHR_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandleKHR GetMemoryWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandlePropertiesKHR GetMemoryWin32HandlePropertiesKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_memory_fd extension commands
-    PFN_vkGetMemoryFdKHR GetMemoryFdKHR;
-    PFN_vkGetMemoryFdPropertiesKHR GetMemoryFdPropertiesKHR;
-
-    // ---- VK_KHR_external_semaphore_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkImportSemaphoreWin32HandleKHR ImportSemaphoreWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetSemaphoreWin32HandleKHR GetSemaphoreWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_semaphore_fd extension commands
-    PFN_vkImportSemaphoreFdKHR ImportSemaphoreFdKHR;
-    PFN_vkGetSemaphoreFdKHR GetSemaphoreFdKHR;
-
-    // ---- VK_KHR_push_descriptor extension commands
-    PFN_vkCmdPushDescriptorSetKHR CmdPushDescriptorSetKHR;
-
-    // ---- VK_KHR_descriptor_update_template extension commands
-    PFN_vkCreateDescriptorUpdateTemplateKHR CreateDescriptorUpdateTemplateKHR;
-    PFN_vkDestroyDescriptorUpdateTemplateKHR DestroyDescriptorUpdateTemplateKHR;
-    PFN_vkUpdateDescriptorSetWithTemplateKHR UpdateDescriptorSetWithTemplateKHR;
-    PFN_vkCmdPushDescriptorSetWithTemplateKHR CmdPushDescriptorSetWithTemplateKHR;
-
-    // ---- VK_KHR_shared_presentable_image extension commands
-    PFN_vkGetSwapchainStatusKHR GetSwapchainStatusKHR;
-
-    // ---- VK_KHR_external_fence_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkImportFenceWin32HandleKHR ImportFenceWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetFenceWin32HandleKHR GetFenceWin32HandleKHR;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHR_external_fence_fd extension commands
-    PFN_vkImportFenceFdKHR ImportFenceFdKHR;
-    PFN_vkGetFenceFdKHR GetFenceFdKHR;
-
-    // ---- VK_KHR_get_memory_requirements2 extension commands
-    PFN_vkGetImageMemoryRequirements2KHR GetImageMemoryRequirements2KHR;
-    PFN_vkGetBufferMemoryRequirements2KHR GetBufferMemoryRequirements2KHR;
-    PFN_vkGetImageSparseMemoryRequirements2KHR GetImageSparseMemoryRequirements2KHR;
-
-    // ---- VK_KHR_sampler_ycbcr_conversion extension commands
-    PFN_vkCreateSamplerYcbcrConversionKHR CreateSamplerYcbcrConversionKHR;
-    PFN_vkDestroySamplerYcbcrConversionKHR DestroySamplerYcbcrConversionKHR;
-
-    // ---- VK_KHR_bind_memory2 extension commands
-    PFN_vkBindBufferMemory2KHR BindBufferMemory2KHR;
-    PFN_vkBindImageMemory2KHR BindImageMemory2KHR;
-
-    // ---- VK_EXT_debug_marker extension commands
-    PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT;
-    PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT;
-    PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBeginEXT;
-    PFN_vkCmdDebugMarkerEndEXT CmdDebugMarkerEndEXT;
-    PFN_vkCmdDebugMarkerInsertEXT CmdDebugMarkerInsertEXT;
-
-    // ---- VK_AMD_draw_indirect_count extension commands
-    PFN_vkCmdDrawIndirectCountAMD CmdDrawIndirectCountAMD;
-    PFN_vkCmdDrawIndexedIndirectCountAMD CmdDrawIndexedIndirectCountAMD;
-
-    // ---- VK_AMD_shader_info extension commands
-    PFN_vkGetShaderInfoAMD GetShaderInfoAMD;
-
-    // ---- VK_NV_external_memory_win32 extension commands
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    PFN_vkGetMemoryWin32HandleNV GetMemoryWin32HandleNV;
-#endif // VK_USE_PLATFORM_WIN32_KHR
-
-    // ---- VK_KHX_device_group extension commands
-    PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX GetDeviceGroupPeerMemoryFeaturesKHX;
-    PFN_vkCmdSetDeviceMaskKHX CmdSetDeviceMaskKHX;
-    PFN_vkCmdDispatchBaseKHX CmdDispatchBaseKHX;
-    PFN_vkGetDeviceGroupPresentCapabilitiesKHX GetDeviceGroupPresentCapabilitiesKHX;
-    PFN_vkGetDeviceGroupSurfacePresentModesKHX GetDeviceGroupSurfacePresentModesKHX;
-    PFN_vkAcquireNextImage2KHX AcquireNextImage2KHX;
-
-    // ---- VK_NVX_device_generated_commands extension commands
-    PFN_vkCmdProcessCommandsNVX CmdProcessCommandsNVX;
-    PFN_vkCmdReserveSpaceForCommandsNVX CmdReserveSpaceForCommandsNVX;
-    PFN_vkCreateIndirectCommandsLayoutNVX CreateIndirectCommandsLayoutNVX;
-    PFN_vkDestroyIndirectCommandsLayoutNVX DestroyIndirectCommandsLayoutNVX;
-    PFN_vkCreateObjectTableNVX CreateObjectTableNVX;
-    PFN_vkDestroyObjectTableNVX DestroyObjectTableNVX;
-    PFN_vkRegisterObjectsNVX RegisterObjectsNVX;
-    PFN_vkUnregisterObjectsNVX UnregisterObjectsNVX;
-
-    // ---- VK_NV_clip_space_w_scaling extension commands
-    PFN_vkCmdSetViewportWScalingNV CmdSetViewportWScalingNV;
-
-    // ---- VK_EXT_display_control extension commands
-    PFN_vkDisplayPowerControlEXT DisplayPowerControlEXT;
-    PFN_vkRegisterDeviceEventEXT RegisterDeviceEventEXT;
-    PFN_vkRegisterDisplayEventEXT RegisterDisplayEventEXT;
-    PFN_vkGetSwapchainCounterEXT GetSwapchainCounterEXT;
-
-    // ---- VK_GOOGLE_display_timing extension commands
-    PFN_vkGetRefreshCycleDurationGOOGLE GetRefreshCycleDurationGOOGLE;
-    PFN_vkGetPastPresentationTimingGOOGLE GetPastPresentationTimingGOOGLE;
-
-    // ---- VK_EXT_discard_rectangles extension commands
-    PFN_vkCmdSetDiscardRectangleEXT CmdSetDiscardRectangleEXT;
-
-    // ---- VK_EXT_hdr_metadata extension commands
-    PFN_vkSetHdrMetadataEXT SetHdrMetadataEXT;
-
-    // ---- VK_EXT_sample_locations extension commands
-    PFN_vkCmdSetSampleLocationsEXT CmdSetSampleLocationsEXT;
-
-    // ---- VK_EXT_validation_cache extension commands
-    PFN_vkCreateValidationCacheEXT CreateValidationCacheEXT;
-    PFN_vkDestroyValidationCacheEXT DestroyValidationCacheEXT;
-    PFN_vkMergeValidationCachesEXT MergeValidationCachesEXT;
-    PFN_vkGetValidationCacheDataEXT GetValidationCacheDataEXT;
-
-    // ---- VK_EXT_external_memory_host extension commands
-    PFN_vkGetMemoryHostPointerPropertiesEXT GetMemoryHostPointerPropertiesEXT;
-} VkLayerDispatchTable;
-
-
diff --git a/third_party/vulkan/vk_lunarg_debug_marker.h b/third_party/vulkan/vk_lunarg_debug_marker.h
deleted file mode 100644
index edff2b9ee..000000000
--- a/third_party/vulkan/vk_lunarg_debug_marker.h
+++ /dev/null
@@ -1,98 +0,0 @@
-//
-// File: vk_lunarg_debug_marker.h
-//
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and/or associated documentation files (the "Materials"), to
- * deal in the Materials without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Materials, and to permit persons to whom the Materials are
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice(s) and this permission notice shall be included in
- * all copies or substantial portions of the Materials.
- *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- *
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
- * USE OR OTHER DEALINGS IN THE MATERIALS.
- *
- * Authors:
- *   Jon Ashburn <jon@lunarg.com>
- *   Courtney Goeltzenleuchter <courtney@lunarg.com>
- */
-
-#ifndef __VK_DEBUG_MARKER_H__
-#define __VK_DEBUG_MARKER_H__
-
-#include "vulkan.h"
-
-#define VK_DEBUG_MARKER_EXTENSION_NUMBER 6
-#define VK_DEBUG_MARKER_EXTENSION_REVISION 1
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-/*
-***************************************************************************************************
-*   DebugMarker Vulkan Extension API
-***************************************************************************************************
-*/
-
-#define DEBUG_MARKER_EXTENSION_NAME "VK_LUNARG_DEBUG_MARKER"
-
-// ------------------------------------------------------------------------------------------------
-// Enumerations
-
-#define VK_DEBUG_MARKER_ENUM_EXTEND(type, id)                                  \
-    ((type)(VK_DEBUG_MARKER_EXTENSION_NUMBER * -1000 + (id)))
-
-#define VK_OBJECT_INFO_TYPE_DBG_OBJECT_TAG                                     \
-    VK_DEBUG_MARKER_ENUM_EXTEND(VkDbgObjectInfoType, 0)
-#define VK_OBJECT_INFO_TYPE_DBG_OBJECT_NAME                                    \
-    VK_DEBUG_MARKER_ENUM_EXTEND(VkDbgObjectInfoType, 1)
-
-// ------------------------------------------------------------------------------------------------
-// API functions
-
-typedef void(VKAPI_PTR *PFN_vkCmdDbgMarkerBegin)(VkCommandBuffer commandBuffer,
-                                                 const char *pMarker);
-typedef void(VKAPI_PTR *PFN_vkCmdDbgMarkerEnd)(VkCommandBuffer commandBuffer);
-typedef VkResult(VKAPI_PTR *PFN_vkDbgSetObjectTag)(
-    VkDevice device, VkDebugReportObjectTypeEXT objType, uint64_t object,
-    size_t tagSize, const void *pTag);
-typedef VkResult(VKAPI_PTR *PFN_vkDbgSetObjectName)(
-    VkDevice device, VkDebugReportObjectTypeEXT objType, uint64_t object,
-    size_t nameSize, const char *pName);
-
-#ifndef VK_NO_PROTOTYPES
-
-// DebugMarker extension entrypoints
-VKAPI_ATTR void VKAPI_CALL
-vkCmdDbgMarkerBegin(VkCommandBuffer commandBuffer, const char *pMarker);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDbgMarkerEnd(VkCommandBuffer commandBuffer);
-
-VKAPI_ATTR VkResult VKAPI_CALL
-vkDbgSetObjectTag(VkDevice device, VkDebugReportObjectTypeEXT objType,
-                  uint64_t object, size_t tagSize, const void *pTag);
-
-VKAPI_ATTR VkResult VKAPI_CALL
-vkDbgSetObjectName(VkDevice device, VkDebugReportObjectTypeEXT objType,
-                   uint64_t object, size_t nameSize, const char *pName);
-
-#endif // VK_NO_PROTOTYPES
-
-#ifdef __cplusplus
-} // extern "C"
-#endif // __cplusplus
-
-#endif // __VK_DEBUG_MARKER_H__
diff --git a/third_party/vulkan/vk_platform.h b/third_party/vulkan/vk_platform.h
index 72f80493c..728929924 100644
--- a/third_party/vulkan/vk_platform.h
+++ b/third_party/vulkan/vk_platform.h
@@ -89,32 +89,4 @@ extern "C"
 } // extern "C"
 #endif // __cplusplus
 
-// Platform-specific headers required by platform window system extensions.
-// These are enabled prior to #including "vulkan.h". The same enable then
-// controls inclusion of the extension interfaces in vulkan.h.
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-#include <android/native_window.h>
-#endif
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-#include <mir_toolkit/client_types.h>
-#endif
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-#include <wayland-client.h>
-#endif
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#include <windows.h>
-#endif
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-#include <X11/Xlib.h>
-#endif
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-#include <xcb/xcb.h>
-#endif
-
 #endif
diff --git a/third_party/vulkan/vk_sdk_platform.h b/third_party/vulkan/vk_sdk_platform.h
deleted file mode 100644
index 96d867694..000000000
--- a/third_party/vulkan/vk_sdk_platform.h
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// File: vk_sdk_platform.h
-//
-/*
- * Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef VK_SDK_PLATFORM_H
-#define VK_SDK_PLATFORM_H
-
-#if defined(_WIN32)
-#define NOMINMAX
-#ifndef __cplusplus
-#undef inline
-#define inline __inline
-#endif // __cplusplus
-
-#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/)
-// C99:
-// Microsoft didn't implement C99 in Visual Studio; but started adding it with
-// VS2013.  However, VS2013 still didn't have snprintf().  The following is a
-// work-around (Note: The _CRT_SECURE_NO_WARNINGS macro must be set in the
-// "CMakeLists.txt" file).
-// NOTE: This is fixed in Visual Studio 2015.
-#define snprintf _snprintf
-#endif
-
-#define strdup _strdup
-
-#endif // _WIN32
-
-// Check for noexcept support using clang, with fallback to Windows or GCC version numbers
-#ifndef NOEXCEPT
-#if defined(__clang__)
-#if __has_feature(cxx_noexcept)
-#define HAS_NOEXCEPT
-#endif
-#else
-#if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46
-#define HAS_NOEXCEPT
-#else
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026 && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS
-#define HAS_NOEXCEPT
-#endif
-#endif
-#endif
-
-#ifdef HAS_NOEXCEPT
-#define NOEXCEPT noexcept
-#else
-#define NOEXCEPT
-#endif
-#endif
-
-#endif  // VK_SDK_PLATFORM_H
diff --git a/third_party/vulkan/vulkan.h b/third_party/vulkan/vulkan.h
index d3e2e246c..d05c8490a 100644
--- a/third_party/vulkan/vulkan.h
+++ b/third_party/vulkan/vulkan.h
@@ -1,10 +1,6 @@
 #ifndef VULKAN_H_
 #define VULKAN_H_ 1
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /*
 ** Copyright (c) 2015-2018 The Khronos Group Inc.
 **
@@ -21,7012 +17,63 @@ extern "C" {
 ** limitations under the License.
 */
 
-/*
-** This header is generated from the Khronos Vulkan XML API Registry.
-**
-*/
-
-
-#define VK_VERSION_1_0 1
 #include "vk_platform.h"
-
-#define VK_MAKE_VERSION(major, minor, patch) \
-    (((major) << 22) | ((minor) << 12) | (patch))
-
-// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
-//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
-
-// Vulkan 1.0 version number
-#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
-
-#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
-#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
-#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
-// Version of this file
-#define VK_HEADER_VERSION 68
-
-
-#define VK_NULL_HANDLE 0
-        
-
-
-#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
-
-
-#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
-#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
-#else
-        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
-#endif
-#endif
-        
-
-
-typedef uint32_t VkFlags;
-typedef uint32_t VkBool32;
-typedef uint64_t VkDeviceSize;
-typedef uint32_t VkSampleMask;
-
-VK_DEFINE_HANDLE(VkInstance)
-VK_DEFINE_HANDLE(VkPhysicalDevice)
-VK_DEFINE_HANDLE(VkDevice)
-VK_DEFINE_HANDLE(VkQueue)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
-VK_DEFINE_HANDLE(VkCommandBuffer)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
-
-#define VK_LOD_CLAMP_NONE                 1000.0f
-#define VK_REMAINING_MIP_LEVELS           (~0U)
-#define VK_REMAINING_ARRAY_LAYERS         (~0U)
-#define VK_WHOLE_SIZE                     (~0ULL)
-#define VK_ATTACHMENT_UNUSED              (~0U)
-#define VK_TRUE                           1
-#define VK_FALSE                          0
-#define VK_QUEUE_FAMILY_IGNORED           (~0U)
-#define VK_SUBPASS_EXTERNAL               (~0U)
-#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
-#define VK_UUID_SIZE                      16
-#define VK_MAX_MEMORY_TYPES               32
-#define VK_MAX_MEMORY_HEAPS               16
-#define VK_MAX_EXTENSION_NAME_SIZE        256
-#define VK_MAX_DESCRIPTION_SIZE           256
-
-
-typedef enum VkPipelineCacheHeaderVersion {
-    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
-    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
-    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
-    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
-    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
-} VkPipelineCacheHeaderVersion;
-
-typedef enum VkResult {
-    VK_SUCCESS = 0,
-    VK_NOT_READY = 1,
-    VK_TIMEOUT = 2,
-    VK_EVENT_SET = 3,
-    VK_EVENT_RESET = 4,
-    VK_INCOMPLETE = 5,
-    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
-    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
-    VK_ERROR_INITIALIZATION_FAILED = -3,
-    VK_ERROR_DEVICE_LOST = -4,
-    VK_ERROR_MEMORY_MAP_FAILED = -5,
-    VK_ERROR_LAYER_NOT_PRESENT = -6,
-    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
-    VK_ERROR_FEATURE_NOT_PRESENT = -8,
-    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
-    VK_ERROR_TOO_MANY_OBJECTS = -10,
-    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
-    VK_ERROR_FRAGMENTED_POOL = -12,
-    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
-    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
-    VK_SUBOPTIMAL_KHR = 1000001003,
-    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
-    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
-    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
-    VK_ERROR_INVALID_SHADER_NV = -1000012000,
-    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000,
-    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = -1000072003,
-    VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
-    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
-    VK_RESULT_END_RANGE = VK_INCOMPLETE,
-    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
-    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
-} VkResult;
-
-typedef enum VkStructureType {
-    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
-    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
-    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
-    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
-    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
-    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
-    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
-    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
-    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
-    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
-    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
-    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
-    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
-    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
-    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
-    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
-    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
-    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
-    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
-    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
-    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
-    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
-    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
-    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
-    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
-    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
-    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
-    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
-    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
-    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
-    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
-    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
-    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
-    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
-    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
-    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
-    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
-    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
-    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
-    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
-    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
-    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
-    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
-    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
-    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
-    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
-    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
-    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
-    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
-    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
-    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
-    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
-    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
-    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
-    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
-    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
-    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
-    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
-    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
-    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
-    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
-    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
-    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
-    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
-    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
-    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
-    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
-    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX = 1000053000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX = 1000053001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX = 1000053002,
-    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
-    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
-    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
-    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
-    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = 1000059000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = 1000059001,
-    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = 1000059002,
-    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059003,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = 1000059004,
-    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000059005,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = 1000059006,
-    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = 1000059007,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = 1000059008,
-    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX = 1000060000,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX = 1000060003,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX = 1000060004,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX = 1000060005,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX = 1000060006,
-    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX = 1000060010,
-    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060013,
-    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX = 1000060014,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX = 1000060007,
-    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX = 1000060008,
-    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX = 1000060009,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX = 1000060011,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX = 1000060012,
-    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
-    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX = 1000070000,
-    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX = 1000070001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = 1000071000,
-    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = 1000071001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = 1000071002,
-    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = 1000071003,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = 1000071004,
-    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = 1000072000,
-    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = 1000072001,
-    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = 1000072002,
-    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
-    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
-    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
-    VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
-    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
-    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
-    VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
-    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = 1000076000,
-    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = 1000076001,
-    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = 1000077000,
-    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
-    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
-    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
-    VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
-    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
-    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = 1000083000,
-    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
-    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = 1000085000,
-    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
-    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
-    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
-    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
-    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
-    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
-    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
-    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
-    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
-    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
-    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
-    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
-    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
-    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
-    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
-    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
-    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
-    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = 1000112000,
-    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = 1000112001,
-    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = 1000113000,
-    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
-    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
-    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
-    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
-    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = 1000117000,
-    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = 1000117001,
-    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = 1000117002,
-    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = 1000117003,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
-    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
-    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = 1000120000,
-    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
-    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
-    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = 1000127000,
-    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = 1000127001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
-    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
-    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
-    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
-    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
-    VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
-    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146000,
-    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146001,
-    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = 1000146002,
-    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = 1000146003,
-    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = 1000146004,
-    VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
-    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
-    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
-    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
-    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = 1000156000,
-    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = 1000156001,
-    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = 1000156002,
-    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = 1000156003,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = 1000156004,
-    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = 1000156005,
-    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = 1000157000,
-    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = 1000157001,
-    VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
-    VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
-    VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
-    VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
-    VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
-    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
-    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
-    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
-    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkStructureType;
-
-typedef enum VkSystemAllocationScope {
-    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
-    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
-    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
-    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
-    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
-    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
-    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
-    VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
-    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
-} VkSystemAllocationScope;
-
-typedef enum VkInternalAllocationType {
-    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
-    VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
-    VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
-    VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
-    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkInternalAllocationType;
-
-typedef enum VkFormat {
-    VK_FORMAT_UNDEFINED = 0,
-    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
-    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
-    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
-    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
-    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
-    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
-    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
-    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
-    VK_FORMAT_R8_UNORM = 9,
-    VK_FORMAT_R8_SNORM = 10,
-    VK_FORMAT_R8_USCALED = 11,
-    VK_FORMAT_R8_SSCALED = 12,
-    VK_FORMAT_R8_UINT = 13,
-    VK_FORMAT_R8_SINT = 14,
-    VK_FORMAT_R8_SRGB = 15,
-    VK_FORMAT_R8G8_UNORM = 16,
-    VK_FORMAT_R8G8_SNORM = 17,
-    VK_FORMAT_R8G8_USCALED = 18,
-    VK_FORMAT_R8G8_SSCALED = 19,
-    VK_FORMAT_R8G8_UINT = 20,
-    VK_FORMAT_R8G8_SINT = 21,
-    VK_FORMAT_R8G8_SRGB = 22,
-    VK_FORMAT_R8G8B8_UNORM = 23,
-    VK_FORMAT_R8G8B8_SNORM = 24,
-    VK_FORMAT_R8G8B8_USCALED = 25,
-    VK_FORMAT_R8G8B8_SSCALED = 26,
-    VK_FORMAT_R8G8B8_UINT = 27,
-    VK_FORMAT_R8G8B8_SINT = 28,
-    VK_FORMAT_R8G8B8_SRGB = 29,
-    VK_FORMAT_B8G8R8_UNORM = 30,
-    VK_FORMAT_B8G8R8_SNORM = 31,
-    VK_FORMAT_B8G8R8_USCALED = 32,
-    VK_FORMAT_B8G8R8_SSCALED = 33,
-    VK_FORMAT_B8G8R8_UINT = 34,
-    VK_FORMAT_B8G8R8_SINT = 35,
-    VK_FORMAT_B8G8R8_SRGB = 36,
-    VK_FORMAT_R8G8B8A8_UNORM = 37,
-    VK_FORMAT_R8G8B8A8_SNORM = 38,
-    VK_FORMAT_R8G8B8A8_USCALED = 39,
-    VK_FORMAT_R8G8B8A8_SSCALED = 40,
-    VK_FORMAT_R8G8B8A8_UINT = 41,
-    VK_FORMAT_R8G8B8A8_SINT = 42,
-    VK_FORMAT_R8G8B8A8_SRGB = 43,
-    VK_FORMAT_B8G8R8A8_UNORM = 44,
-    VK_FORMAT_B8G8R8A8_SNORM = 45,
-    VK_FORMAT_B8G8R8A8_USCALED = 46,
-    VK_FORMAT_B8G8R8A8_SSCALED = 47,
-    VK_FORMAT_B8G8R8A8_UINT = 48,
-    VK_FORMAT_B8G8R8A8_SINT = 49,
-    VK_FORMAT_B8G8R8A8_SRGB = 50,
-    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
-    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
-    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
-    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
-    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
-    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
-    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
-    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
-    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
-    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
-    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
-    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
-    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
-    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
-    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
-    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
-    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
-    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
-    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
-    VK_FORMAT_R16_UNORM = 70,
-    VK_FORMAT_R16_SNORM = 71,
-    VK_FORMAT_R16_USCALED = 72,
-    VK_FORMAT_R16_SSCALED = 73,
-    VK_FORMAT_R16_UINT = 74,
-    VK_FORMAT_R16_SINT = 75,
-    VK_FORMAT_R16_SFLOAT = 76,
-    VK_FORMAT_R16G16_UNORM = 77,
-    VK_FORMAT_R16G16_SNORM = 78,
-    VK_FORMAT_R16G16_USCALED = 79,
-    VK_FORMAT_R16G16_SSCALED = 80,
-    VK_FORMAT_R16G16_UINT = 81,
-    VK_FORMAT_R16G16_SINT = 82,
-    VK_FORMAT_R16G16_SFLOAT = 83,
-    VK_FORMAT_R16G16B16_UNORM = 84,
-    VK_FORMAT_R16G16B16_SNORM = 85,
-    VK_FORMAT_R16G16B16_USCALED = 86,
-    VK_FORMAT_R16G16B16_SSCALED = 87,
-    VK_FORMAT_R16G16B16_UINT = 88,
-    VK_FORMAT_R16G16B16_SINT = 89,
-    VK_FORMAT_R16G16B16_SFLOAT = 90,
-    VK_FORMAT_R16G16B16A16_UNORM = 91,
-    VK_FORMAT_R16G16B16A16_SNORM = 92,
-    VK_FORMAT_R16G16B16A16_USCALED = 93,
-    VK_FORMAT_R16G16B16A16_SSCALED = 94,
-    VK_FORMAT_R16G16B16A16_UINT = 95,
-    VK_FORMAT_R16G16B16A16_SINT = 96,
-    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
-    VK_FORMAT_R32_UINT = 98,
-    VK_FORMAT_R32_SINT = 99,
-    VK_FORMAT_R32_SFLOAT = 100,
-    VK_FORMAT_R32G32_UINT = 101,
-    VK_FORMAT_R32G32_SINT = 102,
-    VK_FORMAT_R32G32_SFLOAT = 103,
-    VK_FORMAT_R32G32B32_UINT = 104,
-    VK_FORMAT_R32G32B32_SINT = 105,
-    VK_FORMAT_R32G32B32_SFLOAT = 106,
-    VK_FORMAT_R32G32B32A32_UINT = 107,
-    VK_FORMAT_R32G32B32A32_SINT = 108,
-    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
-    VK_FORMAT_R64_UINT = 110,
-    VK_FORMAT_R64_SINT = 111,
-    VK_FORMAT_R64_SFLOAT = 112,
-    VK_FORMAT_R64G64_UINT = 113,
-    VK_FORMAT_R64G64_SINT = 114,
-    VK_FORMAT_R64G64_SFLOAT = 115,
-    VK_FORMAT_R64G64B64_UINT = 116,
-    VK_FORMAT_R64G64B64_SINT = 117,
-    VK_FORMAT_R64G64B64_SFLOAT = 118,
-    VK_FORMAT_R64G64B64A64_UINT = 119,
-    VK_FORMAT_R64G64B64A64_SINT = 120,
-    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
-    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
-    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
-    VK_FORMAT_D16_UNORM = 124,
-    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
-    VK_FORMAT_D32_SFLOAT = 126,
-    VK_FORMAT_S8_UINT = 127,
-    VK_FORMAT_D16_UNORM_S8_UINT = 128,
-    VK_FORMAT_D24_UNORM_S8_UINT = 129,
-    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
-    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
-    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
-    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
-    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
-    VK_FORMAT_BC2_UNORM_BLOCK = 135,
-    VK_FORMAT_BC2_SRGB_BLOCK = 136,
-    VK_FORMAT_BC3_UNORM_BLOCK = 137,
-    VK_FORMAT_BC3_SRGB_BLOCK = 138,
-    VK_FORMAT_BC4_UNORM_BLOCK = 139,
-    VK_FORMAT_BC4_SNORM_BLOCK = 140,
-    VK_FORMAT_BC5_UNORM_BLOCK = 141,
-    VK_FORMAT_BC5_SNORM_BLOCK = 142,
-    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
-    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
-    VK_FORMAT_BC7_UNORM_BLOCK = 145,
-    VK_FORMAT_BC7_SRGB_BLOCK = 146,
-    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
-    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
-    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
-    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
-    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
-    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
-    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
-    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
-    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
-    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
-    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
-    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
-    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
-    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
-    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
-    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
-    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
-    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
-    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
-    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
-    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
-    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
-    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
-    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
-    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
-    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
-    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
-    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
-    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
-    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
-    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
-    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
-    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
-    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
-    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
-    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
-    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
-    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
-    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
-    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
-    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
-    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
-    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
-    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
-    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
-    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
-    VK_FORMAT_G8B8G8R8_422_UNORM_KHR = 1000156000,
-    VK_FORMAT_B8G8R8G8_422_UNORM_KHR = 1000156001,
-    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = 1000156002,
-    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = 1000156003,
-    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = 1000156004,
-    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = 1000156005,
-    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = 1000156006,
-    VK_FORMAT_R10X6_UNORM_PACK16_KHR = 1000156007,
-    VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = 1000156008,
-    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = 1000156009,
-    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = 1000156010,
-    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = 1000156011,
-    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012,
-    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = 1000156013,
-    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014,
-    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = 1000156015,
-    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016,
-    VK_FORMAT_R12X4_UNORM_PACK16_KHR = 1000156017,
-    VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = 1000156018,
-    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = 1000156019,
-    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = 1000156020,
-    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = 1000156021,
-    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022,
-    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = 1000156023,
-    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024,
-    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = 1000156025,
-    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026,
-    VK_FORMAT_G16B16G16R16_422_UNORM_KHR = 1000156027,
-    VK_FORMAT_B16G16R16G16_422_UNORM_KHR = 1000156028,
-    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = 1000156029,
-    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = 1000156030,
-    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = 1000156031,
-    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = 1000156032,
-    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = 1000156033,
-    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
-    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
-    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
-} VkFormat;
-
-typedef enum VkImageType {
-    VK_IMAGE_TYPE_1D = 0,
-    VK_IMAGE_TYPE_2D = 1,
-    VK_IMAGE_TYPE_3D = 2,
-    VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
-    VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
-    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
-    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkImageType;
-
-typedef enum VkImageTiling {
-    VK_IMAGE_TILING_OPTIMAL = 0,
-    VK_IMAGE_TILING_LINEAR = 1,
-    VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
-    VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
-    VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
-    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
-} VkImageTiling;
-
-typedef enum VkPhysicalDeviceType {
-    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
-    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
-    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
-    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
-    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
-    VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
-    VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
-    VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
-    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkPhysicalDeviceType;
-
-typedef enum VkQueryType {
-    VK_QUERY_TYPE_OCCLUSION = 0,
-    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
-    VK_QUERY_TYPE_TIMESTAMP = 2,
-    VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
-    VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
-    VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
-    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkQueryType;
-
-typedef enum VkSharingMode {
-    VK_SHARING_MODE_EXCLUSIVE = 0,
-    VK_SHARING_MODE_CONCURRENT = 1,
-    VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
-    VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
-    VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
-    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkSharingMode;
-
-typedef enum VkImageLayout {
-    VK_IMAGE_LAYOUT_UNDEFINED = 0,
-    VK_IMAGE_LAYOUT_GENERAL = 1,
-    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
-    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
-    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
-    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
-    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
-    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
-    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
-    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
-    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
-    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000,
-    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001,
-    VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
-    VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
-    VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
-    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
-} VkImageLayout;
-
-typedef enum VkImageViewType {
-    VK_IMAGE_VIEW_TYPE_1D = 0,
-    VK_IMAGE_VIEW_TYPE_2D = 1,
-    VK_IMAGE_VIEW_TYPE_3D = 2,
-    VK_IMAGE_VIEW_TYPE_CUBE = 3,
-    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
-    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
-    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
-    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
-    VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
-    VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
-    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkImageViewType;
-
-typedef enum VkComponentSwizzle {
-    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
-    VK_COMPONENT_SWIZZLE_ZERO = 1,
-    VK_COMPONENT_SWIZZLE_ONE = 2,
-    VK_COMPONENT_SWIZZLE_R = 3,
-    VK_COMPONENT_SWIZZLE_G = 4,
-    VK_COMPONENT_SWIZZLE_B = 5,
-    VK_COMPONENT_SWIZZLE_A = 6,
-    VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
-    VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
-    VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
-    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
-} VkComponentSwizzle;
-
-typedef enum VkVertexInputRate {
-    VK_VERTEX_INPUT_RATE_VERTEX = 0,
-    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
-    VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
-    VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
-    VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
-    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
-} VkVertexInputRate;
-
-typedef enum VkPrimitiveTopology {
-    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
-    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
-    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
-    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
-    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
-    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
-    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
-    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
-    VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
-    VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
-    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
-} VkPrimitiveTopology;
-
-typedef enum VkPolygonMode {
-    VK_POLYGON_MODE_FILL = 0,
-    VK_POLYGON_MODE_LINE = 1,
-    VK_POLYGON_MODE_POINT = 2,
-    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
-    VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
-    VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
-    VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
-    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkPolygonMode;
-
-typedef enum VkFrontFace {
-    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
-    VK_FRONT_FACE_CLOCKWISE = 1,
-    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
-    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
-    VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
-    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
-} VkFrontFace;
-
-typedef enum VkCompareOp {
-    VK_COMPARE_OP_NEVER = 0,
-    VK_COMPARE_OP_LESS = 1,
-    VK_COMPARE_OP_EQUAL = 2,
-    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
-    VK_COMPARE_OP_GREATER = 4,
-    VK_COMPARE_OP_NOT_EQUAL = 5,
-    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
-    VK_COMPARE_OP_ALWAYS = 7,
-    VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
-    VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
-    VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
-    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
-} VkCompareOp;
-
-typedef enum VkStencilOp {
-    VK_STENCIL_OP_KEEP = 0,
-    VK_STENCIL_OP_ZERO = 1,
-    VK_STENCIL_OP_REPLACE = 2,
-    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
-    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
-    VK_STENCIL_OP_INVERT = 5,
-    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
-    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
-    VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
-    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
-    VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
-    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
-} VkStencilOp;
-
-typedef enum VkLogicOp {
-    VK_LOGIC_OP_CLEAR = 0,
-    VK_LOGIC_OP_AND = 1,
-    VK_LOGIC_OP_AND_REVERSE = 2,
-    VK_LOGIC_OP_COPY = 3,
-    VK_LOGIC_OP_AND_INVERTED = 4,
-    VK_LOGIC_OP_NO_OP = 5,
-    VK_LOGIC_OP_XOR = 6,
-    VK_LOGIC_OP_OR = 7,
-    VK_LOGIC_OP_NOR = 8,
-    VK_LOGIC_OP_EQUIVALENT = 9,
-    VK_LOGIC_OP_INVERT = 10,
-    VK_LOGIC_OP_OR_REVERSE = 11,
-    VK_LOGIC_OP_COPY_INVERTED = 12,
-    VK_LOGIC_OP_OR_INVERTED = 13,
-    VK_LOGIC_OP_NAND = 14,
-    VK_LOGIC_OP_SET = 15,
-    VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
-    VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
-    VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
-    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
-} VkLogicOp;
-
-typedef enum VkBlendFactor {
-    VK_BLEND_FACTOR_ZERO = 0,
-    VK_BLEND_FACTOR_ONE = 1,
-    VK_BLEND_FACTOR_SRC_COLOR = 2,
-    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
-    VK_BLEND_FACTOR_DST_COLOR = 4,
-    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
-    VK_BLEND_FACTOR_SRC_ALPHA = 6,
-    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
-    VK_BLEND_FACTOR_DST_ALPHA = 8,
-    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
-    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
-    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
-    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
-    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
-    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
-    VK_BLEND_FACTOR_SRC1_COLOR = 15,
-    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
-    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
-    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
-    VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
-    VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
-    VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
-    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
-} VkBlendFactor;
-
-typedef enum VkBlendOp {
-    VK_BLEND_OP_ADD = 0,
-    VK_BLEND_OP_SUBTRACT = 1,
-    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
-    VK_BLEND_OP_MIN = 3,
-    VK_BLEND_OP_MAX = 4,
-    VK_BLEND_OP_ZERO_EXT = 1000148000,
-    VK_BLEND_OP_SRC_EXT = 1000148001,
-    VK_BLEND_OP_DST_EXT = 1000148002,
-    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
-    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
-    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
-    VK_BLEND_OP_DST_IN_EXT = 1000148006,
-    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
-    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
-    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
-    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
-    VK_BLEND_OP_XOR_EXT = 1000148011,
-    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
-    VK_BLEND_OP_SCREEN_EXT = 1000148013,
-    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
-    VK_BLEND_OP_DARKEN_EXT = 1000148015,
-    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
-    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
-    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
-    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
-    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
-    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
-    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
-    VK_BLEND_OP_INVERT_EXT = 1000148023,
-    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
-    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
-    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
-    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
-    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
-    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
-    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
-    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
-    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
-    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
-    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
-    VK_BLEND_OP_PLUS_EXT = 1000148035,
-    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
-    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
-    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
-    VK_BLEND_OP_MINUS_EXT = 1000148039,
-    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
-    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
-    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
-    VK_BLEND_OP_RED_EXT = 1000148043,
-    VK_BLEND_OP_GREEN_EXT = 1000148044,
-    VK_BLEND_OP_BLUE_EXT = 1000148045,
-    VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
-    VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
-    VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
-    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
-} VkBlendOp;
-
-typedef enum VkDynamicState {
-    VK_DYNAMIC_STATE_VIEWPORT = 0,
-    VK_DYNAMIC_STATE_SCISSOR = 1,
-    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
-    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
-    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
-    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
-    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
-    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
-    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
-    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
-    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
-    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
-    VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
-    VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
-    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
-} VkDynamicState;
-
-typedef enum VkFilter {
-    VK_FILTER_NEAREST = 0,
-    VK_FILTER_LINEAR = 1,
-    VK_FILTER_CUBIC_IMG = 1000015000,
-    VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
-    VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
-    VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
-    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
-} VkFilter;
-
-typedef enum VkSamplerMipmapMode {
-    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
-    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
-    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-    VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
-    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
-    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkSamplerMipmapMode;
-
-typedef enum VkSamplerAddressMode {
-    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
-    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
-    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
-    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
-    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
-    VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
-    VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-    VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
-    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkSamplerAddressMode;
-
-typedef enum VkBorderColor {
-    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
-    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
-    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
-    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
-    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
-    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
-    VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-    VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
-    VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
-    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
-} VkBorderColor;
-
-typedef enum VkDescriptorType {
-    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
-    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
-    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
-    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
-    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
-    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
-    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
-    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
-    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
-    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
-    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
-    VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
-    VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
-    VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
-    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkDescriptorType;
-
-typedef enum VkAttachmentLoadOp {
-    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
-    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
-    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
-    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
-    VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-    VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
-    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
-} VkAttachmentLoadOp;
-
-typedef enum VkAttachmentStoreOp {
-    VK_ATTACHMENT_STORE_OP_STORE = 0,
-    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
-    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
-    VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-    VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
-    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
-} VkAttachmentStoreOp;
-
-typedef enum VkPipelineBindPoint {
-    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
-    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
-    VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
-    VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
-    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
-    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
-} VkPipelineBindPoint;
-
-typedef enum VkCommandBufferLevel {
-    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
-    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
-    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
-    VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
-    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
-} VkCommandBufferLevel;
-
-typedef enum VkIndexType {
-    VK_INDEX_TYPE_UINT16 = 0,
-    VK_INDEX_TYPE_UINT32 = 1,
-    VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
-    VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
-    VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
-    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkIndexType;
-
-typedef enum VkSubpassContents {
-    VK_SUBPASS_CONTENTS_INLINE = 0,
-    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
-    VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
-    VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
-    VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
-    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
-} VkSubpassContents;
-
-typedef enum VkObjectType {
-    VK_OBJECT_TYPE_UNKNOWN = 0,
-    VK_OBJECT_TYPE_INSTANCE = 1,
-    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
-    VK_OBJECT_TYPE_DEVICE = 3,
-    VK_OBJECT_TYPE_QUEUE = 4,
-    VK_OBJECT_TYPE_SEMAPHORE = 5,
-    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
-    VK_OBJECT_TYPE_FENCE = 7,
-    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
-    VK_OBJECT_TYPE_BUFFER = 9,
-    VK_OBJECT_TYPE_IMAGE = 10,
-    VK_OBJECT_TYPE_EVENT = 11,
-    VK_OBJECT_TYPE_QUERY_POOL = 12,
-    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
-    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
-    VK_OBJECT_TYPE_SHADER_MODULE = 15,
-    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
-    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
-    VK_OBJECT_TYPE_RENDER_PASS = 18,
-    VK_OBJECT_TYPE_PIPELINE = 19,
-    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
-    VK_OBJECT_TYPE_SAMPLER = 21,
-    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
-    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
-    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
-    VK_OBJECT_TYPE_COMMAND_POOL = 25,
-    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
-    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
-    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
-    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
-    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
-    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000,
-    VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
-    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
-    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = 1000156000,
-    VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
-    VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
-    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
-    VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
-    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkObjectType;
-
-typedef VkFlags VkInstanceCreateFlags;
-
-typedef enum VkFormatFeatureFlagBits {
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
-    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
-    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
-    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
-    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
-    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
-    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
-    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
-    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
-    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
-    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
-    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
-    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = 0x00004000,
-    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = 0x00008000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
-    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000,
-    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000,
-    VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = 0x00400000,
-    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000,
-    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkFormatFeatureFlagBits;
-typedef VkFlags VkFormatFeatureFlags;
-
-typedef enum VkImageUsageFlagBits {
-    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
-    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
-    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
-    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
-    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
-    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
-    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
-    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
-    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkImageUsageFlagBits;
-typedef VkFlags VkImageUsageFlags;
-
-typedef enum VkImageCreateFlagBits {
-    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
-    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
-    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
-    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
-    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
-    VK_IMAGE_CREATE_BIND_SFR_BIT_KHX = 0x00000040,
-    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = 0x00000020,
-    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = 0x00000080,
-    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = 0x00000100,
-    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
-    VK_IMAGE_CREATE_DISJOINT_BIT_KHR = 0x00000200,
-    VK_IMAGE_CREATE_ALIAS_BIT_KHR = 0x00000400,
-    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkImageCreateFlagBits;
-typedef VkFlags VkImageCreateFlags;
-
-typedef enum VkSampleCountFlagBits {
-    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
-    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
-    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
-    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
-    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
-    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
-    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
-    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkSampleCountFlagBits;
-typedef VkFlags VkSampleCountFlags;
-
-typedef enum VkQueueFlagBits {
-    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
-    VK_QUEUE_COMPUTE_BIT = 0x00000002,
-    VK_QUEUE_TRANSFER_BIT = 0x00000004,
-    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
-    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkQueueFlagBits;
-typedef VkFlags VkQueueFlags;
-
-typedef enum VkMemoryPropertyFlagBits {
-    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
-    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
-    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
-    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
-    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
-    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkMemoryPropertyFlagBits;
-typedef VkFlags VkMemoryPropertyFlags;
-
-typedef enum VkMemoryHeapFlagBits {
-    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
-    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX = 0x00000002,
-    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkMemoryHeapFlagBits;
-typedef VkFlags VkMemoryHeapFlags;
-typedef VkFlags VkDeviceCreateFlags;
-typedef VkFlags VkDeviceQueueCreateFlags;
-
-typedef enum VkPipelineStageFlagBits {
-    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
-    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
-    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
-    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
-    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
-    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
-    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
-    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
-    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
-    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
-    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
-    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
-    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
-    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
-    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
-    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
-    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
-    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
-    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkPipelineStageFlagBits;
-typedef VkFlags VkPipelineStageFlags;
-typedef VkFlags VkMemoryMapFlags;
-
-typedef enum VkImageAspectFlagBits {
-    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
-    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
-    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
-    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
-    VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = 0x00000010,
-    VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = 0x00000020,
-    VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = 0x00000040,
-    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkImageAspectFlagBits;
-typedef VkFlags VkImageAspectFlags;
-
-typedef enum VkSparseImageFormatFlagBits {
-    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
-    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
-    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
-    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkSparseImageFormatFlagBits;
-typedef VkFlags VkSparseImageFormatFlags;
-
-typedef enum VkSparseMemoryBindFlagBits {
-    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
-    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkSparseMemoryBindFlagBits;
-typedef VkFlags VkSparseMemoryBindFlags;
-
-typedef enum VkFenceCreateFlagBits {
-    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
-    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkFenceCreateFlagBits;
-typedef VkFlags VkFenceCreateFlags;
-typedef VkFlags VkSemaphoreCreateFlags;
-typedef VkFlags VkEventCreateFlags;
-typedef VkFlags VkQueryPoolCreateFlags;
-
-typedef enum VkQueryPipelineStatisticFlagBits {
-    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
-    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
-    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
-    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
-    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
-    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
-    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
-    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
-    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
-    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
-    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
-    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkQueryPipelineStatisticFlagBits;
-typedef VkFlags VkQueryPipelineStatisticFlags;
-
-typedef enum VkQueryResultFlagBits {
-    VK_QUERY_RESULT_64_BIT = 0x00000001,
-    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
-    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
-    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
-    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkQueryResultFlagBits;
-typedef VkFlags VkQueryResultFlags;
-
-typedef enum VkBufferCreateFlagBits {
-    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
-    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
-    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
-    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkBufferCreateFlagBits;
-typedef VkFlags VkBufferCreateFlags;
-
-typedef enum VkBufferUsageFlagBits {
-    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
-    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
-    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
-    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
-    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
-    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
-    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
-    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
-    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
-    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkBufferUsageFlagBits;
-typedef VkFlags VkBufferUsageFlags;
-typedef VkFlags VkBufferViewCreateFlags;
-typedef VkFlags VkImageViewCreateFlags;
-typedef VkFlags VkShaderModuleCreateFlags;
-typedef VkFlags VkPipelineCacheCreateFlags;
-
-typedef enum VkPipelineCreateFlagBits {
-    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
-    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
-    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
-    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX = 0x00000008,
-    VK_PIPELINE_CREATE_DISPATCH_BASE_KHX = 0x00000010,
-    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkPipelineCreateFlagBits;
-typedef VkFlags VkPipelineCreateFlags;
-typedef VkFlags VkPipelineShaderStageCreateFlags;
-
-typedef enum VkShaderStageFlagBits {
-    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
-    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
-    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
-    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
-    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
-    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
-    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
-    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
-    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkShaderStageFlagBits;
-typedef VkFlags VkPipelineVertexInputStateCreateFlags;
-typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
-typedef VkFlags VkPipelineTessellationStateCreateFlags;
-typedef VkFlags VkPipelineViewportStateCreateFlags;
-typedef VkFlags VkPipelineRasterizationStateCreateFlags;
-
-typedef enum VkCullModeFlagBits {
-    VK_CULL_MODE_NONE = 0,
-    VK_CULL_MODE_FRONT_BIT = 0x00000001,
-    VK_CULL_MODE_BACK_BIT = 0x00000002,
-    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
-    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkCullModeFlagBits;
-typedef VkFlags VkCullModeFlags;
-typedef VkFlags VkPipelineMultisampleStateCreateFlags;
-typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
-typedef VkFlags VkPipelineColorBlendStateCreateFlags;
-
-typedef enum VkColorComponentFlagBits {
-    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
-    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
-    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
-    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
-    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkColorComponentFlagBits;
-typedef VkFlags VkColorComponentFlags;
-typedef VkFlags VkPipelineDynamicStateCreateFlags;
-typedef VkFlags VkPipelineLayoutCreateFlags;
-typedef VkFlags VkShaderStageFlags;
-typedef VkFlags VkSamplerCreateFlags;
-
-typedef enum VkDescriptorSetLayoutCreateFlagBits {
-    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
-    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkDescriptorSetLayoutCreateFlagBits;
-typedef VkFlags VkDescriptorSetLayoutCreateFlags;
-
-typedef enum VkDescriptorPoolCreateFlagBits {
-    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
-    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkDescriptorPoolCreateFlagBits;
-typedef VkFlags VkDescriptorPoolCreateFlags;
-typedef VkFlags VkDescriptorPoolResetFlags;
-typedef VkFlags VkFramebufferCreateFlags;
-typedef VkFlags VkRenderPassCreateFlags;
-
-typedef enum VkAttachmentDescriptionFlagBits {
-    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
-    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkAttachmentDescriptionFlagBits;
-typedef VkFlags VkAttachmentDescriptionFlags;
-
-typedef enum VkSubpassDescriptionFlagBits {
-    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
-    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
-    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkSubpassDescriptionFlagBits;
-typedef VkFlags VkSubpassDescriptionFlags;
-
-typedef enum VkAccessFlagBits {
-    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
-    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
-    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
-    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
-    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
-    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
-    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
-    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
-    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
-    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
-    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
-    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
-    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
-    VK_ACCESS_HOST_READ_BIT = 0x00002000,
-    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
-    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
-    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
-    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
-    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
-    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
-    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkAccessFlagBits;
-typedef VkFlags VkAccessFlags;
-
-typedef enum VkDependencyFlagBits {
-    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
-    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX = 0x00000002,
-    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX = 0x00000004,
-    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkDependencyFlagBits;
-typedef VkFlags VkDependencyFlags;
-
-typedef enum VkCommandPoolCreateFlagBits {
-    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
-    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
-    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkCommandPoolCreateFlagBits;
-typedef VkFlags VkCommandPoolCreateFlags;
-
-typedef enum VkCommandPoolResetFlagBits {
-    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkCommandPoolResetFlagBits;
-typedef VkFlags VkCommandPoolResetFlags;
-
-typedef enum VkCommandBufferUsageFlagBits {
-    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
-    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
-    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
-    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkCommandBufferUsageFlagBits;
-typedef VkFlags VkCommandBufferUsageFlags;
-
-typedef enum VkQueryControlFlagBits {
-    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
-    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkQueryControlFlagBits;
-typedef VkFlags VkQueryControlFlags;
-
-typedef enum VkCommandBufferResetFlagBits {
-    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkCommandBufferResetFlagBits;
-typedef VkFlags VkCommandBufferResetFlags;
-
-typedef enum VkStencilFaceFlagBits {
-    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
-    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
-    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
-    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
-} VkStencilFaceFlagBits;
-typedef VkFlags VkStencilFaceFlags;
-
-typedef struct VkApplicationInfo {
-    VkStructureType    sType;
-    const void*        pNext;
-    const char*        pApplicationName;
-    uint32_t           applicationVersion;
-    const char*        pEngineName;
-    uint32_t           engineVersion;
-    uint32_t           apiVersion;
-} VkApplicationInfo;
-
-typedef struct VkInstanceCreateInfo {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkInstanceCreateFlags       flags;
-    const VkApplicationInfo*    pApplicationInfo;
-    uint32_t                    enabledLayerCount;
-    const char* const*          ppEnabledLayerNames;
-    uint32_t                    enabledExtensionCount;
-    const char* const*          ppEnabledExtensionNames;
-} VkInstanceCreateInfo;
-
-typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
-    void*                                       pUserData,
-    size_t                                      size,
-    size_t                                      alignment,
-    VkSystemAllocationScope                     allocationScope);
-
-typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
-    void*                                       pUserData,
-    void*                                       pOriginal,
-    size_t                                      size,
-    size_t                                      alignment,
-    VkSystemAllocationScope                     allocationScope);
-
-typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
-    void*                                       pUserData,
-    void*                                       pMemory);
-
-typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
-    void*                                       pUserData,
-    size_t                                      size,
-    VkInternalAllocationType                    allocationType,
-    VkSystemAllocationScope                     allocationScope);
-
-typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
-    void*                                       pUserData,
-    size_t                                      size,
-    VkInternalAllocationType                    allocationType,
-    VkSystemAllocationScope                     allocationScope);
-
-typedef struct VkAllocationCallbacks {
-    void*                                   pUserData;
-    PFN_vkAllocationFunction                pfnAllocation;
-    PFN_vkReallocationFunction              pfnReallocation;
-    PFN_vkFreeFunction                      pfnFree;
-    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
-    PFN_vkInternalFreeNotification          pfnInternalFree;
-} VkAllocationCallbacks;
-
-typedef struct VkPhysicalDeviceFeatures {
-    VkBool32    robustBufferAccess;
-    VkBool32    fullDrawIndexUint32;
-    VkBool32    imageCubeArray;
-    VkBool32    independentBlend;
-    VkBool32    geometryShader;
-    VkBool32    tessellationShader;
-    VkBool32    sampleRateShading;
-    VkBool32    dualSrcBlend;
-    VkBool32    logicOp;
-    VkBool32    multiDrawIndirect;
-    VkBool32    drawIndirectFirstInstance;
-    VkBool32    depthClamp;
-    VkBool32    depthBiasClamp;
-    VkBool32    fillModeNonSolid;
-    VkBool32    depthBounds;
-    VkBool32    wideLines;
-    VkBool32    largePoints;
-    VkBool32    alphaToOne;
-    VkBool32    multiViewport;
-    VkBool32    samplerAnisotropy;
-    VkBool32    textureCompressionETC2;
-    VkBool32    textureCompressionASTC_LDR;
-    VkBool32    textureCompressionBC;
-    VkBool32    occlusionQueryPrecise;
-    VkBool32    pipelineStatisticsQuery;
-    VkBool32    vertexPipelineStoresAndAtomics;
-    VkBool32    fragmentStoresAndAtomics;
-    VkBool32    shaderTessellationAndGeometryPointSize;
-    VkBool32    shaderImageGatherExtended;
-    VkBool32    shaderStorageImageExtendedFormats;
-    VkBool32    shaderStorageImageMultisample;
-    VkBool32    shaderStorageImageReadWithoutFormat;
-    VkBool32    shaderStorageImageWriteWithoutFormat;
-    VkBool32    shaderUniformBufferArrayDynamicIndexing;
-    VkBool32    shaderSampledImageArrayDynamicIndexing;
-    VkBool32    shaderStorageBufferArrayDynamicIndexing;
-    VkBool32    shaderStorageImageArrayDynamicIndexing;
-    VkBool32    shaderClipDistance;
-    VkBool32    shaderCullDistance;
-    VkBool32    shaderFloat64;
-    VkBool32    shaderInt64;
-    VkBool32    shaderInt16;
-    VkBool32    shaderResourceResidency;
-    VkBool32    shaderResourceMinLod;
-    VkBool32    sparseBinding;
-    VkBool32    sparseResidencyBuffer;
-    VkBool32    sparseResidencyImage2D;
-    VkBool32    sparseResidencyImage3D;
-    VkBool32    sparseResidency2Samples;
-    VkBool32    sparseResidency4Samples;
-    VkBool32    sparseResidency8Samples;
-    VkBool32    sparseResidency16Samples;
-    VkBool32    sparseResidencyAliased;
-    VkBool32    variableMultisampleRate;
-    VkBool32    inheritedQueries;
-} VkPhysicalDeviceFeatures;
-
-typedef struct VkFormatProperties {
-    VkFormatFeatureFlags    linearTilingFeatures;
-    VkFormatFeatureFlags    optimalTilingFeatures;
-    VkFormatFeatureFlags    bufferFeatures;
-} VkFormatProperties;
-
-typedef struct VkExtent3D {
-    uint32_t    width;
-    uint32_t    height;
-    uint32_t    depth;
-} VkExtent3D;
-
-typedef struct VkImageFormatProperties {
-    VkExtent3D            maxExtent;
-    uint32_t              maxMipLevels;
-    uint32_t              maxArrayLayers;
-    VkSampleCountFlags    sampleCounts;
-    VkDeviceSize          maxResourceSize;
-} VkImageFormatProperties;
-
-typedef struct VkPhysicalDeviceLimits {
-    uint32_t              maxImageDimension1D;
-    uint32_t              maxImageDimension2D;
-    uint32_t              maxImageDimension3D;
-    uint32_t              maxImageDimensionCube;
-    uint32_t              maxImageArrayLayers;
-    uint32_t              maxTexelBufferElements;
-    uint32_t              maxUniformBufferRange;
-    uint32_t              maxStorageBufferRange;
-    uint32_t              maxPushConstantsSize;
-    uint32_t              maxMemoryAllocationCount;
-    uint32_t              maxSamplerAllocationCount;
-    VkDeviceSize          bufferImageGranularity;
-    VkDeviceSize          sparseAddressSpaceSize;
-    uint32_t              maxBoundDescriptorSets;
-    uint32_t              maxPerStageDescriptorSamplers;
-    uint32_t              maxPerStageDescriptorUniformBuffers;
-    uint32_t              maxPerStageDescriptorStorageBuffers;
-    uint32_t              maxPerStageDescriptorSampledImages;
-    uint32_t              maxPerStageDescriptorStorageImages;
-    uint32_t              maxPerStageDescriptorInputAttachments;
-    uint32_t              maxPerStageResources;
-    uint32_t              maxDescriptorSetSamplers;
-    uint32_t              maxDescriptorSetUniformBuffers;
-    uint32_t              maxDescriptorSetUniformBuffersDynamic;
-    uint32_t              maxDescriptorSetStorageBuffers;
-    uint32_t              maxDescriptorSetStorageBuffersDynamic;
-    uint32_t              maxDescriptorSetSampledImages;
-    uint32_t              maxDescriptorSetStorageImages;
-    uint32_t              maxDescriptorSetInputAttachments;
-    uint32_t              maxVertexInputAttributes;
-    uint32_t              maxVertexInputBindings;
-    uint32_t              maxVertexInputAttributeOffset;
-    uint32_t              maxVertexInputBindingStride;
-    uint32_t              maxVertexOutputComponents;
-    uint32_t              maxTessellationGenerationLevel;
-    uint32_t              maxTessellationPatchSize;
-    uint32_t              maxTessellationControlPerVertexInputComponents;
-    uint32_t              maxTessellationControlPerVertexOutputComponents;
-    uint32_t              maxTessellationControlPerPatchOutputComponents;
-    uint32_t              maxTessellationControlTotalOutputComponents;
-    uint32_t              maxTessellationEvaluationInputComponents;
-    uint32_t              maxTessellationEvaluationOutputComponents;
-    uint32_t              maxGeometryShaderInvocations;
-    uint32_t              maxGeometryInputComponents;
-    uint32_t              maxGeometryOutputComponents;
-    uint32_t              maxGeometryOutputVertices;
-    uint32_t              maxGeometryTotalOutputComponents;
-    uint32_t              maxFragmentInputComponents;
-    uint32_t              maxFragmentOutputAttachments;
-    uint32_t              maxFragmentDualSrcAttachments;
-    uint32_t              maxFragmentCombinedOutputResources;
-    uint32_t              maxComputeSharedMemorySize;
-    uint32_t              maxComputeWorkGroupCount[3];
-    uint32_t              maxComputeWorkGroupInvocations;
-    uint32_t              maxComputeWorkGroupSize[3];
-    uint32_t              subPixelPrecisionBits;
-    uint32_t              subTexelPrecisionBits;
-    uint32_t              mipmapPrecisionBits;
-    uint32_t              maxDrawIndexedIndexValue;
-    uint32_t              maxDrawIndirectCount;
-    float                 maxSamplerLodBias;
-    float                 maxSamplerAnisotropy;
-    uint32_t              maxViewports;
-    uint32_t              maxViewportDimensions[2];
-    float                 viewportBoundsRange[2];
-    uint32_t              viewportSubPixelBits;
-    size_t                minMemoryMapAlignment;
-    VkDeviceSize          minTexelBufferOffsetAlignment;
-    VkDeviceSize          minUniformBufferOffsetAlignment;
-    VkDeviceSize          minStorageBufferOffsetAlignment;
-    int32_t               minTexelOffset;
-    uint32_t              maxTexelOffset;
-    int32_t               minTexelGatherOffset;
-    uint32_t              maxTexelGatherOffset;
-    float                 minInterpolationOffset;
-    float                 maxInterpolationOffset;
-    uint32_t              subPixelInterpolationOffsetBits;
-    uint32_t              maxFramebufferWidth;
-    uint32_t              maxFramebufferHeight;
-    uint32_t              maxFramebufferLayers;
-    VkSampleCountFlags    framebufferColorSampleCounts;
-    VkSampleCountFlags    framebufferDepthSampleCounts;
-    VkSampleCountFlags    framebufferStencilSampleCounts;
-    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
-    uint32_t              maxColorAttachments;
-    VkSampleCountFlags    sampledImageColorSampleCounts;
-    VkSampleCountFlags    sampledImageIntegerSampleCounts;
-    VkSampleCountFlags    sampledImageDepthSampleCounts;
-    VkSampleCountFlags    sampledImageStencilSampleCounts;
-    VkSampleCountFlags    storageImageSampleCounts;
-    uint32_t              maxSampleMaskWords;
-    VkBool32              timestampComputeAndGraphics;
-    float                 timestampPeriod;
-    uint32_t              maxClipDistances;
-    uint32_t              maxCullDistances;
-    uint32_t              maxCombinedClipAndCullDistances;
-    uint32_t              discreteQueuePriorities;
-    float                 pointSizeRange[2];
-    float                 lineWidthRange[2];
-    float                 pointSizeGranularity;
-    float                 lineWidthGranularity;
-    VkBool32              strictLines;
-    VkBool32              standardSampleLocations;
-    VkDeviceSize          optimalBufferCopyOffsetAlignment;
-    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
-    VkDeviceSize          nonCoherentAtomSize;
-} VkPhysicalDeviceLimits;
-
-typedef struct VkPhysicalDeviceSparseProperties {
-    VkBool32    residencyStandard2DBlockShape;
-    VkBool32    residencyStandard2DMultisampleBlockShape;
-    VkBool32    residencyStandard3DBlockShape;
-    VkBool32    residencyAlignedMipSize;
-    VkBool32    residencyNonResidentStrict;
-} VkPhysicalDeviceSparseProperties;
-
-typedef struct VkPhysicalDeviceProperties {
-    uint32_t                            apiVersion;
-    uint32_t                            driverVersion;
-    uint32_t                            vendorID;
-    uint32_t                            deviceID;
-    VkPhysicalDeviceType                deviceType;
-    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
-    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
-    VkPhysicalDeviceLimits              limits;
-    VkPhysicalDeviceSparseProperties    sparseProperties;
-} VkPhysicalDeviceProperties;
-
-typedef struct VkQueueFamilyProperties {
-    VkQueueFlags    queueFlags;
-    uint32_t        queueCount;
-    uint32_t        timestampValidBits;
-    VkExtent3D      minImageTransferGranularity;
-} VkQueueFamilyProperties;
-
-typedef struct VkMemoryType {
-    VkMemoryPropertyFlags    propertyFlags;
-    uint32_t                 heapIndex;
-} VkMemoryType;
-
-typedef struct VkMemoryHeap {
-    VkDeviceSize         size;
-    VkMemoryHeapFlags    flags;
-} VkMemoryHeap;
-
-typedef struct VkPhysicalDeviceMemoryProperties {
-    uint32_t        memoryTypeCount;
-    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
-    uint32_t        memoryHeapCount;
-    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
-} VkPhysicalDeviceMemoryProperties;
-
-typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
-typedef struct VkDeviceQueueCreateInfo {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkDeviceQueueCreateFlags    flags;
-    uint32_t                    queueFamilyIndex;
-    uint32_t                    queueCount;
-    const float*                pQueuePriorities;
-} VkDeviceQueueCreateInfo;
-
-typedef struct VkDeviceCreateInfo {
-    VkStructureType                    sType;
-    const void*                        pNext;
-    VkDeviceCreateFlags                flags;
-    uint32_t                           queueCreateInfoCount;
-    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
-    uint32_t                           enabledLayerCount;
-    const char* const*                 ppEnabledLayerNames;
-    uint32_t                           enabledExtensionCount;
-    const char* const*                 ppEnabledExtensionNames;
-    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
-} VkDeviceCreateInfo;
-
-typedef struct VkExtensionProperties {
-    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t    specVersion;
-} VkExtensionProperties;
-
-typedef struct VkLayerProperties {
-    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t    specVersion;
-    uint32_t    implementationVersion;
-    char        description[VK_MAX_DESCRIPTION_SIZE];
-} VkLayerProperties;
-
-typedef struct VkSubmitInfo {
-    VkStructureType                sType;
-    const void*                    pNext;
-    uint32_t                       waitSemaphoreCount;
-    const VkSemaphore*             pWaitSemaphores;
-    const VkPipelineStageFlags*    pWaitDstStageMask;
-    uint32_t                       commandBufferCount;
-    const VkCommandBuffer*         pCommandBuffers;
-    uint32_t                       signalSemaphoreCount;
-    const VkSemaphore*             pSignalSemaphores;
-} VkSubmitInfo;
-
-typedef struct VkMemoryAllocateInfo {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkDeviceSize       allocationSize;
-    uint32_t           memoryTypeIndex;
-} VkMemoryAllocateInfo;
-
-typedef struct VkMappedMemoryRange {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkDeviceMemory     memory;
-    VkDeviceSize       offset;
-    VkDeviceSize       size;
-} VkMappedMemoryRange;
-
-typedef struct VkMemoryRequirements {
-    VkDeviceSize    size;
-    VkDeviceSize    alignment;
-    uint32_t        memoryTypeBits;
-} VkMemoryRequirements;
-
-typedef struct VkSparseImageFormatProperties {
-    VkImageAspectFlags          aspectMask;
-    VkExtent3D                  imageGranularity;
-    VkSparseImageFormatFlags    flags;
-} VkSparseImageFormatProperties;
-
-typedef struct VkSparseImageMemoryRequirements {
-    VkSparseImageFormatProperties    formatProperties;
-    uint32_t                         imageMipTailFirstLod;
-    VkDeviceSize                     imageMipTailSize;
-    VkDeviceSize                     imageMipTailOffset;
-    VkDeviceSize                     imageMipTailStride;
-} VkSparseImageMemoryRequirements;
-
-typedef struct VkSparseMemoryBind {
-    VkDeviceSize               resourceOffset;
-    VkDeviceSize               size;
-    VkDeviceMemory             memory;
-    VkDeviceSize               memoryOffset;
-    VkSparseMemoryBindFlags    flags;
-} VkSparseMemoryBind;
-
-typedef struct VkSparseBufferMemoryBindInfo {
-    VkBuffer                     buffer;
-    uint32_t                     bindCount;
-    const VkSparseMemoryBind*    pBinds;
-} VkSparseBufferMemoryBindInfo;
-
-typedef struct VkSparseImageOpaqueMemoryBindInfo {
-    VkImage                      image;
-    uint32_t                     bindCount;
-    const VkSparseMemoryBind*    pBinds;
-} VkSparseImageOpaqueMemoryBindInfo;
-
-typedef struct VkImageSubresource {
-    VkImageAspectFlags    aspectMask;
-    uint32_t              mipLevel;
-    uint32_t              arrayLayer;
-} VkImageSubresource;
-
-typedef struct VkOffset3D {
-    int32_t    x;
-    int32_t    y;
-    int32_t    z;
-} VkOffset3D;
-
-typedef struct VkSparseImageMemoryBind {
-    VkImageSubresource         subresource;
-    VkOffset3D                 offset;
-    VkExtent3D                 extent;
-    VkDeviceMemory             memory;
-    VkDeviceSize               memoryOffset;
-    VkSparseMemoryBindFlags    flags;
-} VkSparseImageMemoryBind;
-
-typedef struct VkSparseImageMemoryBindInfo {
-    VkImage                           image;
-    uint32_t                          bindCount;
-    const VkSparseImageMemoryBind*    pBinds;
-} VkSparseImageMemoryBindInfo;
-
-typedef struct VkBindSparseInfo {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    uint32_t                                    waitSemaphoreCount;
-    const VkSemaphore*                          pWaitSemaphores;
-    uint32_t                                    bufferBindCount;
-    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
-    uint32_t                                    imageOpaqueBindCount;
-    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
-    uint32_t                                    imageBindCount;
-    const VkSparseImageMemoryBindInfo*          pImageBinds;
-    uint32_t                                    signalSemaphoreCount;
-    const VkSemaphore*                          pSignalSemaphores;
-} VkBindSparseInfo;
-
-typedef struct VkFenceCreateInfo {
-    VkStructureType       sType;
-    const void*           pNext;
-    VkFenceCreateFlags    flags;
-} VkFenceCreateInfo;
-
-typedef struct VkSemaphoreCreateInfo {
-    VkStructureType           sType;
-    const void*               pNext;
-    VkSemaphoreCreateFlags    flags;
-} VkSemaphoreCreateInfo;
-
-typedef struct VkEventCreateInfo {
-    VkStructureType       sType;
-    const void*           pNext;
-    VkEventCreateFlags    flags;
-} VkEventCreateInfo;
-
-typedef struct VkQueryPoolCreateInfo {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkQueryPoolCreateFlags           flags;
-    VkQueryType                      queryType;
-    uint32_t                         queryCount;
-    VkQueryPipelineStatisticFlags    pipelineStatistics;
-} VkQueryPoolCreateInfo;
-
-typedef struct VkBufferCreateInfo {
-    VkStructureType        sType;
-    const void*            pNext;
-    VkBufferCreateFlags    flags;
-    VkDeviceSize           size;
-    VkBufferUsageFlags     usage;
-    VkSharingMode          sharingMode;
-    uint32_t               queueFamilyIndexCount;
-    const uint32_t*        pQueueFamilyIndices;
-} VkBufferCreateInfo;
-
-typedef struct VkBufferViewCreateInfo {
-    VkStructureType            sType;
-    const void*                pNext;
-    VkBufferViewCreateFlags    flags;
-    VkBuffer                   buffer;
-    VkFormat                   format;
-    VkDeviceSize               offset;
-    VkDeviceSize               range;
-} VkBufferViewCreateInfo;
-
-typedef struct VkImageCreateInfo {
-    VkStructureType          sType;
-    const void*              pNext;
-    VkImageCreateFlags       flags;
-    VkImageType              imageType;
-    VkFormat                 format;
-    VkExtent3D               extent;
-    uint32_t                 mipLevels;
-    uint32_t                 arrayLayers;
-    VkSampleCountFlagBits    samples;
-    VkImageTiling            tiling;
-    VkImageUsageFlags        usage;
-    VkSharingMode            sharingMode;
-    uint32_t                 queueFamilyIndexCount;
-    const uint32_t*          pQueueFamilyIndices;
-    VkImageLayout            initialLayout;
-} VkImageCreateInfo;
-
-typedef struct VkSubresourceLayout {
-    VkDeviceSize    offset;
-    VkDeviceSize    size;
-    VkDeviceSize    rowPitch;
-    VkDeviceSize    arrayPitch;
-    VkDeviceSize    depthPitch;
-} VkSubresourceLayout;
-
-typedef struct VkComponentMapping {
-    VkComponentSwizzle    r;
-    VkComponentSwizzle    g;
-    VkComponentSwizzle    b;
-    VkComponentSwizzle    a;
-} VkComponentMapping;
-
-typedef struct VkImageSubresourceRange {
-    VkImageAspectFlags    aspectMask;
-    uint32_t              baseMipLevel;
-    uint32_t              levelCount;
-    uint32_t              baseArrayLayer;
-    uint32_t              layerCount;
-} VkImageSubresourceRange;
-
-typedef struct VkImageViewCreateInfo {
-    VkStructureType            sType;
-    const void*                pNext;
-    VkImageViewCreateFlags     flags;
-    VkImage                    image;
-    VkImageViewType            viewType;
-    VkFormat                   format;
-    VkComponentMapping         components;
-    VkImageSubresourceRange    subresourceRange;
-} VkImageViewCreateInfo;
-
-typedef struct VkShaderModuleCreateInfo {
-    VkStructureType              sType;
-    const void*                  pNext;
-    VkShaderModuleCreateFlags    flags;
-    size_t                       codeSize;
-    const uint32_t*              pCode;
-} VkShaderModuleCreateInfo;
-
-typedef struct VkPipelineCacheCreateInfo {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkPipelineCacheCreateFlags    flags;
-    size_t                        initialDataSize;
-    const void*                   pInitialData;
-} VkPipelineCacheCreateInfo;
-
-typedef struct VkSpecializationMapEntry {
-    uint32_t    constantID;
-    uint32_t    offset;
-    size_t      size;
-} VkSpecializationMapEntry;
-
-typedef struct VkSpecializationInfo {
-    uint32_t                           mapEntryCount;
-    const VkSpecializationMapEntry*    pMapEntries;
-    size_t                             dataSize;
-    const void*                        pData;
-} VkSpecializationInfo;
-
-typedef struct VkPipelineShaderStageCreateInfo {
-    VkStructureType                     sType;
-    const void*                         pNext;
-    VkPipelineShaderStageCreateFlags    flags;
-    VkShaderStageFlagBits               stage;
-    VkShaderModule                      module;
-    const char*                         pName;
-    const VkSpecializationInfo*         pSpecializationInfo;
-} VkPipelineShaderStageCreateInfo;
-
-typedef struct VkVertexInputBindingDescription {
-    uint32_t             binding;
-    uint32_t             stride;
-    VkVertexInputRate    inputRate;
-} VkVertexInputBindingDescription;
-
-typedef struct VkVertexInputAttributeDescription {
-    uint32_t    location;
-    uint32_t    binding;
-    VkFormat    format;
-    uint32_t    offset;
-} VkVertexInputAttributeDescription;
-
-typedef struct VkPipelineVertexInputStateCreateInfo {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkPipelineVertexInputStateCreateFlags       flags;
-    uint32_t                                    vertexBindingDescriptionCount;
-    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
-    uint32_t                                    vertexAttributeDescriptionCount;
-    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
-} VkPipelineVertexInputStateCreateInfo;
-
-typedef struct VkPipelineInputAssemblyStateCreateInfo {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    VkPipelineInputAssemblyStateCreateFlags    flags;
-    VkPrimitiveTopology                        topology;
-    VkBool32                                   primitiveRestartEnable;
-} VkPipelineInputAssemblyStateCreateInfo;
-
-typedef struct VkPipelineTessellationStateCreateInfo {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    VkPipelineTessellationStateCreateFlags    flags;
-    uint32_t                                  patchControlPoints;
-} VkPipelineTessellationStateCreateInfo;
-
-typedef struct VkViewport {
-    float    x;
-    float    y;
-    float    width;
-    float    height;
-    float    minDepth;
-    float    maxDepth;
-} VkViewport;
-
-typedef struct VkOffset2D {
-    int32_t    x;
-    int32_t    y;
-} VkOffset2D;
-
-typedef struct VkExtent2D {
-    uint32_t    width;
-    uint32_t    height;
-} VkExtent2D;
-
-typedef struct VkRect2D {
-    VkOffset2D    offset;
-    VkExtent2D    extent;
-} VkRect2D;
-
-typedef struct VkPipelineViewportStateCreateInfo {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkPipelineViewportStateCreateFlags    flags;
-    uint32_t                              viewportCount;
-    const VkViewport*                     pViewports;
-    uint32_t                              scissorCount;
-    const VkRect2D*                       pScissors;
-} VkPipelineViewportStateCreateInfo;
-
-typedef struct VkPipelineRasterizationStateCreateInfo {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    VkPipelineRasterizationStateCreateFlags    flags;
-    VkBool32                                   depthClampEnable;
-    VkBool32                                   rasterizerDiscardEnable;
-    VkPolygonMode                              polygonMode;
-    VkCullModeFlags                            cullMode;
-    VkFrontFace                                frontFace;
-    VkBool32                                   depthBiasEnable;
-    float                                      depthBiasConstantFactor;
-    float                                      depthBiasClamp;
-    float                                      depthBiasSlopeFactor;
-    float                                      lineWidth;
-} VkPipelineRasterizationStateCreateInfo;
-
-typedef struct VkPipelineMultisampleStateCreateInfo {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkPipelineMultisampleStateCreateFlags    flags;
-    VkSampleCountFlagBits                    rasterizationSamples;
-    VkBool32                                 sampleShadingEnable;
-    float                                    minSampleShading;
-    const VkSampleMask*                      pSampleMask;
-    VkBool32                                 alphaToCoverageEnable;
-    VkBool32                                 alphaToOneEnable;
-} VkPipelineMultisampleStateCreateInfo;
-
-typedef struct VkStencilOpState {
-    VkStencilOp    failOp;
-    VkStencilOp    passOp;
-    VkStencilOp    depthFailOp;
-    VkCompareOp    compareOp;
-    uint32_t       compareMask;
-    uint32_t       writeMask;
-    uint32_t       reference;
-} VkStencilOpState;
-
-typedef struct VkPipelineDepthStencilStateCreateInfo {
-    VkStructureType                           sType;
-    const void*                               pNext;
-    VkPipelineDepthStencilStateCreateFlags    flags;
-    VkBool32                                  depthTestEnable;
-    VkBool32                                  depthWriteEnable;
-    VkCompareOp                               depthCompareOp;
-    VkBool32                                  depthBoundsTestEnable;
-    VkBool32                                  stencilTestEnable;
-    VkStencilOpState                          front;
-    VkStencilOpState                          back;
-    float                                     minDepthBounds;
-    float                                     maxDepthBounds;
-} VkPipelineDepthStencilStateCreateInfo;
-
-typedef struct VkPipelineColorBlendAttachmentState {
-    VkBool32                 blendEnable;
-    VkBlendFactor            srcColorBlendFactor;
-    VkBlendFactor            dstColorBlendFactor;
-    VkBlendOp                colorBlendOp;
-    VkBlendFactor            srcAlphaBlendFactor;
-    VkBlendFactor            dstAlphaBlendFactor;
-    VkBlendOp                alphaBlendOp;
-    VkColorComponentFlags    colorWriteMask;
-} VkPipelineColorBlendAttachmentState;
-
-typedef struct VkPipelineColorBlendStateCreateInfo {
-    VkStructureType                               sType;
-    const void*                                   pNext;
-    VkPipelineColorBlendStateCreateFlags          flags;
-    VkBool32                                      logicOpEnable;
-    VkLogicOp                                     logicOp;
-    uint32_t                                      attachmentCount;
-    const VkPipelineColorBlendAttachmentState*    pAttachments;
-    float                                         blendConstants[4];
-} VkPipelineColorBlendStateCreateInfo;
-
-typedef struct VkPipelineDynamicStateCreateInfo {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkPipelineDynamicStateCreateFlags    flags;
-    uint32_t                             dynamicStateCount;
-    const VkDynamicState*                pDynamicStates;
-} VkPipelineDynamicStateCreateInfo;
-
-typedef struct VkGraphicsPipelineCreateInfo {
-    VkStructureType                                  sType;
-    const void*                                      pNext;
-    VkPipelineCreateFlags                            flags;
-    uint32_t                                         stageCount;
-    const VkPipelineShaderStageCreateInfo*           pStages;
-    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
-    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
-    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
-    const VkPipelineViewportStateCreateInfo*         pViewportState;
-    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
-    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
-    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
-    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
-    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
-    VkPipelineLayout                                 layout;
-    VkRenderPass                                     renderPass;
-    uint32_t                                         subpass;
-    VkPipeline                                       basePipelineHandle;
-    int32_t                                          basePipelineIndex;
-} VkGraphicsPipelineCreateInfo;
-
-typedef struct VkComputePipelineCreateInfo {
-    VkStructureType                    sType;
-    const void*                        pNext;
-    VkPipelineCreateFlags              flags;
-    VkPipelineShaderStageCreateInfo    stage;
-    VkPipelineLayout                   layout;
-    VkPipeline                         basePipelineHandle;
-    int32_t                            basePipelineIndex;
-} VkComputePipelineCreateInfo;
-
-typedef struct VkPushConstantRange {
-    VkShaderStageFlags    stageFlags;
-    uint32_t              offset;
-    uint32_t              size;
-} VkPushConstantRange;
-
-typedef struct VkPipelineLayoutCreateInfo {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkPipelineLayoutCreateFlags     flags;
-    uint32_t                        setLayoutCount;
-    const VkDescriptorSetLayout*    pSetLayouts;
-    uint32_t                        pushConstantRangeCount;
-    const VkPushConstantRange*      pPushConstantRanges;
-} VkPipelineLayoutCreateInfo;
-
-typedef struct VkSamplerCreateInfo {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkSamplerCreateFlags    flags;
-    VkFilter                magFilter;
-    VkFilter                minFilter;
-    VkSamplerMipmapMode     mipmapMode;
-    VkSamplerAddressMode    addressModeU;
-    VkSamplerAddressMode    addressModeV;
-    VkSamplerAddressMode    addressModeW;
-    float                   mipLodBias;
-    VkBool32                anisotropyEnable;
-    float                   maxAnisotropy;
-    VkBool32                compareEnable;
-    VkCompareOp             compareOp;
-    float                   minLod;
-    float                   maxLod;
-    VkBorderColor           borderColor;
-    VkBool32                unnormalizedCoordinates;
-} VkSamplerCreateInfo;
-
-typedef struct VkDescriptorSetLayoutBinding {
-    uint32_t              binding;
-    VkDescriptorType      descriptorType;
-    uint32_t              descriptorCount;
-    VkShaderStageFlags    stageFlags;
-    const VkSampler*      pImmutableSamplers;
-} VkDescriptorSetLayoutBinding;
-
-typedef struct VkDescriptorSetLayoutCreateInfo {
-    VkStructureType                        sType;
-    const void*                            pNext;
-    VkDescriptorSetLayoutCreateFlags       flags;
-    uint32_t                               bindingCount;
-    const VkDescriptorSetLayoutBinding*    pBindings;
-} VkDescriptorSetLayoutCreateInfo;
-
-typedef struct VkDescriptorPoolSize {
-    VkDescriptorType    type;
-    uint32_t            descriptorCount;
-} VkDescriptorPoolSize;
-
-typedef struct VkDescriptorPoolCreateInfo {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkDescriptorPoolCreateFlags    flags;
-    uint32_t                       maxSets;
-    uint32_t                       poolSizeCount;
-    const VkDescriptorPoolSize*    pPoolSizes;
-} VkDescriptorPoolCreateInfo;
-
-typedef struct VkDescriptorSetAllocateInfo {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkDescriptorPool                descriptorPool;
-    uint32_t                        descriptorSetCount;
-    const VkDescriptorSetLayout*    pSetLayouts;
-} VkDescriptorSetAllocateInfo;
-
-typedef struct VkDescriptorImageInfo {
-    VkSampler        sampler;
-    VkImageView      imageView;
-    VkImageLayout    imageLayout;
-} VkDescriptorImageInfo;
-
-typedef struct VkDescriptorBufferInfo {
-    VkBuffer        buffer;
-    VkDeviceSize    offset;
-    VkDeviceSize    range;
-} VkDescriptorBufferInfo;
-
-typedef struct VkWriteDescriptorSet {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkDescriptorSet                  dstSet;
-    uint32_t                         dstBinding;
-    uint32_t                         dstArrayElement;
-    uint32_t                         descriptorCount;
-    VkDescriptorType                 descriptorType;
-    const VkDescriptorImageInfo*     pImageInfo;
-    const VkDescriptorBufferInfo*    pBufferInfo;
-    const VkBufferView*              pTexelBufferView;
-} VkWriteDescriptorSet;
-
-typedef struct VkCopyDescriptorSet {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkDescriptorSet    srcSet;
-    uint32_t           srcBinding;
-    uint32_t           srcArrayElement;
-    VkDescriptorSet    dstSet;
-    uint32_t           dstBinding;
-    uint32_t           dstArrayElement;
-    uint32_t           descriptorCount;
-} VkCopyDescriptorSet;
-
-typedef struct VkFramebufferCreateInfo {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkFramebufferCreateFlags    flags;
-    VkRenderPass                renderPass;
-    uint32_t                    attachmentCount;
-    const VkImageView*          pAttachments;
-    uint32_t                    width;
-    uint32_t                    height;
-    uint32_t                    layers;
-} VkFramebufferCreateInfo;
-
-typedef struct VkAttachmentDescription {
-    VkAttachmentDescriptionFlags    flags;
-    VkFormat                        format;
-    VkSampleCountFlagBits           samples;
-    VkAttachmentLoadOp              loadOp;
-    VkAttachmentStoreOp             storeOp;
-    VkAttachmentLoadOp              stencilLoadOp;
-    VkAttachmentStoreOp             stencilStoreOp;
-    VkImageLayout                   initialLayout;
-    VkImageLayout                   finalLayout;
-} VkAttachmentDescription;
-
-typedef struct VkAttachmentReference {
-    uint32_t         attachment;
-    VkImageLayout    layout;
-} VkAttachmentReference;
-
-typedef struct VkSubpassDescription {
-    VkSubpassDescriptionFlags       flags;
-    VkPipelineBindPoint             pipelineBindPoint;
-    uint32_t                        inputAttachmentCount;
-    const VkAttachmentReference*    pInputAttachments;
-    uint32_t                        colorAttachmentCount;
-    const VkAttachmentReference*    pColorAttachments;
-    const VkAttachmentReference*    pResolveAttachments;
-    const VkAttachmentReference*    pDepthStencilAttachment;
-    uint32_t                        preserveAttachmentCount;
-    const uint32_t*                 pPreserveAttachments;
-} VkSubpassDescription;
-
-typedef struct VkSubpassDependency {
-    uint32_t                srcSubpass;
-    uint32_t                dstSubpass;
-    VkPipelineStageFlags    srcStageMask;
-    VkPipelineStageFlags    dstStageMask;
-    VkAccessFlags           srcAccessMask;
-    VkAccessFlags           dstAccessMask;
-    VkDependencyFlags       dependencyFlags;
-} VkSubpassDependency;
-
-typedef struct VkRenderPassCreateInfo {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkRenderPassCreateFlags           flags;
-    uint32_t                          attachmentCount;
-    const VkAttachmentDescription*    pAttachments;
-    uint32_t                          subpassCount;
-    const VkSubpassDescription*       pSubpasses;
-    uint32_t                          dependencyCount;
-    const VkSubpassDependency*        pDependencies;
-} VkRenderPassCreateInfo;
-
-typedef struct VkCommandPoolCreateInfo {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkCommandPoolCreateFlags    flags;
-    uint32_t                    queueFamilyIndex;
-} VkCommandPoolCreateInfo;
-
-typedef struct VkCommandBufferAllocateInfo {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkCommandPool           commandPool;
-    VkCommandBufferLevel    level;
-    uint32_t                commandBufferCount;
-} VkCommandBufferAllocateInfo;
-
-typedef struct VkCommandBufferInheritanceInfo {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkRenderPass                     renderPass;
-    uint32_t                         subpass;
-    VkFramebuffer                    framebuffer;
-    VkBool32                         occlusionQueryEnable;
-    VkQueryControlFlags              queryFlags;
-    VkQueryPipelineStatisticFlags    pipelineStatistics;
-} VkCommandBufferInheritanceInfo;
-
-typedef struct VkCommandBufferBeginInfo {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkCommandBufferUsageFlags                flags;
-    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
-} VkCommandBufferBeginInfo;
-
-typedef struct VkBufferCopy {
-    VkDeviceSize    srcOffset;
-    VkDeviceSize    dstOffset;
-    VkDeviceSize    size;
-} VkBufferCopy;
-
-typedef struct VkImageSubresourceLayers {
-    VkImageAspectFlags    aspectMask;
-    uint32_t              mipLevel;
-    uint32_t              baseArrayLayer;
-    uint32_t              layerCount;
-} VkImageSubresourceLayers;
-
-typedef struct VkImageCopy {
-    VkImageSubresourceLayers    srcSubresource;
-    VkOffset3D                  srcOffset;
-    VkImageSubresourceLayers    dstSubresource;
-    VkOffset3D                  dstOffset;
-    VkExtent3D                  extent;
-} VkImageCopy;
-
-typedef struct VkImageBlit {
-    VkImageSubresourceLayers    srcSubresource;
-    VkOffset3D                  srcOffsets[2];
-    VkImageSubresourceLayers    dstSubresource;
-    VkOffset3D                  dstOffsets[2];
-} VkImageBlit;
-
-typedef struct VkBufferImageCopy {
-    VkDeviceSize                bufferOffset;
-    uint32_t                    bufferRowLength;
-    uint32_t                    bufferImageHeight;
-    VkImageSubresourceLayers    imageSubresource;
-    VkOffset3D                  imageOffset;
-    VkExtent3D                  imageExtent;
-} VkBufferImageCopy;
-
-typedef union VkClearColorValue {
-    float       float32[4];
-    int32_t     int32[4];
-    uint32_t    uint32[4];
-} VkClearColorValue;
-
-typedef struct VkClearDepthStencilValue {
-    float       depth;
-    uint32_t    stencil;
-} VkClearDepthStencilValue;
-
-typedef union VkClearValue {
-    VkClearColorValue           color;
-    VkClearDepthStencilValue    depthStencil;
-} VkClearValue;
-
-typedef struct VkClearAttachment {
-    VkImageAspectFlags    aspectMask;
-    uint32_t              colorAttachment;
-    VkClearValue          clearValue;
-} VkClearAttachment;
-
-typedef struct VkClearRect {
-    VkRect2D    rect;
-    uint32_t    baseArrayLayer;
-    uint32_t    layerCount;
-} VkClearRect;
-
-typedef struct VkImageResolve {
-    VkImageSubresourceLayers    srcSubresource;
-    VkOffset3D                  srcOffset;
-    VkImageSubresourceLayers    dstSubresource;
-    VkOffset3D                  dstOffset;
-    VkExtent3D                  extent;
-} VkImageResolve;
-
-typedef struct VkMemoryBarrier {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkAccessFlags      srcAccessMask;
-    VkAccessFlags      dstAccessMask;
-} VkMemoryBarrier;
-
-typedef struct VkBufferMemoryBarrier {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkAccessFlags      srcAccessMask;
-    VkAccessFlags      dstAccessMask;
-    uint32_t           srcQueueFamilyIndex;
-    uint32_t           dstQueueFamilyIndex;
-    VkBuffer           buffer;
-    VkDeviceSize       offset;
-    VkDeviceSize       size;
-} VkBufferMemoryBarrier;
-
-typedef struct VkImageMemoryBarrier {
-    VkStructureType            sType;
-    const void*                pNext;
-    VkAccessFlags              srcAccessMask;
-    VkAccessFlags              dstAccessMask;
-    VkImageLayout              oldLayout;
-    VkImageLayout              newLayout;
-    uint32_t                   srcQueueFamilyIndex;
-    uint32_t                   dstQueueFamilyIndex;
-    VkImage                    image;
-    VkImageSubresourceRange    subresourceRange;
-} VkImageMemoryBarrier;
-
-typedef struct VkRenderPassBeginInfo {
-    VkStructureType        sType;
-    const void*            pNext;
-    VkRenderPass           renderPass;
-    VkFramebuffer          framebuffer;
-    VkRect2D               renderArea;
-    uint32_t               clearValueCount;
-    const VkClearValue*    pClearValues;
-} VkRenderPassBeginInfo;
-
-typedef struct VkDispatchIndirectCommand {
-    uint32_t    x;
-    uint32_t    y;
-    uint32_t    z;
-} VkDispatchIndirectCommand;
-
-typedef struct VkDrawIndexedIndirectCommand {
-    uint32_t    indexCount;
-    uint32_t    instanceCount;
-    uint32_t    firstIndex;
-    int32_t     vertexOffset;
-    uint32_t    firstInstance;
-} VkDrawIndexedIndirectCommand;
-
-typedef struct VkDrawIndirectCommand {
-    uint32_t    vertexCount;
-    uint32_t    instanceCount;
-    uint32_t    firstVertex;
-    uint32_t    firstInstance;
-} VkDrawIndirectCommand;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
-typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
-typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
-typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
-typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
-typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
-typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
-typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
-typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
-typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
-typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
-typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
-typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
-typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
-typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
-typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
-typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
-typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
-typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
-typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
-typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
-typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
-typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
-typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
-typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
-typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
-typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
-typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
-typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
-typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
-typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
-typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
-typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
-typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
-typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
-typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
-typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
-typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
-typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
-typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
-typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
-typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
-typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
-typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
-typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
-typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
-typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
-typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
-typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
-typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
-typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
-typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
-typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
-typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
-typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
-typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
-typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
-typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
-typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
-typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
-typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI_PTR *PFN_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);
-typedef void (VKAPI_PTR *PFN_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);
-typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
-typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
-typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
-typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
-typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
-typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
-typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
-typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
-typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
-    const VkInstanceCreateInfo*                 pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkInstance*                                 pInstance);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
-    VkInstance                                  instance,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
-    VkInstance                                  instance,
-    uint32_t*                                   pPhysicalDeviceCount,
-    VkPhysicalDevice*                           pPhysicalDevices);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceFeatures*                   pFeatures);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkFormatProperties*                         pFormatProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkImageType                                 type,
-    VkImageTiling                               tiling,
-    VkImageUsageFlags                           usage,
-    VkImageCreateFlags                          flags,
-    VkImageFormatProperties*                    pImageFormatProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceProperties*                 pProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties*                    pQueueFamilyProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
-
-VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
-    VkInstance                                  instance,
-    const char*                                 pName);
-
-VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
-    VkDevice                                    device,
-    const char*                                 pName);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
-    VkPhysicalDevice                            physicalDevice,
-    const VkDeviceCreateInfo*                   pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDevice*                                   pDevice);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
-    VkDevice                                    device,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
-    const char*                                 pLayerName,
-    uint32_t*                                   pPropertyCount,
-    VkExtensionProperties*                      pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
-    VkPhysicalDevice                            physicalDevice,
-    const char*                                 pLayerName,
-    uint32_t*                                   pPropertyCount,
-    VkExtensionProperties*                      pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
-    uint32_t*                                   pPropertyCount,
-    VkLayerProperties*                          pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pPropertyCount,
-    VkLayerProperties*                          pProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
-    VkDevice                                    device,
-    uint32_t                                    queueFamilyIndex,
-    uint32_t                                    queueIndex,
-    VkQueue*                                    pQueue);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
-    VkQueue                                     queue,
-    uint32_t                                    submitCount,
-    const VkSubmitInfo*                         pSubmits,
-    VkFence                                     fence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
-    VkQueue                                     queue);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
-    VkDevice                                    device);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
-    VkDevice                                    device,
-    const VkMemoryAllocateInfo*                 pAllocateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDeviceMemory*                             pMemory);
-
-VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    VkDeviceSize                                offset,
-    VkDeviceSize                                size,
-    VkMemoryMapFlags                            flags,
-    void**                                      ppData);
-
-VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
-    VkDevice                                    device,
-    uint32_t                                    memoryRangeCount,
-    const VkMappedMemoryRange*                  pMemoryRanges);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
-    VkDevice                                    device,
-    uint32_t                                    memoryRangeCount,
-    const VkMappedMemoryRange*                  pMemoryRanges);
-
-VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    VkDeviceSize*                               pCommittedMemoryInBytes);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
-    VkDevice                                    device,
-    VkBuffer                                    buffer,
-    VkDeviceMemory                              memory,
-    VkDeviceSize                                memoryOffset);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
-    VkDevice                                    device,
-    VkImage                                     image,
-    VkDeviceMemory                              memory,
-    VkDeviceSize                                memoryOffset);
-
-VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
-    VkDevice                                    device,
-    VkBuffer                                    buffer,
-    VkMemoryRequirements*                       pMemoryRequirements);
-
-VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
-    VkDevice                                    device,
-    VkImage                                     image,
-    VkMemoryRequirements*                       pMemoryRequirements);
-
-VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
-    VkDevice                                    device,
-    VkImage                                     image,
-    uint32_t*                                   pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkImageType                                 type,
-    VkSampleCountFlagBits                       samples,
-    VkImageUsageFlags                           usage,
-    VkImageTiling                               tiling,
-    uint32_t*                                   pPropertyCount,
-    VkSparseImageFormatProperties*              pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
-    VkQueue                                     queue,
-    uint32_t                                    bindInfoCount,
-    const VkBindSparseInfo*                     pBindInfo,
-    VkFence                                     fence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
-    VkDevice                                    device,
-    const VkFenceCreateInfo*                    pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFence*                                    pFence);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
-    VkDevice                                    device,
-    VkFence                                     fence,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
-    VkDevice                                    device,
-    uint32_t                                    fenceCount,
-    const VkFence*                              pFences);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
-    VkDevice                                    device,
-    VkFence                                     fence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
-    VkDevice                                    device,
-    uint32_t                                    fenceCount,
-    const VkFence*                              pFences,
-    VkBool32                                    waitAll,
-    uint64_t                                    timeout);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
-    VkDevice                                    device,
-    const VkSemaphoreCreateInfo*                pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSemaphore*                                pSemaphore);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
-    VkDevice                                    device,
-    VkSemaphore                                 semaphore,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
-    VkDevice                                    device,
-    const VkEventCreateInfo*                    pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkEvent*                                    pEvent);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
-    VkDevice                                    device,
-    VkEvent                                     event,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
-    VkDevice                                    device,
-    VkEvent                                     event);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
-    VkDevice                                    device,
-    VkEvent                                     event);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
-    VkDevice                                    device,
-    VkEvent                                     event);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
-    VkDevice                                    device,
-    const VkQueryPoolCreateInfo*                pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkQueryPool*                                pQueryPool);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
-    VkDevice                                    device,
-    VkQueryPool                                 queryPool,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
-    VkDevice                                    device,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    firstQuery,
-    uint32_t                                    queryCount,
-    size_t                                      dataSize,
-    void*                                       pData,
-    VkDeviceSize                                stride,
-    VkQueryResultFlags                          flags);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
-    VkDevice                                    device,
-    const VkBufferCreateInfo*                   pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkBuffer*                                   pBuffer);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
-    VkDevice                                    device,
-    VkBuffer                                    buffer,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
-    VkDevice                                    device,
-    const VkBufferViewCreateInfo*               pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkBufferView*                               pView);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
-    VkDevice                                    device,
-    VkBufferView                                bufferView,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
-    VkDevice                                    device,
-    const VkImageCreateInfo*                    pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkImage*                                    pImage);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
-    VkDevice                                    device,
-    VkImage                                     image,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
-    VkDevice                                    device,
-    VkImage                                     image,
-    const VkImageSubresource*                   pSubresource,
-    VkSubresourceLayout*                        pLayout);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
-    VkDevice                                    device,
-    const VkImageViewCreateInfo*                pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkImageView*                                pView);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
-    VkDevice                                    device,
-    VkImageView                                 imageView,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
-    VkDevice                                    device,
-    const VkShaderModuleCreateInfo*             pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkShaderModule*                             pShaderModule);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
-    VkDevice                                    device,
-    VkShaderModule                              shaderModule,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
-    VkDevice                                    device,
-    const VkPipelineCacheCreateInfo*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipelineCache*                            pPipelineCache);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
-    VkDevice                                    device,
-    VkPipelineCache                             pipelineCache,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
-    VkDevice                                    device,
-    VkPipelineCache                             pipelineCache,
-    size_t*                                     pDataSize,
-    void*                                       pData);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
-    VkDevice                                    device,
-    VkPipelineCache                             dstCache,
-    uint32_t                                    srcCacheCount,
-    const VkPipelineCache*                      pSrcCaches);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
-    VkDevice                                    device,
-    VkPipelineCache                             pipelineCache,
-    uint32_t                                    createInfoCount,
-    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipeline*                                 pPipelines);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
-    VkDevice                                    device,
-    VkPipelineCache                             pipelineCache,
-    uint32_t                                    createInfoCount,
-    const VkComputePipelineCreateInfo*          pCreateInfos,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipeline*                                 pPipelines);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
-    VkDevice                                    device,
-    VkPipeline                                  pipeline,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
-    VkDevice                                    device,
-    const VkPipelineLayoutCreateInfo*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkPipelineLayout*                           pPipelineLayout);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
-    VkDevice                                    device,
-    VkPipelineLayout                            pipelineLayout,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
-    VkDevice                                    device,
-    const VkSamplerCreateInfo*                  pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSampler*                                  pSampler);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
-    VkDevice                                    device,
-    VkSampler                                   sampler,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
-    VkDevice                                    device,
-    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDescriptorSetLayout*                      pSetLayout);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
-    VkDevice                                    device,
-    VkDescriptorSetLayout                       descriptorSetLayout,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
-    VkDevice                                    device,
-    const VkDescriptorPoolCreateInfo*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDescriptorPool*                           pDescriptorPool);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
-    VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
-    VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool,
-    VkDescriptorPoolResetFlags                  flags);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
-    VkDevice                                    device,
-    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
-    VkDescriptorSet*                            pDescriptorSets);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
-    VkDevice                                    device,
-    VkDescriptorPool                            descriptorPool,
-    uint32_t                                    descriptorSetCount,
-    const VkDescriptorSet*                      pDescriptorSets);
-
-VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
-    VkDevice                                    device,
-    uint32_t                                    descriptorWriteCount,
-    const VkWriteDescriptorSet*                 pDescriptorWrites,
-    uint32_t                                    descriptorCopyCount,
-    const VkCopyDescriptorSet*                  pDescriptorCopies);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
-    VkDevice                                    device,
-    const VkFramebufferCreateInfo*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFramebuffer*                              pFramebuffer);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
-    VkDevice                                    device,
-    VkFramebuffer                               framebuffer,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
-    VkDevice                                    device,
-    const VkRenderPassCreateInfo*               pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkRenderPass*                               pRenderPass);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
-    VkDevice                                    device,
-    VkRenderPass                                renderPass,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
-    VkDevice                                    device,
-    VkRenderPass                                renderPass,
-    VkExtent2D*                                 pGranularity);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
-    VkDevice                                    device,
-    const VkCommandPoolCreateInfo*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkCommandPool*                              pCommandPool);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
-    VkDevice                                    device,
-    VkCommandPool                               commandPool,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
-    VkDevice                                    device,
-    VkCommandPool                               commandPool,
-    VkCommandPoolResetFlags                     flags);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
-    VkDevice                                    device,
-    const VkCommandBufferAllocateInfo*          pAllocateInfo,
-    VkCommandBuffer*                            pCommandBuffers);
-
-VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
-    VkDevice                                    device,
-    VkCommandPool                               commandPool,
-    uint32_t                                    commandBufferCount,
-    const VkCommandBuffer*                      pCommandBuffers);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
-    VkCommandBuffer                             commandBuffer,
-    const VkCommandBufferBeginInfo*             pBeginInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
-    VkCommandBuffer                             commandBuffer);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkCommandBufferResetFlags                   flags);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineBindPoint                         pipelineBindPoint,
-    VkPipeline                                  pipeline);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstViewport,
-    uint32_t                                    viewportCount,
-    const VkViewport*                           pViewports);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstScissor,
-    uint32_t                                    scissorCount,
-    const VkRect2D*                             pScissors);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
-    VkCommandBuffer                             commandBuffer,
-    float                                       lineWidth);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
-    VkCommandBuffer                             commandBuffer,
-    float                                       depthBiasConstantFactor,
-    float                                       depthBiasClamp,
-    float                                       depthBiasSlopeFactor);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
-    VkCommandBuffer                             commandBuffer,
-    const float                                 blendConstants[4]);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
-    VkCommandBuffer                             commandBuffer,
-    float                                       minDepthBounds,
-    float                                       maxDepthBounds);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
-    VkCommandBuffer                             commandBuffer,
-    VkStencilFaceFlags                          faceMask,
-    uint32_t                                    compareMask);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
-    VkCommandBuffer                             commandBuffer,
-    VkStencilFaceFlags                          faceMask,
-    uint32_t                                    writeMask);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
-    VkCommandBuffer                             commandBuffer,
-    VkStencilFaceFlags                          faceMask,
-    uint32_t                                    reference);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineBindPoint                         pipelineBindPoint,
-    VkPipelineLayout                            layout,
-    uint32_t                                    firstSet,
-    uint32_t                                    descriptorSetCount,
-    const VkDescriptorSet*                      pDescriptorSets,
-    uint32_t                                    dynamicOffsetCount,
-    const uint32_t*                             pDynamicOffsets);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    VkIndexType                                 indexType);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstBinding,
-    uint32_t                                    bindingCount,
-    const VkBuffer*                             pBuffers,
-    const VkDeviceSize*                         pOffsets);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    vertexCount,
-    uint32_t                                    instanceCount,
-    uint32_t                                    firstVertex,
-    uint32_t                                    firstInstance);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    indexCount,
-    uint32_t                                    instanceCount,
-    uint32_t                                    firstIndex,
-    int32_t                                     vertexOffset,
-    uint32_t                                    firstInstance);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    uint32_t                                    drawCount,
-    uint32_t                                    stride);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    uint32_t                                    drawCount,
-    uint32_t                                    stride);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    groupCountX,
-    uint32_t                                    groupCountY,
-    uint32_t                                    groupCountZ);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    srcBuffer,
-    VkBuffer                                    dstBuffer,
-    uint32_t                                    regionCount,
-    const VkBufferCopy*                         pRegions);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     srcImage,
-    VkImageLayout                               srcImageLayout,
-    VkImage                                     dstImage,
-    VkImageLayout                               dstImageLayout,
-    uint32_t                                    regionCount,
-    const VkImageCopy*                          pRegions);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     srcImage,
-    VkImageLayout                               srcImageLayout,
-    VkImage                                     dstImage,
-    VkImageLayout                               dstImageLayout,
-    uint32_t                                    regionCount,
-    const VkImageBlit*                          pRegions,
-    VkFilter                                    filter);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    srcBuffer,
-    VkImage                                     dstImage,
-    VkImageLayout                               dstImageLayout,
-    uint32_t                                    regionCount,
-    const VkBufferImageCopy*                    pRegions);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     srcImage,
-    VkImageLayout                               srcImageLayout,
-    VkBuffer                                    dstBuffer,
-    uint32_t                                    regionCount,
-    const VkBufferImageCopy*                    pRegions);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    dstBuffer,
-    VkDeviceSize                                dstOffset,
-    VkDeviceSize                                dataSize,
-    const void*                                 pData);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    dstBuffer,
-    VkDeviceSize                                dstOffset,
-    VkDeviceSize                                size,
-    uint32_t                                    data);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     image,
-    VkImageLayout                               imageLayout,
-    const VkClearColorValue*                    pColor,
-    uint32_t                                    rangeCount,
-    const VkImageSubresourceRange*              pRanges);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     image,
-    VkImageLayout                               imageLayout,
-    const VkClearDepthStencilValue*             pDepthStencil,
-    uint32_t                                    rangeCount,
-    const VkImageSubresourceRange*              pRanges);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    attachmentCount,
-    const VkClearAttachment*                    pAttachments,
-    uint32_t                                    rectCount,
-    const VkClearRect*                          pRects);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
-    VkCommandBuffer                             commandBuffer,
-    VkImage                                     srcImage,
-    VkImageLayout                               srcImageLayout,
-    VkImage                                     dstImage,
-    VkImageLayout                               dstImageLayout,
-    uint32_t                                    regionCount,
-    const VkImageResolve*                       pRegions);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
-    VkCommandBuffer                             commandBuffer,
-    VkEvent                                     event,
-    VkPipelineStageFlags                        stageMask);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
-    VkCommandBuffer                             commandBuffer,
-    VkEvent                                     event,
-    VkPipelineStageFlags                        stageMask);
-
-VKAPI_ATTR void VKAPI_CALL 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);
-
-VKAPI_ATTR void VKAPI_CALL 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);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
-    VkCommandBuffer                             commandBuffer,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    query,
-    VkQueryControlFlags                         flags);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
-    VkCommandBuffer                             commandBuffer,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    query);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
-    VkCommandBuffer                             commandBuffer,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    firstQuery,
-    uint32_t                                    queryCount);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineStageFlagBits                     pipelineStage,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    query);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
-    VkCommandBuffer                             commandBuffer,
-    VkQueryPool                                 queryPool,
-    uint32_t                                    firstQuery,
-    uint32_t                                    queryCount,
-    VkBuffer                                    dstBuffer,
-    VkDeviceSize                                dstOffset,
-    VkDeviceSize                                stride,
-    VkQueryResultFlags                          flags);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineLayout                            layout,
-    VkShaderStageFlags                          stageFlags,
-    uint32_t                                    offset,
-    uint32_t                                    size,
-    const void*                                 pValues);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
-    VkCommandBuffer                             commandBuffer,
-    const VkRenderPassBeginInfo*                pRenderPassBegin,
-    VkSubpassContents                           contents);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
-    VkCommandBuffer                             commandBuffer,
-    VkSubpassContents                           contents);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
-    VkCommandBuffer                             commandBuffer);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    commandBufferCount,
-    const VkCommandBuffer*                      pCommandBuffers);
-#endif
-
-#define VK_KHR_surface 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
-
-#define VK_KHR_SURFACE_SPEC_VERSION       25
-#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
-#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
-
-
-typedef enum VkColorSpaceKHR {
-    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
-    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
-    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
-    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
-    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
-    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
-    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
-    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
-    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
-    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
-    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
-    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
-    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
-    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
-    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
-    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
-    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkColorSpaceKHR;
-
-typedef enum VkPresentModeKHR {
-    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
-    VK_PRESENT_MODE_MAILBOX_KHR = 1,
-    VK_PRESENT_MODE_FIFO_KHR = 2,
-    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
-    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
-    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
-    VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
-    VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-    VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
-    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkPresentModeKHR;
-
-
-typedef enum VkSurfaceTransformFlagBitsKHR {
-    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
-    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
-    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
-    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
-    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
-    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
-    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
-    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
-    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
-    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkSurfaceTransformFlagBitsKHR;
-typedef VkFlags VkSurfaceTransformFlagsKHR;
-
-typedef enum VkCompositeAlphaFlagBitsKHR {
-    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
-    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
-    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
-    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
-    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkCompositeAlphaFlagBitsKHR;
-typedef VkFlags VkCompositeAlphaFlagsKHR;
-
-typedef struct VkSurfaceCapabilitiesKHR {
-    uint32_t                         minImageCount;
-    uint32_t                         maxImageCount;
-    VkExtent2D                       currentExtent;
-    VkExtent2D                       minImageExtent;
-    VkExtent2D                       maxImageExtent;
-    uint32_t                         maxImageArrayLayers;
-    VkSurfaceTransformFlagsKHR       supportedTransforms;
-    VkSurfaceTransformFlagBitsKHR    currentTransform;
-    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
-    VkImageUsageFlags                supportedUsageFlags;
-} VkSurfaceCapabilitiesKHR;
-
-typedef struct VkSurfaceFormatKHR {
-    VkFormat           format;
-    VkColorSpaceKHR    colorSpace;
-} VkSurfaceFormatKHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
-    VkInstance                                  instance,
-    VkSurfaceKHR                                surface,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    VkSurfaceKHR                                surface,
-    VkBool32*                                   pSupported);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    uint32_t*                                   pSurfaceFormatCount,
-    VkSurfaceFormatKHR*                         pSurfaceFormats);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    uint32_t*                                   pPresentModeCount,
-    VkPresentModeKHR*                           pPresentModes);
-#endif
-
-#define VK_KHR_swapchain 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
-
-#define VK_KHR_SWAPCHAIN_SPEC_VERSION     68
-#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
-
-
-typedef enum VkSwapchainCreateFlagBitsKHR {
-    VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX = 0x00000001,
-    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkSwapchainCreateFlagBitsKHR;
-typedef VkFlags VkSwapchainCreateFlagsKHR;
-
-typedef struct VkSwapchainCreateInfoKHR {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkSwapchainCreateFlagsKHR        flags;
-    VkSurfaceKHR                     surface;
-    uint32_t                         minImageCount;
-    VkFormat                         imageFormat;
-    VkColorSpaceKHR                  imageColorSpace;
-    VkExtent2D                       imageExtent;
-    uint32_t                         imageArrayLayers;
-    VkImageUsageFlags                imageUsage;
-    VkSharingMode                    imageSharingMode;
-    uint32_t                         queueFamilyIndexCount;
-    const uint32_t*                  pQueueFamilyIndices;
-    VkSurfaceTransformFlagBitsKHR    preTransform;
-    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
-    VkPresentModeKHR                 presentMode;
-    VkBool32                         clipped;
-    VkSwapchainKHR                   oldSwapchain;
-} VkSwapchainCreateInfoKHR;
-
-typedef struct VkPresentInfoKHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 waitSemaphoreCount;
-    const VkSemaphore*       pWaitSemaphores;
-    uint32_t                 swapchainCount;
-    const VkSwapchainKHR*    pSwapchains;
-    const uint32_t*          pImageIndices;
-    VkResult*                pResults;
-} VkPresentInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
-typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
-typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
-typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
-    VkDevice                                    device,
-    const VkSwapchainCreateInfoKHR*             pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSwapchainKHR*                             pSwapchain);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    uint32_t*                                   pSwapchainImageCount,
-    VkImage*                                    pSwapchainImages);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    uint64_t                                    timeout,
-    VkSemaphore                                 semaphore,
-    VkFence                                     fence,
-    uint32_t*                                   pImageIndex);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
-    VkQueue                                     queue,
-    const VkPresentInfoKHR*                     pPresentInfo);
-#endif
-
-#define VK_KHR_display 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
-
-#define VK_KHR_DISPLAY_SPEC_VERSION       21
-#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
-
-
-typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
-    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
-    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
-    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
-    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
-    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkDisplayPlaneAlphaFlagBitsKHR;
-typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
-typedef VkFlags VkDisplayModeCreateFlagsKHR;
-typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
-
-typedef struct VkDisplayPropertiesKHR {
-    VkDisplayKHR                  display;
-    const char*                   displayName;
-    VkExtent2D                    physicalDimensions;
-    VkExtent2D                    physicalResolution;
-    VkSurfaceTransformFlagsKHR    supportedTransforms;
-    VkBool32                      planeReorderPossible;
-    VkBool32                      persistentContent;
-} VkDisplayPropertiesKHR;
-
-typedef struct VkDisplayModeParametersKHR {
-    VkExtent2D    visibleRegion;
-    uint32_t      refreshRate;
-} VkDisplayModeParametersKHR;
-
-typedef struct VkDisplayModePropertiesKHR {
-    VkDisplayModeKHR              displayMode;
-    VkDisplayModeParametersKHR    parameters;
-} VkDisplayModePropertiesKHR;
-
-typedef struct VkDisplayModeCreateInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkDisplayModeCreateFlagsKHR    flags;
-    VkDisplayModeParametersKHR     parameters;
-} VkDisplayModeCreateInfoKHR;
-
-typedef struct VkDisplayPlaneCapabilitiesKHR {
-    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
-    VkOffset2D                     minSrcPosition;
-    VkOffset2D                     maxSrcPosition;
-    VkExtent2D                     minSrcExtent;
-    VkExtent2D                     maxSrcExtent;
-    VkOffset2D                     minDstPosition;
-    VkOffset2D                     maxDstPosition;
-    VkExtent2D                     minDstExtent;
-    VkExtent2D                     maxDstExtent;
-} VkDisplayPlaneCapabilitiesKHR;
-
-typedef struct VkDisplayPlanePropertiesKHR {
-    VkDisplayKHR    currentDisplay;
-    uint32_t        currentStackIndex;
-} VkDisplayPlanePropertiesKHR;
-
-typedef struct VkDisplaySurfaceCreateInfoKHR {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkDisplaySurfaceCreateFlagsKHR    flags;
-    VkDisplayModeKHR                  displayMode;
-    uint32_t                          planeIndex;
-    uint32_t                          planeStackIndex;
-    VkSurfaceTransformFlagBitsKHR     transform;
-    float                             globalAlpha;
-    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
-    VkExtent2D                        imageExtent;
-} VkDisplaySurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pPropertyCount,
-    VkDisplayPropertiesKHR*                     pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pPropertyCount,
-    VkDisplayPlanePropertiesKHR*                pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    planeIndex,
-    uint32_t*                                   pDisplayCount,
-    VkDisplayKHR*                               pDisplays);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkDisplayKHR                                display,
-    uint32_t*                                   pPropertyCount,
-    VkDisplayModePropertiesKHR*                 pProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkDisplayKHR                                display,
-    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDisplayModeKHR*                           pMode);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkDisplayModeKHR                            mode,
-    uint32_t                                    planeIndex,
-    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
-    VkInstance                                  instance,
-    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-#endif
-
-#define VK_KHR_display_swapchain 1
-#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
-#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
-
-typedef struct VkDisplayPresentInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkRect2D           srcRect;
-    VkRect2D           dstRect;
-    VkBool32           persistent;
-} VkDisplayPresentInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
-    VkDevice                                    device,
-    uint32_t                                    swapchainCount,
-    const VkSwapchainCreateInfoKHR*             pCreateInfos,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSwapchainKHR*                             pSwapchains);
-#endif
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-#define VK_KHR_xlib_surface 1
-#include <X11/Xlib.h>
-
-#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
-#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
-
-typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
-
-typedef struct VkXlibSurfaceCreateInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkXlibSurfaceCreateFlagsKHR    flags;
-    Display*                       dpy;
-    Window                         window;
-} VkXlibSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
-    VkInstance                                  instance,
-    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    Display*                                    dpy,
-    VisualID                                    visualID);
-#endif
-#endif /* VK_USE_PLATFORM_XLIB_KHR */
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-#define VK_KHR_xcb_surface 1
-#include <xcb/xcb.h>
-
-#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
-#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
-
-typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
-
-typedef struct VkXcbSurfaceCreateInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkXcbSurfaceCreateFlagsKHR    flags;
-    xcb_connection_t*             connection;
-    xcb_window_t                  window;
-} VkXcbSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
-    VkInstance                                  instance,
-    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    xcb_connection_t*                           connection,
-    xcb_visualid_t                              visual_id);
-#endif
-#endif /* VK_USE_PLATFORM_XCB_KHR */
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-#define VK_KHR_wayland_surface 1
-#include <wayland-client.h>
-
-#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
-#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
-
-typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
-
-typedef struct VkWaylandSurfaceCreateInfoKHR {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkWaylandSurfaceCreateFlagsKHR    flags;
-    struct wl_display*                display;
-    struct wl_surface*                surface;
-} VkWaylandSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
-    VkInstance                                  instance,
-    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    struct wl_display*                          display);
-#endif
-#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-#define VK_KHR_mir_surface 1
-#include <mir_toolkit/client_types.h>
-
-#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
-#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
-
-typedef VkFlags VkMirSurfaceCreateFlagsKHR;
-
-typedef struct VkMirSurfaceCreateInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkMirSurfaceCreateFlagsKHR    flags;
-    MirConnection*                connection;
-    MirSurface*                   mirSurface;
-} VkMirSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
-    VkInstance                                  instance,
-    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex,
-    MirConnection*                              connection);
-#endif
-#endif /* VK_USE_PLATFORM_MIR_KHR */
+#include "vulkan_core.h"
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-#define VK_KHR_android_surface 1
-#include <android/native_window.h>
-
-#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
-#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
-
-typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
-
-typedef struct VkAndroidSurfaceCreateInfoKHR {
-    VkStructureType                   sType;
-    const void*                       pNext;
-    VkAndroidSurfaceCreateFlagsKHR    flags;
-    ANativeWindow*                    window;
-} VkAndroidSurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
-    VkInstance                                  instance,
-    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-#endif
-#endif /* VK_USE_PLATFORM_ANDROID_KHR */
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_KHR_win32_surface 1
-#include <windows.h>
-
-#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
-#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
-
-typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
-
-typedef struct VkWin32SurfaceCreateInfoKHR {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkWin32SurfaceCreateFlagsKHR    flags;
-    HINSTANCE                       hinstance;
-    HWND                            hwnd;
-} VkWin32SurfaceCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
-    VkInstance                                  instance,
-    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-
-VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t                                    queueFamilyIndex);
-#endif
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHR_sampler_mirror_clamp_to_edge 1
-#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
-#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
-
-
-#define VK_KHR_get_physical_device_properties2 1
-#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
-#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
-
-typedef struct VkPhysicalDeviceFeatures2KHR {
-    VkStructureType             sType;
-    void*                       pNext;
-    VkPhysicalDeviceFeatures    features;
-} VkPhysicalDeviceFeatures2KHR;
-
-typedef struct VkPhysicalDeviceProperties2KHR {
-    VkStructureType               sType;
-    void*                         pNext;
-    VkPhysicalDeviceProperties    properties;
-} VkPhysicalDeviceProperties2KHR;
-
-typedef struct VkFormatProperties2KHR {
-    VkStructureType       sType;
-    void*                 pNext;
-    VkFormatProperties    formatProperties;
-} VkFormatProperties2KHR;
-
-typedef struct VkImageFormatProperties2KHR {
-    VkStructureType            sType;
-    void*                      pNext;
-    VkImageFormatProperties    imageFormatProperties;
-} VkImageFormatProperties2KHR;
-
-typedef struct VkPhysicalDeviceImageFormatInfo2KHR {
-    VkStructureType       sType;
-    const void*           pNext;
-    VkFormat              format;
-    VkImageType           type;
-    VkImageTiling         tiling;
-    VkImageUsageFlags     usage;
-    VkImageCreateFlags    flags;
-} VkPhysicalDeviceImageFormatInfo2KHR;
-
-typedef struct VkQueueFamilyProperties2KHR {
-    VkStructureType            sType;
-    void*                      pNext;
-    VkQueueFamilyProperties    queueFamilyProperties;
-} VkQueueFamilyProperties2KHR;
-
-typedef struct VkPhysicalDeviceMemoryProperties2KHR {
-    VkStructureType                     sType;
-    void*                               pNext;
-    VkPhysicalDeviceMemoryProperties    memoryProperties;
-} VkPhysicalDeviceMemoryProperties2KHR;
-
-typedef struct VkSparseImageFormatProperties2KHR {
-    VkStructureType                  sType;
-    void*                            pNext;
-    VkSparseImageFormatProperties    properties;
-} VkSparseImageFormatProperties2KHR;
-
-typedef struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    VkFormat                 format;
-    VkImageType              type;
-    VkSampleCountFlagBits    samples;
-    VkImageUsageFlags        usage;
-    VkImageTiling            tiling;
-} VkPhysicalDeviceSparseImageFormatInfo2KHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceFeatures2KHR*               pFeatures);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceProperties2KHR*             pProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkFormatProperties2KHR*                     pFormatProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceImageFormatInfo2KHR*  pImageFormatInfo,
-    VkImageFormatProperties2KHR*                pImageFormatProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pQueueFamilyPropertyCount,
-    VkQueueFamilyProperties2KHR*                pQueueFamilyProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    VkPhysicalDeviceMemoryProperties2KHR*       pMemoryProperties);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
-    uint32_t*                                   pPropertyCount,
-    VkSparseImageFormatProperties2KHR*          pProperties);
+#include "vulkan_android.h"
 #endif
 
-#define VK_KHR_shader_draw_parameters 1
-#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
-#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
 
-
-#define VK_KHR_maintenance1 1
-#define VK_KHR_MAINTENANCE1_SPEC_VERSION  1
-#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
-
-typedef VkFlags VkCommandPoolTrimFlagsKHR;
-
-typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
-    VkDevice                                    device,
-    VkCommandPool                               commandPool,
-    VkCommandPoolTrimFlagsKHR                   flags);
+#ifdef VK_USE_PLATFORM_IOS_MVK
+#include "vulkan_ios.h"
 #endif
 
-#define VK_KHR_external_memory_capabilities 1
-#define VK_LUID_SIZE_KHR                  8
-#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
 
-
-typedef enum VkExternalMemoryHandleTypeFlagBitsKHR {
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = 0x00000008,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = 0x00000010,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = 0x00000020,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = 0x00000040,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalMemoryHandleTypeFlagBitsKHR;
-typedef VkFlags VkExternalMemoryHandleTypeFlagsKHR;
-
-typedef enum VkExternalMemoryFeatureFlagBitsKHR {
-    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = 0x00000004,
-    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalMemoryFeatureFlagBitsKHR;
-typedef VkFlags VkExternalMemoryFeatureFlagsKHR;
-
-typedef struct VkExternalMemoryPropertiesKHR {
-    VkExternalMemoryFeatureFlagsKHR       externalMemoryFeatures;
-    VkExternalMemoryHandleTypeFlagsKHR    exportFromImportedHandleTypes;
-    VkExternalMemoryHandleTypeFlagsKHR    compatibleHandleTypes;
-} VkExternalMemoryPropertiesKHR;
-
-typedef struct VkPhysicalDeviceExternalImageFormatInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-} VkPhysicalDeviceExternalImageFormatInfoKHR;
-
-typedef struct VkExternalImageFormatPropertiesKHR {
-    VkStructureType                  sType;
-    void*                            pNext;
-    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
-} VkExternalImageFormatPropertiesKHR;
-
-typedef struct VkPhysicalDeviceExternalBufferInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkBufferCreateFlags                      flags;
-    VkBufferUsageFlags                       usage;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-} VkPhysicalDeviceExternalBufferInfoKHR;
-
-typedef struct VkExternalBufferPropertiesKHR {
-    VkStructureType                  sType;
-    void*                            pNext;
-    VkExternalMemoryPropertiesKHR    externalMemoryProperties;
-} VkExternalBufferPropertiesKHR;
-
-typedef struct VkPhysicalDeviceIDPropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint8_t            deviceUUID[VK_UUID_SIZE];
-    uint8_t            driverUUID[VK_UUID_SIZE];
-    uint8_t            deviceLUID[VK_LUID_SIZE_KHR];
-    uint32_t           deviceNodeMask;
-    VkBool32           deviceLUIDValid;
-} VkPhysicalDeviceIDPropertiesKHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
-    VkExternalBufferPropertiesKHR*              pExternalBufferProperties);
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+#include "vulkan_macos.h"
 #endif
 
-#define VK_KHR_external_memory 1
-#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
-#define VK_QUEUE_FAMILY_EXTERNAL_KHR      (~0U-1)
 
-typedef struct VkExternalMemoryImageCreateInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
-} VkExternalMemoryImageCreateInfoKHR;
-
-typedef struct VkExternalMemoryBufferCreateInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
-} VkExternalMemoryBufferCreateInfoKHR;
-
-typedef struct VkExportMemoryAllocateInfoKHR {
-    VkStructureType                       sType;
-    const void*                           pNext;
-    VkExternalMemoryHandleTypeFlagsKHR    handleTypes;
-} VkExportMemoryAllocateInfoKHR;
-
-
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_KHR_external_memory_win32 1
-#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
-
-typedef struct VkImportMemoryWin32HandleInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-    HANDLE                                   handle;
-    LPCWSTR                                  name;
-} VkImportMemoryWin32HandleInfoKHR;
-
-typedef struct VkExportMemoryWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportMemoryWin32HandleInfoKHR;
-
-typedef struct VkMemoryWin32HandlePropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           memoryTypeBits;
-} VkMemoryWin32HandlePropertiesKHR;
-
-typedef struct VkMemoryGetWin32HandleInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkDeviceMemory                           memory;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-} VkMemoryGetWin32HandleInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
-    VkDevice                                    device,
-    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    HANDLE                                      handle,
-    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#ifdef VK_USE_PLATFORM_MIR_KHR
+#include <mir_toolkit/client_types.h>
+#include "vulkan_mir.h"
 #endif
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHR_external_memory_fd 1
-#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
-
-typedef struct VkImportMemoryFdInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-    int                                      fd;
-} VkImportMemoryFdInfoKHR;
-
-typedef struct VkMemoryFdPropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           memoryTypeBits;
-} VkMemoryFdPropertiesKHR;
-
-typedef struct VkMemoryGetFdInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkDeviceMemory                           memory;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-} VkMemoryGetFdInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
-    VkDevice                                    device,
-    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
-    int*                                        pFd);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    int                                         fd,
-    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
-#endif
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_KHR_win32_keyed_mutex 1
-#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
-#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
-
-typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 acquireCount;
-    const VkDeviceMemory*    pAcquireSyncs;
-    const uint64_t*          pAcquireKeys;
-    const uint32_t*          pAcquireTimeouts;
-    uint32_t                 releaseCount;
-    const VkDeviceMemory*    pReleaseSyncs;
-    const uint64_t*          pReleaseKeys;
-} VkWin32KeyedMutexAcquireReleaseInfoKHR;
-
-
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHR_external_semaphore_capabilities 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
-
-
-typedef enum VkExternalSemaphoreHandleTypeFlagBitsKHR {
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = 0x00000008,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000010,
-    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalSemaphoreHandleTypeFlagBitsKHR;
-typedef VkFlags VkExternalSemaphoreHandleTypeFlagsKHR;
-
-typedef enum VkExternalSemaphoreFeatureFlagBitsKHR {
-    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalSemaphoreFeatureFlagBitsKHR;
-typedef VkFlags VkExternalSemaphoreFeatureFlagsKHR;
-
-typedef struct VkPhysicalDeviceExternalSemaphoreInfoKHR {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
-} VkPhysicalDeviceExternalSemaphoreInfoKHR;
-
-typedef struct VkExternalSemaphorePropertiesKHR {
-    VkStructureType                          sType;
-    void*                                    pNext;
-    VkExternalSemaphoreHandleTypeFlagsKHR    exportFromImportedHandleTypes;
-    VkExternalSemaphoreHandleTypeFlagsKHR    compatibleHandleTypes;
-    VkExternalSemaphoreFeatureFlagsKHR       externalSemaphoreFeatures;
-} VkExternalSemaphorePropertiesKHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo,
-    VkExternalSemaphorePropertiesKHR*           pExternalSemaphoreProperties);
-#endif
-
-#define VK_KHR_external_semaphore 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
-
-
-typedef enum VkSemaphoreImportFlagBitsKHR {
-    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
-    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkSemaphoreImportFlagBitsKHR;
-typedef VkFlags VkSemaphoreImportFlagsKHR;
-
-typedef struct VkExportSemaphoreCreateInfoKHR {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkExternalSemaphoreHandleTypeFlagsKHR    handleTypes;
-} VkExportSemaphoreCreateInfoKHR;
-
-
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_KHR_external_semaphore_win32 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
-
-typedef struct VkImportSemaphoreWin32HandleInfoKHR {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkSemaphore                                 semaphore;
-    VkSemaphoreImportFlagsKHR                   flags;
-    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
-    HANDLE                                      handle;
-    LPCWSTR                                     name;
-} VkImportSemaphoreWin32HandleInfoKHR;
-
-typedef struct VkExportSemaphoreWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportSemaphoreWin32HandleInfoKHR;
-
-typedef struct VkD3D12FenceSubmitInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           waitSemaphoreValuesCount;
-    const uint64_t*    pWaitSemaphoreValues;
-    uint32_t           signalSemaphoreValuesCount;
-    const uint64_t*    pSignalSemaphoreValues;
-} VkD3D12FenceSubmitInfoKHR;
-
-typedef struct VkSemaphoreGetWin32HandleInfoKHR {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkSemaphore                                 semaphore;
-    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
-} VkSemaphoreGetWin32HandleInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
-    VkDevice                                    device,
-    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-#endif
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHR_external_semaphore_fd 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
-
-typedef struct VkImportSemaphoreFdInfoKHR {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkSemaphore                                 semaphore;
-    VkSemaphoreImportFlagsKHR                   flags;
-    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
-    int                                         fd;
-} VkImportSemaphoreFdInfoKHR;
-
-typedef struct VkSemaphoreGetFdInfoKHR {
-    VkStructureType                             sType;
-    const void*                                 pNext;
-    VkSemaphore                                 semaphore;
-    VkExternalSemaphoreHandleTypeFlagBitsKHR    handleType;
-} VkSemaphoreGetFdInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
-    VkDevice                                    device,
-    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
-    VkDevice                                    device,
-    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
-    int*                                        pFd);
-#endif
-
-#define VK_KHR_push_descriptor 1
-#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 1
-#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
-
-typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           maxPushDescriptors;
-} VkPhysicalDevicePushDescriptorPropertiesKHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
-    VkCommandBuffer                             commandBuffer,
-    VkPipelineBindPoint                         pipelineBindPoint,
-    VkPipelineLayout                            layout,
-    uint32_t                                    set,
-    uint32_t                                    descriptorWriteCount,
-    const VkWriteDescriptorSet*                 pDescriptorWrites);
-#endif
-
-#define VK_KHR_16bit_storage 1
-#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
-#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
-
-typedef struct VkPhysicalDevice16BitStorageFeaturesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           storageBuffer16BitAccess;
-    VkBool32           uniformAndStorageBuffer16BitAccess;
-    VkBool32           storagePushConstant16;
-    VkBool32           storageInputOutput16;
-} VkPhysicalDevice16BitStorageFeaturesKHR;
-
-
-
-#define VK_KHR_incremental_present 1
-#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
-#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
-
-typedef struct VkRectLayerKHR {
-    VkOffset2D    offset;
-    VkExtent2D    extent;
-    uint32_t      layer;
-} VkRectLayerKHR;
-
-typedef struct VkPresentRegionKHR {
-    uint32_t                 rectangleCount;
-    const VkRectLayerKHR*    pRectangles;
-} VkPresentRegionKHR;
-
-typedef struct VkPresentRegionsKHR {
-    VkStructureType              sType;
-    const void*                  pNext;
-    uint32_t                     swapchainCount;
-    const VkPresentRegionKHR*    pRegions;
-} VkPresentRegionsKHR;
-
-
-
-#define VK_KHR_descriptor_update_template 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplateKHR)
-
-#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
-#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
-
-
-typedef enum VkDescriptorUpdateTemplateTypeKHR {
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = 0,
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR,
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE_KHR = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR + 1),
-    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkDescriptorUpdateTemplateTypeKHR;
-
-typedef VkFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
-
-typedef struct VkDescriptorUpdateTemplateEntryKHR {
-    uint32_t            dstBinding;
-    uint32_t            dstArrayElement;
-    uint32_t            descriptorCount;
-    VkDescriptorType    descriptorType;
-    size_t              offset;
-    size_t              stride;
-} VkDescriptorUpdateTemplateEntryKHR;
-
-typedef struct VkDescriptorUpdateTemplateCreateInfoKHR {
-    VkStructureType                              sType;
-    void*                                        pNext;
-    VkDescriptorUpdateTemplateCreateFlagsKHR     flags;
-    uint32_t                                     descriptorUpdateEntryCount;
-    const VkDescriptorUpdateTemplateEntryKHR*    pDescriptorUpdateEntries;
-    VkDescriptorUpdateTemplateTypeKHR            templateType;
-    VkDescriptorSetLayout                        descriptorSetLayout;
-    VkPipelineBindPoint                          pipelineBindPoint;
-    VkPipelineLayout                             pipelineLayout;
-    uint32_t                                     set;
-} VkDescriptorUpdateTemplateCreateInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
-typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
-typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
-typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
-    VkDevice                                    device,
-    const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDescriptorUpdateTemplateKHR*              pDescriptorUpdateTemplate);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
-    VkDevice                                    device,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
-    VkDevice                                    device,
-    VkDescriptorSet                             descriptorSet,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    const void*                                 pData);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
-    VkCommandBuffer                             commandBuffer,
-    VkDescriptorUpdateTemplateKHR               descriptorUpdateTemplate,
-    VkPipelineLayout                            layout,
-    uint32_t                                    set,
-    const void*                                 pData);
-#endif
-
-#define VK_KHR_shared_presentable_image 1
-#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
-#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
-
-typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
-    VkStructureType      sType;
-    void*                pNext;
-    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
-} VkSharedPresentSurfaceCapabilitiesKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain);
-#endif
-
-#define VK_KHR_external_fence_capabilities 1
-#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
-
-
-typedef enum VkExternalFenceHandleTypeFlagBitsKHR {
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = 0x00000004,
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = 0x00000008,
-    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalFenceHandleTypeFlagBitsKHR;
-typedef VkFlags VkExternalFenceHandleTypeFlagsKHR;
-
-typedef enum VkExternalFenceFeatureFlagBitsKHR {
-    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = 0x00000001,
-    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = 0x00000002,
-    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkExternalFenceFeatureFlagBitsKHR;
-typedef VkFlags VkExternalFenceFeatureFlagsKHR;
-
-typedef struct VkPhysicalDeviceExternalFenceInfoKHR {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
-} VkPhysicalDeviceExternalFenceInfoKHR;
-
-typedef struct VkExternalFencePropertiesKHR {
-    VkStructureType                      sType;
-    void*                                pNext;
-    VkExternalFenceHandleTypeFlagsKHR    exportFromImportedHandleTypes;
-    VkExternalFenceHandleTypeFlagsKHR    compatibleHandleTypes;
-    VkExternalFenceFeatureFlagsKHR       externalFenceFeatures;
-} VkExternalFencePropertiesKHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo,
-    VkExternalFencePropertiesKHR*               pExternalFenceProperties);
-#endif
-
-#define VK_KHR_external_fence 1
-#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
-
-
-typedef enum VkFenceImportFlagBitsKHR {
-    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = 0x00000001,
-    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkFenceImportFlagBitsKHR;
-typedef VkFlags VkFenceImportFlagsKHR;
-
-typedef struct VkExportFenceCreateInfoKHR {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkExternalFenceHandleTypeFlagsKHR    handleTypes;
-} VkExportFenceCreateInfoKHR;
-
-
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_KHR_external_fence_win32 1
-#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
-
-typedef struct VkImportFenceWin32HandleInfoKHR {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkFence                                 fence;
-    VkFenceImportFlagsKHR                   flags;
-    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
-    HANDLE                                  handle;
-    LPCWSTR                                 name;
-} VkImportFenceWin32HandleInfoKHR;
-
-typedef struct VkExportFenceWin32HandleInfoKHR {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-    LPCWSTR                       name;
-} VkExportFenceWin32HandleInfoKHR;
-
-typedef struct VkFenceGetWin32HandleInfoKHR {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkFence                                 fence;
-    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
-} VkFenceGetWin32HandleInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
-    VkDevice                                    device,
-    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
-    HANDLE*                                     pHandle);
-#endif
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHR_external_fence_fd 1
-#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
-#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
-
-typedef struct VkImportFenceFdInfoKHR {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkFence                                 fence;
-    VkFenceImportFlagsKHR                   flags;
-    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
-    int                                     fd;
-} VkImportFenceFdInfoKHR;
-
-typedef struct VkFenceGetFdInfoKHR {
-    VkStructureType                         sType;
-    const void*                             pNext;
-    VkFence                                 fence;
-    VkExternalFenceHandleTypeFlagBitsKHR    handleType;
-} VkFenceGetFdInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
-    VkDevice                                    device,
-    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
-    VkDevice                                    device,
-    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
-    int*                                        pFd);
-#endif
-
-#define VK_KHR_maintenance2 1
-#define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
-#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
-
-
-typedef enum VkPointClippingBehaviorKHR {
-    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = 0,
-    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = 1,
-    VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR,
-    VK_POINT_CLIPPING_BEHAVIOR_END_RANGE_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR,
-    VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE_KHR = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR + 1),
-    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkPointClippingBehaviorKHR;
-
-typedef enum VkTessellationDomainOriginKHR {
-    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = 0,
-    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = 1,
-    VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR,
-    VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR,
-    VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE_KHR = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR + 1),
-    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkTessellationDomainOriginKHR;
-
-typedef struct VkPhysicalDevicePointClippingPropertiesKHR {
-    VkStructureType               sType;
-    void*                         pNext;
-    VkPointClippingBehaviorKHR    pointClippingBehavior;
-} VkPhysicalDevicePointClippingPropertiesKHR;
-
-typedef struct VkInputAttachmentAspectReferenceKHR {
-    uint32_t              subpass;
-    uint32_t              inputAttachmentIndex;
-    VkImageAspectFlags    aspectMask;
-} VkInputAttachmentAspectReferenceKHR;
-
-typedef struct VkRenderPassInputAttachmentAspectCreateInfoKHR {
-    VkStructureType                               sType;
-    const void*                                   pNext;
-    uint32_t                                      aspectReferenceCount;
-    const VkInputAttachmentAspectReferenceKHR*    pAspectReferences;
-} VkRenderPassInputAttachmentAspectCreateInfoKHR;
-
-typedef struct VkImageViewUsageCreateInfoKHR {
-    VkStructureType      sType;
-    const void*          pNext;
-    VkImageUsageFlags    usage;
-} VkImageViewUsageCreateInfoKHR;
-
-typedef struct VkPipelineTessellationDomainOriginStateCreateInfoKHR {
-    VkStructureType                  sType;
-    const void*                      pNext;
-    VkTessellationDomainOriginKHR    domainOrigin;
-} VkPipelineTessellationDomainOriginStateCreateInfoKHR;
-
-
-
-#define VK_KHR_get_surface_capabilities2 1
-#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
-#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
-
-typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkSurfaceKHR       surface;
-} VkPhysicalDeviceSurfaceInfo2KHR;
-
-typedef struct VkSurfaceCapabilities2KHR {
-    VkStructureType             sType;
-    void*                       pNext;
-    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
-} VkSurfaceCapabilities2KHR;
-
-typedef struct VkSurfaceFormat2KHR {
-    VkStructureType       sType;
-    void*                 pNext;
-    VkSurfaceFormatKHR    surfaceFormat;
-} VkSurfaceFormat2KHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
-    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
-    VkPhysicalDevice                            physicalDevice,
-    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
-    uint32_t*                                   pSurfaceFormatCount,
-    VkSurfaceFormat2KHR*                        pSurfaceFormats);
-#endif
-
-#define VK_KHR_variable_pointers 1
-#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
-#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
-
-typedef struct VkPhysicalDeviceVariablePointerFeaturesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           variablePointersStorageBuffer;
-    VkBool32           variablePointers;
-} VkPhysicalDeviceVariablePointerFeaturesKHR;
-
-
-
-#define VK_KHR_dedicated_allocation 1
-#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
-#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
-
-typedef struct VkMemoryDedicatedRequirementsKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           prefersDedicatedAllocation;
-    VkBool32           requiresDedicatedAllocation;
-} VkMemoryDedicatedRequirementsKHR;
-
-typedef struct VkMemoryDedicatedAllocateInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkImage            image;
-    VkBuffer           buffer;
-} VkMemoryDedicatedAllocateInfoKHR;
-
-
-
-#define VK_KHR_storage_buffer_storage_class 1
-#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
-#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
-
-
-#define VK_KHR_relaxed_block_layout 1
-#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
-#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
-
-
-#define VK_KHR_get_memory_requirements2 1
-#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
-#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
-
-typedef struct VkBufferMemoryRequirementsInfo2KHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBuffer           buffer;
-} VkBufferMemoryRequirementsInfo2KHR;
-
-typedef struct VkImageMemoryRequirementsInfo2KHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkImage            image;
-} VkImageMemoryRequirementsInfo2KHR;
-
-typedef struct VkImageSparseMemoryRequirementsInfo2KHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkImage            image;
-} VkImageSparseMemoryRequirementsInfo2KHR;
-
-typedef struct VkMemoryRequirements2KHR {
-    VkStructureType         sType;
-    void*                   pNext;
-    VkMemoryRequirements    memoryRequirements;
-} VkMemoryRequirements2KHR;
-
-typedef struct VkSparseImageMemoryRequirements2KHR {
-    VkStructureType                    sType;
-    void*                              pNext;
-    VkSparseImageMemoryRequirements    memoryRequirements;
-} VkSparseImageMemoryRequirements2KHR;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
-typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);
-typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkImageMemoryRequirementsInfo2KHR*    pInfo,
-    VkMemoryRequirements2KHR*                   pMemoryRequirements);
-
-VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkBufferMemoryRequirementsInfo2KHR*   pInfo,
-    VkMemoryRequirements2KHR*                   pMemoryRequirements);
-
-VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
-    VkDevice                                    device,
-    const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
-    uint32_t*                                   pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2KHR*        pSparseMemoryRequirements);
-#endif
-
-#define VK_KHR_image_format_list 1
-#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
-#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
-
-typedef struct VkImageFormatListCreateInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           viewFormatCount;
-    const VkFormat*    pViewFormats;
-} VkImageFormatListCreateInfoKHR;
-
-
-
-#define VK_KHR_sampler_ycbcr_conversion 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversionKHR)
-
-#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
-#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
-
-
-typedef enum VkSamplerYcbcrModelConversionKHR {
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = 0,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = 1,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = 2,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = 3,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = 4,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR,
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR + 1),
-    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkSamplerYcbcrModelConversionKHR;
-
-typedef enum VkSamplerYcbcrRangeKHR {
-    VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = 0,
-    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = 1,
-    VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
-    VK_SAMPLER_YCBCR_RANGE_END_RANGE_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR,
-    VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE_KHR = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR + 1),
-    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkSamplerYcbcrRangeKHR;
-
-typedef enum VkChromaLocationKHR {
-    VK_CHROMA_LOCATION_COSITED_EVEN_KHR = 0,
-    VK_CHROMA_LOCATION_MIDPOINT_KHR = 1,
-    VK_CHROMA_LOCATION_BEGIN_RANGE_KHR = VK_CHROMA_LOCATION_COSITED_EVEN_KHR,
-    VK_CHROMA_LOCATION_END_RANGE_KHR = VK_CHROMA_LOCATION_MIDPOINT_KHR,
-    VK_CHROMA_LOCATION_RANGE_SIZE_KHR = (VK_CHROMA_LOCATION_MIDPOINT_KHR - VK_CHROMA_LOCATION_COSITED_EVEN_KHR + 1),
-    VK_CHROMA_LOCATION_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkChromaLocationKHR;
-
-typedef struct VkSamplerYcbcrConversionCreateInfoKHR {
-    VkStructureType                     sType;
-    const void*                         pNext;
-    VkFormat                            format;
-    VkSamplerYcbcrModelConversionKHR    ycbcrModel;
-    VkSamplerYcbcrRangeKHR              ycbcrRange;
-    VkComponentMapping                  components;
-    VkChromaLocationKHR                 xChromaOffset;
-    VkChromaLocationKHR                 yChromaOffset;
-    VkFilter                            chromaFilter;
-    VkBool32                            forceExplicitReconstruction;
-} VkSamplerYcbcrConversionCreateInfoKHR;
-
-typedef struct VkSamplerYcbcrConversionInfoKHR {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkSamplerYcbcrConversionKHR    conversion;
-} VkSamplerYcbcrConversionInfoKHR;
-
-typedef struct VkBindImagePlaneMemoryInfoKHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    VkImageAspectFlagBits    planeAspect;
-} VkBindImagePlaneMemoryInfoKHR;
-
-typedef struct VkImagePlaneMemoryRequirementsInfoKHR {
-    VkStructureType          sType;
-    const void*              pNext;
-    VkImageAspectFlagBits    planeAspect;
-} VkImagePlaneMemoryRequirementsInfoKHR;
-
-typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           samplerYcbcrConversion;
-} VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
-
-typedef struct VkSamplerYcbcrConversionImageFormatPropertiesKHR {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           combinedImageSamplerDescriptorCount;
-} VkSamplerYcbcrConversionImageFormatPropertiesKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion);
-typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversionKHR ycbcrConversion, const VkAllocationCallbacks* pAllocator);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
-    VkDevice                                    device,
-    const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSamplerYcbcrConversionKHR*                pYcbcrConversion);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
-    VkDevice                                    device,
-    VkSamplerYcbcrConversionKHR                 ycbcrConversion,
-    const VkAllocationCallbacks*                pAllocator);
-#endif
-
-#define VK_KHR_bind_memory2 1
-#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
-#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
-
-typedef struct VkBindBufferMemoryInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBuffer           buffer;
-    VkDeviceMemory     memory;
-    VkDeviceSize       memoryOffset;
-} VkBindBufferMemoryInfoKHR;
-
-typedef struct VkBindImageMemoryInfoKHR {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkImage            image;
-    VkDeviceMemory     memory;
-    VkDeviceSize       memoryOffset;
-} VkBindImageMemoryInfoKHR;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos);
-typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
-    VkDevice                                    device,
-    uint32_t                                    bindInfoCount,
-    const VkBindBufferMemoryInfoKHR*            pBindInfos);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
-    VkDevice                                    device,
-    uint32_t                                    bindInfoCount,
-    const VkBindImageMemoryInfoKHR*             pBindInfos);
-#endif
-
-#define VK_EXT_debug_report 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
-
-#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
-#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
-#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
-#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
-
-
-typedef enum VkDebugReportObjectTypeEXT {
-    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
-    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
-    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
-    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
-    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
-    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
-    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
-    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
-    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
-    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
-    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
-    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
-    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
-    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
-    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
-    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
-    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
-    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
-    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
-    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
-    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
-    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = 1000085000,
-    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = 1000156000,
-    VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
-    VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
-    VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
-    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDebugReportObjectTypeEXT;
-
-
-typedef enum VkDebugReportFlagBitsEXT {
-    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
-    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
-    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
-    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
-    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
-    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDebugReportFlagBitsEXT;
-typedef VkFlags VkDebugReportFlagsEXT;
-
-typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
-    VkDebugReportFlagsEXT                       flags,
-    VkDebugReportObjectTypeEXT                  objectType,
-    uint64_t                                    object,
-    size_t                                      location,
-    int32_t                                     messageCode,
-    const char*                                 pLayerPrefix,
-    const char*                                 pMessage,
-    void*                                       pUserData);
-
-typedef struct VkDebugReportCallbackCreateInfoEXT {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkDebugReportFlagsEXT           flags;
-    PFN_vkDebugReportCallbackEXT    pfnCallback;
-    void*                           pUserData;
-} VkDebugReportCallbackCreateInfoEXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
-typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
-typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
-    VkInstance                                  instance,
-    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkDebugReportCallbackEXT*                   pCallback);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
-    VkInstance                                  instance,
-    VkDebugReportCallbackEXT                    callback,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
-    VkInstance                                  instance,
-    VkDebugReportFlagsEXT                       flags,
-    VkDebugReportObjectTypeEXT                  objectType,
-    uint64_t                                    object,
-    size_t                                      location,
-    int32_t                                     messageCode,
-    const char*                                 pLayerPrefix,
-    const char*                                 pMessage);
-#endif
-
-#define VK_NV_glsl_shader 1
-#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
-#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
-
-
-#define VK_EXT_depth_range_unrestricted 1
-#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
-#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
-
-
-#define VK_IMG_filter_cubic 1
-#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
-#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
-
-
-#define VK_AMD_rasterization_order 1
-#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
-#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
-
-
-typedef enum VkRasterizationOrderAMD {
-    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
-    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
-    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
-    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
-    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
-    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
-} VkRasterizationOrderAMD;
-
-typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
-    VkStructureType            sType;
-    const void*                pNext;
-    VkRasterizationOrderAMD    rasterizationOrder;
-} VkPipelineRasterizationStateRasterizationOrderAMD;
-
-
-
-#define VK_AMD_shader_trinary_minmax 1
-#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
-#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
-
-
-#define VK_AMD_shader_explicit_vertex_parameter 1
-#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
-#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
-
-
-#define VK_EXT_debug_marker 1
-#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
-#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
-
-typedef struct VkDebugMarkerObjectNameInfoEXT {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkDebugReportObjectTypeEXT    objectType;
-    uint64_t                      object;
-    const char*                   pObjectName;
-} VkDebugMarkerObjectNameInfoEXT;
-
-typedef struct VkDebugMarkerObjectTagInfoEXT {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkDebugReportObjectTypeEXT    objectType;
-    uint64_t                      object;
-    uint64_t                      tagName;
-    size_t                        tagSize;
-    const void*                   pTag;
-} VkDebugMarkerObjectTagInfoEXT;
-
-typedef struct VkDebugMarkerMarkerInfoEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    const char*        pMarkerName;
-    float              color[4];
-} VkDebugMarkerMarkerInfoEXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
-typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
-    VkDevice                                    device,
-    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
-    VkCommandBuffer                             commandBuffer);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
-#endif
-
-#define VK_AMD_gcn_shader 1
-#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
-#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
-
-
-#define VK_NV_dedicated_allocation 1
-#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
-#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
-
-typedef struct VkDedicatedAllocationImageCreateInfoNV {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           dedicatedAllocation;
-} VkDedicatedAllocationImageCreateInfoNV;
-
-typedef struct VkDedicatedAllocationBufferCreateInfoNV {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           dedicatedAllocation;
-} VkDedicatedAllocationBufferCreateInfoNV;
-
-typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkImage            image;
-    VkBuffer           buffer;
-} VkDedicatedAllocationMemoryAllocateInfoNV;
-
-
-
-#define VK_AMD_draw_indirect_count 1
-#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
-#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
-
-typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
-typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    VkBuffer                                    countBuffer,
-    VkDeviceSize                                countBufferOffset,
-    uint32_t                                    maxDrawCount,
-    uint32_t                                    stride);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
-    VkCommandBuffer                             commandBuffer,
-    VkBuffer                                    buffer,
-    VkDeviceSize                                offset,
-    VkBuffer                                    countBuffer,
-    VkDeviceSize                                countBufferOffset,
-    uint32_t                                    maxDrawCount,
-    uint32_t                                    stride);
-#endif
-
-#define VK_AMD_negative_viewport_height 1
-#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
-#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
-
-
-#define VK_AMD_gpu_shader_half_float 1
-#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
-#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
-
-
-#define VK_AMD_shader_ballot 1
-#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
-#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
-
-
-#define VK_AMD_texture_gather_bias_lod 1
-#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
-#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
-
-typedef struct VkTextureLODGatherFormatPropertiesAMD {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           supportsTextureGatherLODBiasAMD;
-} VkTextureLODGatherFormatPropertiesAMD;
-
-
-
-#define VK_AMD_shader_info 1
-#define VK_AMD_SHADER_INFO_SPEC_VERSION   1
-#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
-
-
-typedef enum VkShaderInfoTypeAMD {
-    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
-    VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
-    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
-    VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
-    VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD,
-    VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1),
-    VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
-} VkShaderInfoTypeAMD;
-
-typedef struct VkShaderResourceUsageAMD {
-    uint32_t    numUsedVgprs;
-    uint32_t    numUsedSgprs;
-    uint32_t    ldsSizePerLocalWorkGroup;
-    size_t      ldsUsageSizeInBytes;
-    size_t      scratchMemUsageInBytes;
-} VkShaderResourceUsageAMD;
-
-typedef struct VkShaderStatisticsInfoAMD {
-    VkShaderStageFlags          shaderStageMask;
-    VkShaderResourceUsageAMD    resourceUsage;
-    uint32_t                    numPhysicalVgprs;
-    uint32_t                    numPhysicalSgprs;
-    uint32_t                    numAvailableVgprs;
-    uint32_t                    numAvailableSgprs;
-    uint32_t                    computeWorkGroupSize[3];
-} VkShaderStatisticsInfoAMD;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
-    VkDevice                                    device,
-    VkPipeline                                  pipeline,
-    VkShaderStageFlagBits                       shaderStage,
-    VkShaderInfoTypeAMD                         infoType,
-    size_t*                                     pInfoSize,
-    void*                                       pInfo);
-#endif
-
-#define VK_AMD_shader_image_load_store_lod 1
-#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
-#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
-
-
-#define VK_KHX_multiview 1
-#define VK_KHX_MULTIVIEW_SPEC_VERSION     1
-#define VK_KHX_MULTIVIEW_EXTENSION_NAME   "VK_KHX_multiview"
-
-typedef struct VkRenderPassMultiviewCreateInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           subpassCount;
-    const uint32_t*    pViewMasks;
-    uint32_t           dependencyCount;
-    const int32_t*     pViewOffsets;
-    uint32_t           correlationMaskCount;
-    const uint32_t*    pCorrelationMasks;
-} VkRenderPassMultiviewCreateInfoKHX;
-
-typedef struct VkPhysicalDeviceMultiviewFeaturesKHX {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           multiview;
-    VkBool32           multiviewGeometryShader;
-    VkBool32           multiviewTessellationShader;
-} VkPhysicalDeviceMultiviewFeaturesKHX;
-
-typedef struct VkPhysicalDeviceMultiviewPropertiesKHX {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           maxMultiviewViewCount;
-    uint32_t           maxMultiviewInstanceIndex;
-} VkPhysicalDeviceMultiviewPropertiesKHX;
-
-
-
-#define VK_IMG_format_pvrtc 1
-#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
-#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
-
-
-#define VK_NV_external_memory_capabilities 1
-#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
-#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
-
-
-typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
-    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
-} VkExternalMemoryHandleTypeFlagBitsNV;
-typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
-
-typedef enum VkExternalMemoryFeatureFlagBitsNV {
-    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
-    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
-    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
-    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
-} VkExternalMemoryFeatureFlagBitsNV;
-typedef VkFlags VkExternalMemoryFeatureFlagsNV;
-
-typedef struct VkExternalImageFormatPropertiesNV {
-    VkImageFormatProperties              imageFormatProperties;
-    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
-    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
-    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
-} VkExternalImageFormatPropertiesNV;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
-    VkPhysicalDevice                            physicalDevice,
-    VkFormat                                    format,
-    VkImageType                                 type,
-    VkImageTiling                               tiling,
-    VkImageUsageFlags                           usage,
-    VkImageCreateFlags                          flags,
-    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
-    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
-#endif
-
-#define VK_NV_external_memory 1
-#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
-#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
-
-typedef struct VkExternalMemoryImageCreateInfoNV {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
-} VkExternalMemoryImageCreateInfoNV;
-
-typedef struct VkExportMemoryAllocateInfoNV {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
-} VkExportMemoryAllocateInfoNV;
-
-
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_NV_external_memory_win32 1
-#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
-#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
-
-typedef struct VkImportMemoryWin32HandleInfoNV {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkExternalMemoryHandleTypeFlagsNV    handleType;
-    HANDLE                               handle;
-} VkImportMemoryWin32HandleInfoNV;
-
-typedef struct VkExportMemoryWin32HandleInfoNV {
-    VkStructureType               sType;
-    const void*                   pNext;
-    const SECURITY_ATTRIBUTES*    pAttributes;
-    DWORD                         dwAccess;
-} VkExportMemoryWin32HandleInfoNV;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
-    VkDevice                                    device,
-    VkDeviceMemory                              memory,
-    VkExternalMemoryHandleTypeFlagsNV           handleType,
-    HANDLE*                                     pHandle);
-#endif
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-#define VK_NV_win32_keyed_mutex 1
-#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
-#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
-
-typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 acquireCount;
-    const VkDeviceMemory*    pAcquireSyncs;
-    const uint64_t*          pAcquireKeys;
-    const uint32_t*          pAcquireTimeoutMilliseconds;
-    uint32_t                 releaseCount;
-    const VkDeviceMemory*    pReleaseSyncs;
-    const uint64_t*          pReleaseKeys;
-} VkWin32KeyedMutexAcquireReleaseInfoNV;
-
-
-#endif /* VK_USE_PLATFORM_WIN32_KHR */
-
-#define VK_KHX_device_group 1
-#define VK_KHX_DEVICE_GROUP_SPEC_VERSION  2
-#define VK_KHX_DEVICE_GROUP_EXTENSION_NAME "VK_KHX_device_group"
-#define VK_MAX_DEVICE_GROUP_SIZE_KHX      32
-
-
-typedef enum VkPeerMemoryFeatureFlagBitsKHX {
-    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX = 0x00000001,
-    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX = 0x00000002,
-    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX = 0x00000004,
-    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX = 0x00000008,
-    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
-} VkPeerMemoryFeatureFlagBitsKHX;
-typedef VkFlags VkPeerMemoryFeatureFlagsKHX;
-
-typedef enum VkMemoryAllocateFlagBitsKHX {
-    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX = 0x00000001,
-    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
-} VkMemoryAllocateFlagBitsKHX;
-typedef VkFlags VkMemoryAllocateFlagsKHX;
-
-typedef enum VkDeviceGroupPresentModeFlagBitsKHX {
-    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX = 0x00000001,
-    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX = 0x00000002,
-    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX = 0x00000004,
-    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX = 0x00000008,
-    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHX = 0x7FFFFFFF
-} VkDeviceGroupPresentModeFlagBitsKHX;
-typedef VkFlags VkDeviceGroupPresentModeFlagsKHX;
-
-typedef struct VkMemoryAllocateFlagsInfoKHX {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkMemoryAllocateFlagsKHX    flags;
-    uint32_t                    deviceMask;
-} VkMemoryAllocateFlagsInfoKHX;
-
-typedef struct VkDeviceGroupRenderPassBeginInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           deviceMask;
-    uint32_t           deviceRenderAreaCount;
-    const VkRect2D*    pDeviceRenderAreas;
-} VkDeviceGroupRenderPassBeginInfoKHX;
-
-typedef struct VkDeviceGroupCommandBufferBeginInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           deviceMask;
-} VkDeviceGroupCommandBufferBeginInfoKHX;
-
-typedef struct VkDeviceGroupSubmitInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           waitSemaphoreCount;
-    const uint32_t*    pWaitSemaphoreDeviceIndices;
-    uint32_t           commandBufferCount;
-    const uint32_t*    pCommandBufferDeviceMasks;
-    uint32_t           signalSemaphoreCount;
-    const uint32_t*    pSignalSemaphoreDeviceIndices;
-} VkDeviceGroupSubmitInfoKHX;
-
-typedef struct VkDeviceGroupBindSparseInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           resourceDeviceIndex;
-    uint32_t           memoryDeviceIndex;
-} VkDeviceGroupBindSparseInfoKHX;
-
-typedef struct VkBindBufferMemoryDeviceGroupInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           deviceIndexCount;
-    const uint32_t*    pDeviceIndices;
-} VkBindBufferMemoryDeviceGroupInfoKHX;
-
-typedef struct VkBindImageMemoryDeviceGroupInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           deviceIndexCount;
-    const uint32_t*    pDeviceIndices;
-    uint32_t           SFRRectCount;
-    const VkRect2D*    pSFRRects;
-} VkBindImageMemoryDeviceGroupInfoKHX;
-
-typedef struct VkDeviceGroupPresentCapabilitiesKHX {
-    VkStructureType                     sType;
-    const void*                         pNext;
-    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
-    VkDeviceGroupPresentModeFlagsKHX    modes;
-} VkDeviceGroupPresentCapabilitiesKHX;
-
-typedef struct VkImageSwapchainCreateInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkSwapchainKHR     swapchain;
-} VkImageSwapchainCreateInfoKHX;
-
-typedef struct VkBindImageMemorySwapchainInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkSwapchainKHR     swapchain;
-    uint32_t           imageIndex;
-} VkBindImageMemorySwapchainInfoKHX;
-
-typedef struct VkAcquireNextImageInfoKHX {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkSwapchainKHR     swapchain;
-    uint64_t           timeout;
-    VkSemaphore        semaphore;
-    VkFence            fence;
-    uint32_t           deviceMask;
-} VkAcquireNextImageInfoKHX;
-
-typedef struct VkDeviceGroupPresentInfoKHX {
-    VkStructureType                        sType;
-    const void*                            pNext;
-    uint32_t                               swapchainCount;
-    const uint32_t*                        pDeviceMasks;
-    VkDeviceGroupPresentModeFlagBitsKHX    mode;
-} VkDeviceGroupPresentInfoKHX;
-
-typedef struct VkDeviceGroupSwapchainCreateInfoKHX {
-    VkStructureType                     sType;
-    const void*                         pNext;
-    VkDeviceGroupPresentModeFlagsKHX    modes;
-} VkDeviceGroupSwapchainCreateInfoKHX;
-
-
-typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHX)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures);
-typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHX)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
-typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHX)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHX)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHX)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHX* pModes);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHX)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
-typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHX)(VkDevice device, const VkAcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHX(
-    VkDevice                                    device,
-    uint32_t                                    heapIndex,
-    uint32_t                                    localDeviceIndex,
-    uint32_t                                    remoteDeviceIndex,
-    VkPeerMemoryFeatureFlagsKHX*                pPeerMemoryFeatures);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHX(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    deviceMask);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHX(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    baseGroupX,
-    uint32_t                                    baseGroupY,
-    uint32_t                                    baseGroupZ,
-    uint32_t                                    groupCountX,
-    uint32_t                                    groupCountY,
-    uint32_t                                    groupCountZ);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHX(
-    VkDevice                                    device,
-    VkDeviceGroupPresentCapabilitiesKHX*        pDeviceGroupPresentCapabilities);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHX(
-    VkDevice                                    device,
-    VkSurfaceKHR                                surface,
-    VkDeviceGroupPresentModeFlagsKHX*           pModes);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHX(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    uint32_t*                                   pRectCount,
-    VkRect2D*                                   pRects);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHX(
-    VkDevice                                    device,
-    const VkAcquireNextImageInfoKHX*            pAcquireInfo,
-    uint32_t*                                   pImageIndex);
-#endif
-
-#define VK_EXT_validation_flags 1
-#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
-#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
-
-
-typedef enum VkValidationCheckEXT {
-    VK_VALIDATION_CHECK_ALL_EXT = 0,
-    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
-    VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
-    VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
-    VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
-    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkValidationCheckEXT;
-
-typedef struct VkValidationFlagsEXT {
-    VkStructureType          sType;
-    const void*              pNext;
-    uint32_t                 disabledValidationCheckCount;
-    VkValidationCheckEXT*    pDisabledValidationChecks;
-} VkValidationFlagsEXT;
-
 
 
 #ifdef VK_USE_PLATFORM_VI_NN
-#define VK_NN_vi_surface 1
-#define VK_NN_VI_SURFACE_SPEC_VERSION     1
-#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
-
-typedef VkFlags VkViSurfaceCreateFlagsNN;
-
-typedef struct VkViSurfaceCreateInfoNN {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkViSurfaceCreateFlagsNN    flags;
-    void*                       window;
-} VkViSurfaceCreateInfoNN;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
-    VkInstance                                  instance,
-    const VkViSurfaceCreateInfoNN*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-#endif
-#endif /* VK_USE_PLATFORM_VI_NN */
-
-#define VK_EXT_shader_subgroup_ballot 1
-#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
-#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
-
-
-#define VK_EXT_shader_subgroup_vote 1
-#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
-#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
-
-
-#define VK_KHX_device_group_creation 1
-#define VK_KHX_DEVICE_GROUP_CREATION_SPEC_VERSION 1
-#define VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHX_device_group_creation"
-
-typedef struct VkPhysicalDeviceGroupPropertiesKHX {
-    VkStructureType     sType;
-    void*               pNext;
-    uint32_t            physicalDeviceCount;
-    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
-    VkBool32            subsetAllocation;
-} VkPhysicalDeviceGroupPropertiesKHX;
-
-typedef struct VkDeviceGroupDeviceCreateInfoKHX {
-    VkStructureType            sType;
-    const void*                pNext;
-    uint32_t                   physicalDeviceCount;
-    const VkPhysicalDevice*    pPhysicalDevices;
-} VkDeviceGroupDeviceCreateInfoKHX;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHX)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHX(
-    VkInstance                                  instance,
-    uint32_t*                                   pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupPropertiesKHX*         pPhysicalDeviceGroupProperties);
+#include "vulkan_vi.h"
 #endif
 
-#define VK_NVX_device_generated_commands 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
 
-#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
-#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
-
-
-typedef enum VkIndirectCommandsTokenTypeNVX {
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
-    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
-} VkIndirectCommandsTokenTypeNVX;
-
-typedef enum VkObjectEntryTypeNVX {
-    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
-    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
-    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
-    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
-    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
-    VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
-    VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
-    VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
-    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
-} VkObjectEntryTypeNVX;
-
-
-typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
-    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
-    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
-    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
-    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
-    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
-} VkIndirectCommandsLayoutUsageFlagBitsNVX;
-typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
-
-typedef enum VkObjectEntryUsageFlagBitsNVX {
-    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
-    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
-    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
-} VkObjectEntryUsageFlagBitsNVX;
-typedef VkFlags VkObjectEntryUsageFlagsNVX;
-
-typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkBool32           computeBindingPointSupport;
-} VkDeviceGeneratedCommandsFeaturesNVX;
-
-typedef struct VkDeviceGeneratedCommandsLimitsNVX {
-    VkStructureType    sType;
-    const void*        pNext;
-    uint32_t           maxIndirectCommandsLayoutTokenCount;
-    uint32_t           maxObjectEntryCounts;
-    uint32_t           minSequenceCountBufferOffsetAlignment;
-    uint32_t           minSequenceIndexBufferOffsetAlignment;
-    uint32_t           minCommandsTokenBufferOffsetAlignment;
-} VkDeviceGeneratedCommandsLimitsNVX;
-
-typedef struct VkIndirectCommandsTokenNVX {
-    VkIndirectCommandsTokenTypeNVX    tokenType;
-    VkBuffer                          buffer;
-    VkDeviceSize                      offset;
-} VkIndirectCommandsTokenNVX;
-
-typedef struct VkIndirectCommandsLayoutTokenNVX {
-    VkIndirectCommandsTokenTypeNVX    tokenType;
-    uint32_t                          bindingUnit;
-    uint32_t                          dynamicCount;
-    uint32_t                          divisor;
-} VkIndirectCommandsLayoutTokenNVX;
-
-typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
-    VkStructureType                            sType;
-    const void*                                pNext;
-    VkPipelineBindPoint                        pipelineBindPoint;
-    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
-    uint32_t                                   tokenCount;
-    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
-} VkIndirectCommandsLayoutCreateInfoNVX;
-
-typedef struct VkCmdProcessCommandsInfoNVX {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    VkObjectTableNVX                     objectTable;
-    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
-    uint32_t                             indirectCommandsTokenCount;
-    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
-    uint32_t                             maxSequencesCount;
-    VkCommandBuffer                      targetCommandBuffer;
-    VkBuffer                             sequencesCountBuffer;
-    VkDeviceSize                         sequencesCountOffset;
-    VkBuffer                             sequencesIndexBuffer;
-    VkDeviceSize                         sequencesIndexOffset;
-} VkCmdProcessCommandsInfoNVX;
-
-typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkObjectTableNVX               objectTable;
-    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
-    uint32_t                       maxSequencesCount;
-} VkCmdReserveSpaceForCommandsInfoNVX;
-
-typedef struct VkObjectTableCreateInfoNVX {
-    VkStructureType                      sType;
-    const void*                          pNext;
-    uint32_t                             objectCount;
-    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
-    const uint32_t*                      pObjectEntryCounts;
-    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
-    uint32_t                             maxUniformBuffersPerDescriptor;
-    uint32_t                             maxStorageBuffersPerDescriptor;
-    uint32_t                             maxStorageImagesPerDescriptor;
-    uint32_t                             maxSampledImagesPerDescriptor;
-    uint32_t                             maxPipelineLayouts;
-} VkObjectTableCreateInfoNVX;
-
-typedef struct VkObjectTableEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-} VkObjectTableEntryNVX;
-
-typedef struct VkObjectTablePipelineEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-    VkPipeline                    pipeline;
-} VkObjectTablePipelineEntryNVX;
-
-typedef struct VkObjectTableDescriptorSetEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-    VkPipelineLayout              pipelineLayout;
-    VkDescriptorSet               descriptorSet;
-} VkObjectTableDescriptorSetEntryNVX;
-
-typedef struct VkObjectTableVertexBufferEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-    VkBuffer                      buffer;
-} VkObjectTableVertexBufferEntryNVX;
-
-typedef struct VkObjectTableIndexBufferEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-    VkBuffer                      buffer;
-    VkIndexType                   indexType;
-} VkObjectTableIndexBufferEntryNVX;
-
-typedef struct VkObjectTablePushConstantEntryNVX {
-    VkObjectEntryTypeNVX          type;
-    VkObjectEntryUsageFlagsNVX    flags;
-    VkPipelineLayout              pipelineLayout;
-    VkShaderStageFlags            stageFlags;
-} VkObjectTablePushConstantEntryNVX;
-
-
-typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
-typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
-typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
-typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
-typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
-    VkCommandBuffer                             commandBuffer,
-    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
-
-VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
-    VkCommandBuffer                             commandBuffer,
-    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
-    VkDevice                                    device,
-    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
-    VkDevice                                    device,
-    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
-    VkDevice                                    device,
-    const VkObjectTableCreateInfoNVX*           pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkObjectTableNVX*                           pObjectTable);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    uint32_t                                    objectCount,
-    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
-    const uint32_t*                             pObjectIndices);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
-    VkDevice                                    device,
-    VkObjectTableNVX                            objectTable,
-    uint32_t                                    objectCount,
-    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
-    const uint32_t*                             pObjectIndices);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
-    VkPhysicalDevice                            physicalDevice,
-    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
-    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+#include <wayland-client.h>
+#include "vulkan_wayland.h"
 #endif
 
-#define VK_NV_clip_space_w_scaling 1
-#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
-#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
 
-typedef struct VkViewportWScalingNV {
-    float    xcoeff;
-    float    ycoeff;
-} VkViewportWScalingNV;
-
-typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
-    VkStructureType                sType;
-    const void*                    pNext;
-    VkBool32                       viewportWScalingEnable;
-    uint32_t                       viewportCount;
-    const VkViewportWScalingNV*    pViewportWScalings;
-} VkPipelineViewportWScalingStateCreateInfoNV;
-
-
-typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstViewport,
-    uint32_t                                    viewportCount,
-    const VkViewportWScalingNV*                 pViewportWScalings);
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+#include <windows.h>
+#include "vulkan_win32.h"
 #endif
 
-#define VK_EXT_direct_mode_display 1
-#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
-#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
 
-typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
-    VkPhysicalDevice                            physicalDevice,
-    VkDisplayKHR                                display);
+#ifdef VK_USE_PLATFORM_XCB_KHR
+#include <xcb/xcb.h>
+#include "vulkan_xcb.h"
 #endif
 
+
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+#include <X11/Xlib.h>
+#include "vulkan_xlib.h"
+#endif
+
+
 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-#define VK_EXT_acquire_xlib_display 1
+#include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
-
-#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
-#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
-
-typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
-typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
-    VkPhysicalDevice                            physicalDevice,
-    Display*                                    dpy,
-    VkDisplayKHR                                display);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
-    VkPhysicalDevice                            physicalDevice,
-    Display*                                    dpy,
-    RROutput                                    rrOutput,
-    VkDisplayKHR*                               pDisplay);
-#endif
-#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
-
-#define VK_EXT_display_surface_counter 1
-#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
-#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
-#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
-
-
-typedef enum VkSurfaceCounterFlagBitsEXT {
-    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
-    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkSurfaceCounterFlagBitsEXT;
-typedef VkFlags VkSurfaceCounterFlagsEXT;
-
-typedef struct VkSurfaceCapabilities2EXT {
-    VkStructureType                  sType;
-    void*                            pNext;
-    uint32_t                         minImageCount;
-    uint32_t                         maxImageCount;
-    VkExtent2D                       currentExtent;
-    VkExtent2D                       minImageExtent;
-    VkExtent2D                       maxImageExtent;
-    uint32_t                         maxImageArrayLayers;
-    VkSurfaceTransformFlagsKHR       supportedTransforms;
-    VkSurfaceTransformFlagBitsKHR    currentTransform;
-    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
-    VkImageUsageFlags                supportedUsageFlags;
-    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
-} VkSurfaceCapabilities2EXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
-    VkPhysicalDevice                            physicalDevice,
-    VkSurfaceKHR                                surface,
-    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
+#include "vulkan_xlib_xrandr.h"
 #endif
 
-#define VK_EXT_display_control 1
-#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
-#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
-
-
-typedef enum VkDisplayPowerStateEXT {
-    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
-    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
-    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
-    VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
-    VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
-    VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
-    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDisplayPowerStateEXT;
-
-typedef enum VkDeviceEventTypeEXT {
-    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
-    VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
-    VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
-    VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
-    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDeviceEventTypeEXT;
-
-typedef enum VkDisplayEventTypeEXT {
-    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
-    VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
-    VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
-    VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
-    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDisplayEventTypeEXT;
-
-typedef struct VkDisplayPowerInfoEXT {
-    VkStructureType           sType;
-    const void*               pNext;
-    VkDisplayPowerStateEXT    powerState;
-} VkDisplayPowerInfoEXT;
-
-typedef struct VkDeviceEventInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkDeviceEventTypeEXT    deviceEvent;
-} VkDeviceEventInfoEXT;
-
-typedef struct VkDisplayEventInfoEXT {
-    VkStructureType          sType;
-    const void*              pNext;
-    VkDisplayEventTypeEXT    displayEvent;
-} VkDisplayEventInfoEXT;
-
-typedef struct VkSwapchainCounterCreateInfoEXT {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkSurfaceCounterFlagsEXT    surfaceCounters;
-} VkSwapchainCounterCreateInfoEXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
-typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
-typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
-    VkDevice                                    device,
-    VkDisplayKHR                                display,
-    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
-    VkDevice                                    device,
-    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFence*                                    pFence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
-    VkDevice                                    device,
-    VkDisplayKHR                                display,
-    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFence*                                    pFence);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    VkSurfaceCounterFlagBitsEXT                 counter,
-    uint64_t*                                   pCounterValue);
-#endif
-
-#define VK_GOOGLE_display_timing 1
-#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
-#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
-
-typedef struct VkRefreshCycleDurationGOOGLE {
-    uint64_t    refreshDuration;
-} VkRefreshCycleDurationGOOGLE;
-
-typedef struct VkPastPresentationTimingGOOGLE {
-    uint32_t    presentID;
-    uint64_t    desiredPresentTime;
-    uint64_t    actualPresentTime;
-    uint64_t    earliestPresentTime;
-    uint64_t    presentMargin;
-} VkPastPresentationTimingGOOGLE;
-
-typedef struct VkPresentTimeGOOGLE {
-    uint32_t    presentID;
-    uint64_t    desiredPresentTime;
-} VkPresentTimeGOOGLE;
-
-typedef struct VkPresentTimesInfoGOOGLE {
-    VkStructureType               sType;
-    const void*                   pNext;
-    uint32_t                      swapchainCount;
-    const VkPresentTimeGOOGLE*    pTimes;
-} VkPresentTimesInfoGOOGLE;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
-    VkDevice                                    device,
-    VkSwapchainKHR                              swapchain,
-    uint32_t*                                   pPresentationTimingCount,
-    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
-#endif
-
-#define VK_NV_sample_mask_override_coverage 1
-#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
-#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
-
-
-#define VK_NV_geometry_shader_passthrough 1
-#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
-#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
-
-
-#define VK_NV_viewport_array2 1
-#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
-#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
-
-
-#define VK_NVX_multiview_per_view_attributes 1
-#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
-#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
-
-typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           perViewPositionAllComponents;
-} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
-
-
-#define VK_NV_viewport_swizzle 1
-#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
-#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
-
-
-typedef enum VkViewportCoordinateSwizzleNV {
-    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
-    VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
-    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
-} VkViewportCoordinateSwizzleNV;
-
-typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
-
-typedef struct VkViewportSwizzleNV {
-    VkViewportCoordinateSwizzleNV    x;
-    VkViewportCoordinateSwizzleNV    y;
-    VkViewportCoordinateSwizzleNV    z;
-    VkViewportCoordinateSwizzleNV    w;
-} VkViewportSwizzleNV;
-
-typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
-    uint32_t                                       viewportCount;
-    const VkViewportSwizzleNV*                     pViewportSwizzles;
-} VkPipelineViewportSwizzleStateCreateInfoNV;
-
-
-
-#define VK_EXT_discard_rectangles 1
-#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
-#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
-
-
-typedef enum VkDiscardRectangleModeEXT {
-    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
-    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
-    VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
-    VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
-    VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
-    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkDiscardRectangleModeEXT;
-
-typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
-
-typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           maxDiscardRectangles;
-} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
-
-typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
-    VkStructureType                                  sType;
-    const void*                                      pNext;
-    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
-    VkDiscardRectangleModeEXT                        discardRectangleMode;
-    uint32_t                                         discardRectangleCount;
-    const VkRect2D*                                  pDiscardRectangles;
-} VkPipelineDiscardRectangleStateCreateInfoEXT;
-
-
-typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
-    VkCommandBuffer                             commandBuffer,
-    uint32_t                                    firstDiscardRectangle,
-    uint32_t                                    discardRectangleCount,
-    const VkRect2D*                             pDiscardRectangles);
-#endif
-
-#define VK_EXT_conservative_rasterization 1
-#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
-#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
-
-
-typedef enum VkConservativeRasterizationModeEXT {
-    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
-    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
-    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
-    VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
-    VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,
-    VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1),
-    VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkConservativeRasterizationModeEXT;
-
-typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
-
-typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    float              primitiveOverestimationSize;
-    float              maxExtraPrimitiveOverestimationSize;
-    float              extraPrimitiveOverestimationSizeGranularity;
-    VkBool32           primitiveUnderestimation;
-    VkBool32           conservativePointAndLineRasterization;
-    VkBool32           degenerateTrianglesRasterized;
-    VkBool32           degenerateLinesRasterized;
-    VkBool32           fullyCoveredFragmentShaderInputVariable;
-    VkBool32           conservativeRasterizationPostDepthCoverage;
-} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
-
-typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
-    VkStructureType                                           sType;
-    const void*                                               pNext;
-    VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
-    VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
-    float                                                     extraPrimitiveOverestimationSize;
-} VkPipelineRasterizationConservativeStateCreateInfoEXT;
-
-
-
-#define VK_EXT_swapchain_colorspace 1
-#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3
-#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
-
-
-#define VK_EXT_hdr_metadata 1
-#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
-#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
-
-typedef struct VkXYColorEXT {
-    float    x;
-    float    y;
-} VkXYColorEXT;
-
-typedef struct VkHdrMetadataEXT {
-    VkStructureType    sType;
-    const void*        pNext;
-    VkXYColorEXT       displayPrimaryRed;
-    VkXYColorEXT       displayPrimaryGreen;
-    VkXYColorEXT       displayPrimaryBlue;
-    VkXYColorEXT       whitePoint;
-    float              maxLuminance;
-    float              minLuminance;
-    float              maxContentLightLevel;
-    float              maxFrameAverageLightLevel;
-} VkHdrMetadataEXT;
-
-
-typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
-    VkDevice                                    device,
-    uint32_t                                    swapchainCount,
-    const VkSwapchainKHR*                       pSwapchains,
-    const VkHdrMetadataEXT*                     pMetadata);
-#endif
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-#define VK_MVK_ios_surface 1
-#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
-#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
-
-typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
-
-typedef struct VkIOSSurfaceCreateInfoMVK {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkIOSSurfaceCreateFlagsMVK    flags;
-    const void*                   pView;
-} VkIOSSurfaceCreateInfoMVK;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-#endif
-#endif /* VK_USE_PLATFORM_IOS_MVK */
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-#define VK_MVK_macos_surface 1
-#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
-#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
-
-typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
-
-typedef struct VkMacOSSurfaceCreateInfoMVK {
-    VkStructureType                 sType;
-    const void*                     pNext;
-    VkMacOSSurfaceCreateFlagsMVK    flags;
-    const void*                     pView;
-} VkMacOSSurfaceCreateInfoMVK;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
-    VkInstance                                  instance,
-    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkSurfaceKHR*                               pSurface);
-#endif
-#endif /* VK_USE_PLATFORM_MACOS_MVK */
-
-#define VK_EXT_external_memory_dma_buf 1
-#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
-#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
-
-
-#define VK_EXT_queue_family_foreign 1
-#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
-#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
-#define VK_QUEUE_FAMILY_FOREIGN_EXT       (~0U-2)
-
-
-#define VK_EXT_sampler_filter_minmax 1
-#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
-#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
-
-
-typedef enum VkSamplerReductionModeEXT {
-    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
-    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
-    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
-    VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
-    VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
-    VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
-    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkSamplerReductionModeEXT;
-
-typedef struct VkSamplerReductionModeCreateInfoEXT {
-    VkStructureType              sType;
-    const void*                  pNext;
-    VkSamplerReductionModeEXT    reductionMode;
-} VkSamplerReductionModeCreateInfoEXT;
-
-typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           filterMinmaxSingleComponentFormats;
-    VkBool32           filterMinmaxImageComponentMapping;
-} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-
-
-
-#define VK_AMD_gpu_shader_int16 1
-#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
-#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
-
-
-#define VK_AMD_mixed_attachment_samples 1
-#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
-#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
-
-
-#define VK_AMD_shader_fragment_mask 1
-#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
-#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
-
-
-#define VK_EXT_shader_stencil_export 1
-#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
-#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
-
-
-#define VK_EXT_sample_locations 1
-#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
-#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
-
-typedef struct VkSampleLocationEXT {
-    float    x;
-    float    y;
-} VkSampleLocationEXT;
-
-typedef struct VkSampleLocationsInfoEXT {
-    VkStructureType               sType;
-    const void*                   pNext;
-    VkSampleCountFlagBits         sampleLocationsPerPixel;
-    VkExtent2D                    sampleLocationGridSize;
-    uint32_t                      sampleLocationsCount;
-    const VkSampleLocationEXT*    pSampleLocations;
-} VkSampleLocationsInfoEXT;
-
-typedef struct VkAttachmentSampleLocationsEXT {
-    uint32_t                    attachmentIndex;
-    VkSampleLocationsInfoEXT    sampleLocationsInfo;
-} VkAttachmentSampleLocationsEXT;
-
-typedef struct VkSubpassSampleLocationsEXT {
-    uint32_t                    subpassIndex;
-    VkSampleLocationsInfoEXT    sampleLocationsInfo;
-} VkSubpassSampleLocationsEXT;
-
-typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    uint32_t                                 attachmentInitialSampleLocationsCount;
-    const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
-    uint32_t                                 postSubpassSampleLocationsCount;
-    const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
-} VkRenderPassSampleLocationsBeginInfoEXT;
-
-typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkBool32                    sampleLocationsEnable;
-    VkSampleLocationsInfoEXT    sampleLocationsInfo;
-} VkPipelineSampleLocationsStateCreateInfoEXT;
-
-typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
-    VkStructureType       sType;
-    void*                 pNext;
-    VkSampleCountFlags    sampleLocationSampleCounts;
-    VkExtent2D            maxSampleLocationGridSize;
-    float                 sampleLocationCoordinateRange[2];
-    uint32_t              sampleLocationSubPixelBits;
-    VkBool32              variableSampleLocations;
-} VkPhysicalDeviceSampleLocationsPropertiesEXT;
-
-typedef struct VkMultisamplePropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkExtent2D         maxSampleLocationGridSize;
-} VkMultisamplePropertiesEXT;
-
-
-typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
-typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
-    VkCommandBuffer                             commandBuffer,
-    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
-
-VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
-    VkPhysicalDevice                            physicalDevice,
-    VkSampleCountFlagBits                       samples,
-    VkMultisamplePropertiesEXT*                 pMultisampleProperties);
-#endif
-
-#define VK_EXT_blend_operation_advanced 1
-#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
-#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
-
-
-typedef enum VkBlendOverlapEXT {
-    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
-    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
-    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
-    VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
-    VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
-    VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
-    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkBlendOverlapEXT;
-
-typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkBool32           advancedBlendCoherentOperations;
-} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-
-typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           advancedBlendMaxColorAttachments;
-    VkBool32           advancedBlendIndependentBlend;
-    VkBool32           advancedBlendNonPremultipliedSrcColor;
-    VkBool32           advancedBlendNonPremultipliedDstColor;
-    VkBool32           advancedBlendCorrelatedOverlap;
-    VkBool32           advancedBlendAllOperations;
-} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-
-typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
-    VkStructureType      sType;
-    const void*          pNext;
-    VkBool32             srcPremultiplied;
-    VkBool32             dstPremultiplied;
-    VkBlendOverlapEXT    blendOverlap;
-} VkPipelineColorBlendAdvancedStateCreateInfoEXT;
-
-
-
-#define VK_NV_fragment_coverage_to_color 1
-#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
-#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
-
-typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
-
-typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
-    VkStructureType                                sType;
-    const void*                                    pNext;
-    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
-    VkBool32                                       coverageToColorEnable;
-    uint32_t                                       coverageToColorLocation;
-} VkPipelineCoverageToColorStateCreateInfoNV;
-
-
-
-#define VK_NV_framebuffer_mixed_samples 1
-#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
-#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
-
-
-typedef enum VkCoverageModulationModeNV {
-    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
-    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
-    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
-    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
-    VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
-    VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
-    VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
-    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
-} VkCoverageModulationModeNV;
-
-typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
-
-typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
-    VkStructureType                                   sType;
-    const void*                                       pNext;
-    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
-    VkCoverageModulationModeNV                        coverageModulationMode;
-    VkBool32                                          coverageModulationTableEnable;
-    uint32_t                                          coverageModulationTableCount;
-    const float*                                      pCoverageModulationTable;
-} VkPipelineCoverageModulationStateCreateInfoNV;
-
-
-
-#define VK_NV_fill_rectangle 1
-#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
-#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
-
-
-#define VK_EXT_post_depth_coverage 1
-#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
-#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
-
-
-#define VK_EXT_validation_cache 1
-VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
-
-#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
-#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
-#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT
-
-
-typedef enum VkValidationCacheHeaderVersionEXT {
-    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
-    VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
-    VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
-    VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1),
-    VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkValidationCacheHeaderVersionEXT;
-
-typedef VkFlags VkValidationCacheCreateFlagsEXT;
-
-typedef struct VkValidationCacheCreateInfoEXT {
-    VkStructureType                    sType;
-    const void*                        pNext;
-    VkValidationCacheCreateFlagsEXT    flags;
-    size_t                             initialDataSize;
-    const void*                        pInitialData;
-} VkValidationCacheCreateInfoEXT;
-
-typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
-    VkStructureType         sType;
-    const void*             pNext;
-    VkValidationCacheEXT    validationCache;
-} VkShaderModuleValidationCacheCreateInfoEXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
-typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
-typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
-typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
-    VkDevice                                    device,
-    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkValidationCacheEXT*                       pValidationCache);
-
-VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        validationCache,
-    const VkAllocationCallbacks*                pAllocator);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        dstCache,
-    uint32_t                                    srcCacheCount,
-    const VkValidationCacheEXT*                 pSrcCaches);
-
-VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
-    VkDevice                                    device,
-    VkValidationCacheEXT                        validationCache,
-    size_t*                                     pDataSize,
-    void*                                       pData);
-#endif
-
-#define VK_EXT_shader_viewport_index_layer 1
-#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
-#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
-
-
-#define VK_EXT_global_priority 1
-#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
-#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
-
-
-typedef enum VkQueueGlobalPriorityEXT {
-    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
-    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
-    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
-    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
-    VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
-    VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT,
-    VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1),
-    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkQueueGlobalPriorityEXT;
-
-typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
-    VkStructureType             sType;
-    const void*                 pNext;
-    VkQueueGlobalPriorityEXT    globalPriority;
-} VkDeviceQueueGlobalPriorityCreateInfoEXT;
-
-
-
-#define VK_EXT_external_memory_host 1
-#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
-#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
-
-typedef struct VkImportMemoryHostPointerInfoEXT {
-    VkStructureType                          sType;
-    const void*                              pNext;
-    VkExternalMemoryHandleTypeFlagBitsKHR    handleType;
-    void*                                    pHostPointer;
-} VkImportMemoryHostPointerInfoEXT;
-
-typedef struct VkMemoryHostPointerPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    uint32_t           memoryTypeBits;
-} VkMemoryHostPointerPropertiesEXT;
-
-typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
-    VkStructureType    sType;
-    void*              pNext;
-    VkDeviceSize       minImportedHostPointerAlignment;
-} VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
-
-
-typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
-
-#ifndef VK_NO_PROTOTYPES
-VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
-    VkDevice                                    device,
-    VkExternalMemoryHandleTypeFlagBitsKHR       handleType,
-    const void*                                 pHostPointer,
-    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+#endif // VULKAN_H_
diff --git a/third_party/vulkan/vulkan.hpp b/third_party/vulkan/vulkan.hpp
deleted file mode 100644
index 5b7bc7203..000000000
--- a/third_party/vulkan/vulkan.hpp
+++ /dev/null
@@ -1,35695 +0,0 @@
-// Copyright (c) 2015-2018 The Khronos Group Inc.
-// 
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// 
-//     http://www.apache.org/licenses/LICENSE-2.0
-// 
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// This header is generated from the Khronos Vulkan XML API Registry.
-
-#ifndef VULKAN_HPP
-#define VULKAN_HPP
-
-#include <algorithm>
-#include <array>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <initializer_list>
-#include <string>
-#include <system_error>
-#include <tuple>
-#include <type_traits>
-#include <vulkan/vulkan.h>
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-# include <memory>
-# include <vector>
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-static_assert( VK_HEADER_VERSION ==  68 , "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 defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
-# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION )
-#  define VULKAN_HPP_TYPESAFE_CONVERSION
-# endif
-#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 __forceinline
-# 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(VULKAN_HPP_NAMESPACE)
-#define VULKAN_HPP_NAMESPACE vk
-#endif
-
-namespace VULKAN_HPP_NAMESPACE
-{
-
-  template <typename FlagBitsType> struct FlagTraits
-  {
-    enum { allFlags = 0 };
-  };
-
-  template <typename BitType, typename MaskType = VkFlags>
-  class Flags
-  {
-  public:
-    Flags()
-      : m_mask(0)
-    {
-    }
-
-    Flags(BitType bit)
-      : m_mask(static_cast<MaskType>(bit))
-    {
-    }
-
-    Flags(Flags<BitType> const& rhs)
-      : m_mask(rhs.m_mask)
-    {
-    }
-
-    explicit Flags(MaskType flags)
-      : m_mask(flags)
-    {
-    }
-
-    Flags<BitType> & operator=(Flags<BitType> const& rhs)
-    {
-      m_mask = rhs.m_mask;
-      return *this;
-    }
-
-    Flags<BitType> & operator|=(Flags<BitType> const& rhs)
-    {
-      m_mask |= rhs.m_mask;
-      return *this;
-    }
-
-    Flags<BitType> & operator&=(Flags<BitType> const& rhs)
-    {
-      m_mask &= rhs.m_mask;
-      return *this;
-    }
-
-    Flags<BitType> & operator^=(Flags<BitType> const& rhs)
-    {
-      m_mask ^= rhs.m_mask;
-      return *this;
-    }
-
-    Flags<BitType> operator|(Flags<BitType> const& rhs) const
-    {
-      Flags<BitType> result(*this);
-      result |= rhs;
-      return result;
-    }
-
-    Flags<BitType> operator&(Flags<BitType> const& rhs) const
-    {
-      Flags<BitType> result(*this);
-      result &= rhs;
-      return result;
-    }
-
-    Flags<BitType> operator^(Flags<BitType> const& rhs) const
-    {
-      Flags<BitType> result(*this);
-      result ^= rhs;
-      return result;
-    }
-
-    bool operator!() const
-    {
-      return !m_mask;
-    }
-
-    Flags<BitType> operator~() const
-    {
-      Flags<BitType> result(*this);
-      result.m_mask ^= FlagTraits<BitType>::allFlags;
-      return result;
-    }
-
-    bool operator==(Flags<BitType> const& rhs) const
-    {
-      return m_mask == rhs.m_mask;
-    }
-
-    bool operator!=(Flags<BitType> const& rhs) const
-    {
-      return m_mask != rhs.m_mask;
-    }
-
-    explicit operator bool() const
-    {
-      return !!m_mask;
-    }
-
-    explicit operator MaskType() const
-    {
-        return m_mask;
-    }
-
-  private:
-    MaskType  m_mask;
-  };
-
-  template <typename BitType>
-  Flags<BitType> operator|(BitType bit, Flags<BitType> const& flags)
-  {
-    return flags | bit;
-  }
-
-  template <typename BitType>
-  Flags<BitType> operator&(BitType bit, Flags<BitType> const& flags)
-  {
-    return flags & bit;
-  }
-
-  template <typename BitType>
-  Flags<BitType> operator^(BitType bit, Flags<BitType> const& flags)
-  {
-    return flags ^ bit;
-  }
-
-
-  template <typename RefType>
-  class Optional
-  {
-  public:
-    Optional(RefType & reference) { m_ptr = &reference; }
-    Optional(RefType * ptr) { m_ptr = ptr; }
-    Optional(std::nullptr_t) { m_ptr = nullptr; }
-
-    operator RefType*() const { return m_ptr; }
-    RefType const* operator->() const { return m_ptr; }
-    explicit operator bool() const { return !!m_ptr; }
-
-  private:
-    RefType *m_ptr;
-  };
-
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  class ArrayProxy
-  {
-  public:
-    ArrayProxy(std::nullptr_t)
-      : m_count(0)
-      , m_ptr(nullptr)
-    {}
-
-    ArrayProxy(T & ptr)
-      : m_count(1)
-      , m_ptr(&ptr)
-    {}
-
-    ArrayProxy(uint32_t count, T * ptr)
-      : m_count(count)
-      , m_ptr(ptr)
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> & data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <size_t N>
-    ArrayProxy(std::array<typename std::remove_const<T>::type, N> const& data)
-      : m_count(N)
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> & data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    template <class Allocator = std::allocator<typename std::remove_const<T>::type>>
-    ArrayProxy(std::vector<typename std::remove_const<T>::type, Allocator> const& data)
-      : m_count(static_cast<uint32_t>(data.size()))
-      , m_ptr(data.data())
-    {}
-
-    ArrayProxy(std::initializer_list<T> const& data)
-      : m_count(static_cast<uint32_t>(data.end() - data.begin()))
-      , m_ptr(data.begin())
-    {}
-
-    const T * begin() const
-    {
-      return m_ptr;
-    }
-
-    const T * end() const
-    {
-      return m_ptr + m_count;
-    }
-
-    const T & front() const
-    {
-      assert(m_count && m_ptr);
-      return *m_ptr;
-    }
-
-    const T & back() const
-    {
-      assert(m_count && m_ptr);
-      return *(m_ptr + m_count - 1);
-    }
-
-    bool empty() const
-    {
-      return (m_count == 0);
-    }
-
-    uint32_t size() const
-    {
-      return m_count;
-    }
-
-    T * data() const
-    {
-      return m_ptr;
-    }
-
-  private:
-    uint32_t  m_count;
-    T *       m_ptr;
-  };
-#endif
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-
-  template <typename Type> class UniqueHandleTraits;
-
-  template <typename Type>
-  class UniqueHandle : public UniqueHandleTraits<Type>::deleter
-  {
-  private:
-    using Deleter = typename UniqueHandleTraits<Type>::deleter;
-  public:
-    explicit UniqueHandle( Type const& value = Type(), Deleter const& deleter = Deleter() )
-      : Deleter( deleter)
-      , m_value( value )
-    {}
-
-    UniqueHandle( UniqueHandle const& ) = delete;
-
-    UniqueHandle( UniqueHandle && other )
-      : Deleter( std::move( static_cast<Deleter&>( other ) ) )
-      , m_value( other.release() )
-    {}
-
-    ~UniqueHandle()
-    {
-      if ( m_value ) this->destroy( m_value );
-    }
-
-    UniqueHandle & operator=( UniqueHandle const& ) = delete;
-
-    UniqueHandle & operator=( UniqueHandle && other )
-    {
-      reset( other.release() );
-      *static_cast<Deleter*>(this) = std::move( static_cast<Deleter&>(other) );
-      return *this;
-    }
-
-    explicit operator bool() const
-    {
-      return m_value.operator bool();
-    }
-
-    Type const* operator->() const
-    {
-      return &m_value;
-    }
-
-    Type * operator->()
-    {
-      return &m_value;
-    }
-
-    Type const& operator*() const
-    {
-      return m_value;
-    }
-
-    Type & operator*()
-    {
-      return m_value;
-    }
-
-    const Type & get() const
-    {
-      return m_value;
-    }
-    
-    Type & get()
-    {
-      return m_value;
-    }
-
-    void reset( Type const& value = Type() )
-    {
-      if ( m_value != value )
-      {
-        if ( m_value ) this->destroy( m_value );
-        m_value = value;
-      }
-    }
-
-    Type release()
-    {
-      Type value = m_value;
-      m_value = nullptr;
-      return value;
-    }
-
-    void swap( UniqueHandle<Type> & rhs )
-    {
-      std::swap(m_value, rhs.m_value);
-      std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
-    }
-
-  private:
-    Type    m_value;
-  };
-
-  template <typename Type>
-  VULKAN_HPP_INLINE void swap( UniqueHandle<Type> & lhs, UniqueHandle<Type> & rhs )
-  {
-    lhs.swap( rhs );
-  }
-#endif
-
-
-  template <typename X, typename Y> struct isStructureChainValid { enum { value = false }; };
-
-  template <class Element>
-  class StructureChainElement
-  {
-  public:
-    explicit operator Element&() { return value; }
-    explicit operator const Element&() const { return value; }
-  private:
-    Element value;
-  };
-
-  template<typename ...StructureElements>
-  class StructureChain : private StructureChainElement<StructureElements>...
-  {
-  public:
-    StructureChain()
-    {
-      link<StructureElements...>();  
-    }
-
-    StructureChain(StructureChain const &rhs)
-    {
-      linkAndCopy<StructureElements...>(rhs);
-    }
-
-    StructureChain& operator=(StructureChain const &rhs)
-    {
-      linkAndCopy<StructureElements...>(rhs);
-      return *this;
-    }
-
-    template<typename ClassType> ClassType& get() { return static_cast<ClassType&>(*this);}
-
-  private:
-    template<typename X>
-    void link()
-    {
-    }
-
-    template<typename X, typename Y, typename ...Z>
-    void link()
-    {
-      static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
-      X& x = static_cast<X&>(*this);
-      Y& y = static_cast<Y&>(*this);
-      x.pNext = &y;
-      link<Y, Z...>();
-    }
-
-    template<typename X>
-    void linkAndCopy(StructureChain const &rhs)
-    {
-      static_cast<X&>(*this) = static_cast<X const &>(rhs);
-    }
-
-    template<typename X, typename Y, typename ...Z>
-    void linkAndCopy(StructureChain const &rhs)
-    {
-      static_assert(isStructureChainValid<X,Y>::value, "The structure chain is not valid!");
-      X& x = static_cast<X&>(*this);
-      Y& y = static_cast<Y&>(*this);
-      x = static_cast<X const &>(rhs);
-      x.pNext = &y;
-      linkAndCopy<Y, Z...>(rhs);
-    }
-
-};
-  enum class Result
-  {
-    eSuccess = VK_SUCCESS,
-    eNotReady = VK_NOT_READY,
-    eTimeout = VK_TIMEOUT,
-    eEventSet = VK_EVENT_SET,
-    eEventReset = VK_EVENT_RESET,
-    eIncomplete = VK_INCOMPLETE,
-    eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY,
-    eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY,
-    eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED,
-    eErrorDeviceLost = VK_ERROR_DEVICE_LOST,
-    eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED,
-    eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT,
-    eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT,
-    eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT,
-    eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER,
-    eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS,
-    eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
-    eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
-    eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR,
-    eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR,
-    eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
-    eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
-    eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
-    eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
-    eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
-    eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
-    eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR,
-    eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT
-  };
-
-  VULKAN_HPP_INLINE std::string to_string(Result value)
-  {
-    switch (value)
-    {
-    case Result::eSuccess: return "Success";
-    case Result::eNotReady: return "NotReady";
-    case Result::eTimeout: return "Timeout";
-    case Result::eEventSet: return "EventSet";
-    case Result::eEventReset: return "EventReset";
-    case Result::eIncomplete: return "Incomplete";
-    case Result::eErrorOutOfHostMemory: return "ErrorOutOfHostMemory";
-    case Result::eErrorOutOfDeviceMemory: return "ErrorOutOfDeviceMemory";
-    case Result::eErrorInitializationFailed: return "ErrorInitializationFailed";
-    case Result::eErrorDeviceLost: return "ErrorDeviceLost";
-    case Result::eErrorMemoryMapFailed: return "ErrorMemoryMapFailed";
-    case Result::eErrorLayerNotPresent: return "ErrorLayerNotPresent";
-    case Result::eErrorExtensionNotPresent: return "ErrorExtensionNotPresent";
-    case Result::eErrorFeatureNotPresent: return "ErrorFeatureNotPresent";
-    case Result::eErrorIncompatibleDriver: return "ErrorIncompatibleDriver";
-    case Result::eErrorTooManyObjects: return "ErrorTooManyObjects";
-    case Result::eErrorFormatNotSupported: return "ErrorFormatNotSupported";
-    case Result::eErrorFragmentedPool: return "ErrorFragmentedPool";
-    case Result::eErrorSurfaceLostKHR: return "ErrorSurfaceLostKHR";
-    case Result::eErrorNativeWindowInUseKHR: return "ErrorNativeWindowInUseKHR";
-    case Result::eSuboptimalKHR: return "SuboptimalKHR";
-    case Result::eErrorOutOfDateKHR: return "ErrorOutOfDateKHR";
-    case Result::eErrorIncompatibleDisplayKHR: return "ErrorIncompatibleDisplayKHR";
-    case Result::eErrorValidationFailedEXT: return "ErrorValidationFailedEXT";
-    case Result::eErrorInvalidShaderNV: return "ErrorInvalidShaderNV";
-    case Result::eErrorOutOfPoolMemoryKHR: return "ErrorOutOfPoolMemoryKHR";
-    case Result::eErrorInvalidExternalHandleKHR: return "ErrorInvalidExternalHandleKHR";
-    case Result::eErrorNotPermittedEXT: return "ErrorNotPermittedEXT";
-    default: return "invalid";
-    }
-  }
-
-#ifndef VULKAN_HPP_NO_EXCEPTIONS
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class ErrorCategoryImpl : public std::error_category
-  {
-    public:
-    virtual const char* name() const noexcept override { return "VULKAN_HPP_NAMESPACE::Result"; }
-    virtual std::string message(int ev) const override { return to_string(static_cast<Result>(ev)); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  VULKAN_HPP_INLINE const std::error_category& errorCategory()
-  {
-    static ErrorCategoryImpl instance;
-    return instance;
-  }
-
-  VULKAN_HPP_INLINE std::error_code make_error_code(Result e)
-  {
-    return std::error_code(static_cast<int>(e), errorCategory());
-  }
-
-  VULKAN_HPP_INLINE std::error_condition make_error_condition(Result e)
-  {
-    return std::error_condition(static_cast<int>(e), errorCategory());
-  }
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# define noexcept _NOEXCEPT
-#endif
-
-  class Error
-  {
-    public:
-    virtual ~Error() = default;
-
-    virtual const char* what() const 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 ~LogicError() = default;
-
-    virtual const char* what() const 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 ~SystemError() = default;
-
-    virtual const char* what() const noexcept { return std::system_error::what(); }
-  };
-
-#if defined(_MSC_VER) && (_MSC_VER == 1800)
-# undef noexcept
-#endif
-
-  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 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 OutOfPoolMemoryKHRError : public SystemError
-  {
-  public:
-    OutOfPoolMemoryKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {}
-    OutOfPoolMemoryKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorOutOfPoolMemoryKHR ), message ) {}
-  };
-  class InvalidExternalHandleKHRError : public SystemError
-  {
-  public:
-    InvalidExternalHandleKHRError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {}
-    InvalidExternalHandleKHRError( char const * message )
-      : SystemError( make_error_code( Result::eErrorInvalidExternalHandleKHR ), message ) {}
-  };
-  class NotPermittedEXTError : public SystemError
-  {
-  public:
-    NotPermittedEXTError( std::string const& message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-    NotPermittedEXTError( char const * message )
-      : SystemError( make_error_code( Result::eErrorNotPermittedEXT ), message ) {}
-  };
-
-  VULKAN_HPP_INLINE 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::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::eErrorOutOfPoolMemoryKHR: throw OutOfPoolMemoryKHRError ( message );
-    case Result::eErrorInvalidExternalHandleKHR: throw InvalidExternalHandleKHRError ( message );
-    case Result::eErrorNotPermittedEXT: throw NotPermittedEXTError ( message );
-    default: throw SystemError( make_error_code( result ) );
-    }
-  }
-#endif
-} // namespace VULKAN_HPP_NAMESPACE
-
-namespace std
-{
-  template <>
-  struct is_error_code_enum<VULKAN_HPP_NAMESPACE::Result> : public true_type
-  {};
-}
-
-namespace VULKAN_HPP_NAMESPACE
-{
-
-  template <typename T>
-  struct ResultValue
-  {
-    ResultValue( Result r, T & v )
-      : result( r )
-      , value( v )
-    {}
-
-    ResultValue( Result r, T && v )
-      : result( r )
-      , value( std::move( v ) )
-    {}
-
-    Result  result;
-    T       value;
-
-    operator std::tuple<Result&, T&>() { return std::tuple<Result&, T&>(result, value); }
-  };
-
-  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
-  };
-
-  VULKAN_HPP_INLINE ResultValueType<void>::type createResultValue( Result result, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( result == Result::eSuccess );
-    return result;
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-#endif
-  }
-
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<T>::type createResultValue( Result result, T & data, char const * message )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( result == Result::eSuccess );
-    return ResultValue<T>( result, data );
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-    return data;
-#endif
-  }
-
-  VULKAN_HPP_INLINE Result createResultValue( Result result, char const * message, std::initializer_list<Result> successCodes )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( 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 result;
-  }
-
-  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
-    assert( 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, data );
-  }
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename T>
-  VULKAN_HPP_INLINE typename ResultValueType<UniqueHandle<T>>::type createResultValue( Result result, T & data, char const * message, typename UniqueHandleTraits<T>::deleter const& deleter )
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( result == Result::eSuccess );
-    return ResultValue<UniqueHandle<T>>( result, UniqueHandle<T>(data, deleter) );
-#else
-    if ( result != Result::eSuccess )
-    {
-      throwResultException( result, message );
-    }
-    return UniqueHandle<T>(data, deleter);
-#endif
-  }
-#endif
-
-  using SampleMask = uint32_t;
-
-  using Bool32 = uint32_t;
-
-  using DeviceSize = uint64_t;
-
-  enum class FramebufferCreateFlagBits
-  {
-  };
-
-  using FramebufferCreateFlags = Flags<FramebufferCreateFlagBits, VkFramebufferCreateFlags>;
-
-  enum class QueryPoolCreateFlagBits
-  {
-  };
-
-  using QueryPoolCreateFlags = Flags<QueryPoolCreateFlagBits, VkQueryPoolCreateFlags>;
-
-  enum class RenderPassCreateFlagBits
-  {
-  };
-
-  using RenderPassCreateFlags = Flags<RenderPassCreateFlagBits, VkRenderPassCreateFlags>;
-
-  enum class SamplerCreateFlagBits
-  {
-  };
-
-  using SamplerCreateFlags = Flags<SamplerCreateFlagBits, VkSamplerCreateFlags>;
-
-  enum class PipelineLayoutCreateFlagBits
-  {
-  };
-
-  using PipelineLayoutCreateFlags = Flags<PipelineLayoutCreateFlagBits, VkPipelineLayoutCreateFlags>;
-
-  enum class PipelineCacheCreateFlagBits
-  {
-  };
-
-  using PipelineCacheCreateFlags = Flags<PipelineCacheCreateFlagBits, VkPipelineCacheCreateFlags>;
-
-  enum class PipelineDepthStencilStateCreateFlagBits
-  {
-  };
-
-  using PipelineDepthStencilStateCreateFlags = Flags<PipelineDepthStencilStateCreateFlagBits, VkPipelineDepthStencilStateCreateFlags>;
-
-  enum class PipelineDynamicStateCreateFlagBits
-  {
-  };
-
-  using PipelineDynamicStateCreateFlags = Flags<PipelineDynamicStateCreateFlagBits, VkPipelineDynamicStateCreateFlags>;
-
-  enum class PipelineColorBlendStateCreateFlagBits
-  {
-  };
-
-  using PipelineColorBlendStateCreateFlags = Flags<PipelineColorBlendStateCreateFlagBits, VkPipelineColorBlendStateCreateFlags>;
-
-  enum class PipelineMultisampleStateCreateFlagBits
-  {
-  };
-
-  using PipelineMultisampleStateCreateFlags = Flags<PipelineMultisampleStateCreateFlagBits, VkPipelineMultisampleStateCreateFlags>;
-
-  enum class PipelineRasterizationStateCreateFlagBits
-  {
-  };
-
-  using PipelineRasterizationStateCreateFlags = Flags<PipelineRasterizationStateCreateFlagBits, VkPipelineRasterizationStateCreateFlags>;
-
-  enum class PipelineViewportStateCreateFlagBits
-  {
-  };
-
-  using PipelineViewportStateCreateFlags = Flags<PipelineViewportStateCreateFlagBits, VkPipelineViewportStateCreateFlags>;
-
-  enum class PipelineTessellationStateCreateFlagBits
-  {
-  };
-
-  using PipelineTessellationStateCreateFlags = Flags<PipelineTessellationStateCreateFlagBits, VkPipelineTessellationStateCreateFlags>;
-
-  enum class PipelineInputAssemblyStateCreateFlagBits
-  {
-  };
-
-  using PipelineInputAssemblyStateCreateFlags = Flags<PipelineInputAssemblyStateCreateFlagBits, VkPipelineInputAssemblyStateCreateFlags>;
-
-  enum class PipelineVertexInputStateCreateFlagBits
-  {
-  };
-
-  using PipelineVertexInputStateCreateFlags = Flags<PipelineVertexInputStateCreateFlagBits, VkPipelineVertexInputStateCreateFlags>;
-
-  enum class PipelineShaderStageCreateFlagBits
-  {
-  };
-
-  using PipelineShaderStageCreateFlags = Flags<PipelineShaderStageCreateFlagBits, VkPipelineShaderStageCreateFlags>;
-
-  enum class BufferViewCreateFlagBits
-  {
-  };
-
-  using BufferViewCreateFlags = Flags<BufferViewCreateFlagBits, VkBufferViewCreateFlags>;
-
-  enum class InstanceCreateFlagBits
-  {
-  };
-
-  using InstanceCreateFlags = Flags<InstanceCreateFlagBits, VkInstanceCreateFlags>;
-
-  enum class DeviceCreateFlagBits
-  {
-  };
-
-  using DeviceCreateFlags = Flags<DeviceCreateFlagBits, VkDeviceCreateFlags>;
-
-  enum class DeviceQueueCreateFlagBits
-  {
-  };
-
-  using DeviceQueueCreateFlags = Flags<DeviceQueueCreateFlagBits, VkDeviceQueueCreateFlags>;
-
-  enum class ImageViewCreateFlagBits
-  {
-  };
-
-  using ImageViewCreateFlags = Flags<ImageViewCreateFlagBits, VkImageViewCreateFlags>;
-
-  enum class SemaphoreCreateFlagBits
-  {
-  };
-
-  using SemaphoreCreateFlags = Flags<SemaphoreCreateFlagBits, VkSemaphoreCreateFlags>;
-
-  enum class ShaderModuleCreateFlagBits
-  {
-  };
-
-  using ShaderModuleCreateFlags = Flags<ShaderModuleCreateFlagBits, VkShaderModuleCreateFlags>;
-
-  enum class EventCreateFlagBits
-  {
-  };
-
-  using EventCreateFlags = Flags<EventCreateFlagBits, VkEventCreateFlags>;
-
-  enum class MemoryMapFlagBits
-  {
-  };
-
-  using MemoryMapFlags = Flags<MemoryMapFlagBits, VkMemoryMapFlags>;
-
-  enum class DescriptorPoolResetFlagBits
-  {
-  };
-
-  using DescriptorPoolResetFlags = Flags<DescriptorPoolResetFlagBits, VkDescriptorPoolResetFlags>;
-
-  enum class DescriptorUpdateTemplateCreateFlagBitsKHR
-  {
-  };
-
-  using DescriptorUpdateTemplateCreateFlagsKHR = Flags<DescriptorUpdateTemplateCreateFlagBitsKHR, VkDescriptorUpdateTemplateCreateFlagsKHR>;
-
-  enum class DisplayModeCreateFlagBitsKHR
-  {
-  };
-
-  using DisplayModeCreateFlagsKHR = Flags<DisplayModeCreateFlagBitsKHR, VkDisplayModeCreateFlagsKHR>;
-
-  enum class DisplaySurfaceCreateFlagBitsKHR
-  {
-  };
-
-  using DisplaySurfaceCreateFlagsKHR = Flags<DisplaySurfaceCreateFlagBitsKHR, VkDisplaySurfaceCreateFlagsKHR>;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  enum class AndroidSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  using AndroidSurfaceCreateFlagsKHR = Flags<AndroidSurfaceCreateFlagBitsKHR, VkAndroidSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  enum class MirSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  using MirSurfaceCreateFlagsKHR = Flags<MirSurfaceCreateFlagBitsKHR, VkMirSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  enum class ViSurfaceCreateFlagBitsNN
-  {
-  };
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  using ViSurfaceCreateFlagsNN = Flags<ViSurfaceCreateFlagBitsNN, VkViSurfaceCreateFlagsNN>;
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  enum class WaylandSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  using WaylandSurfaceCreateFlagsKHR = Flags<WaylandSurfaceCreateFlagBitsKHR, VkWaylandSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  enum class Win32SurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  using Win32SurfaceCreateFlagsKHR = Flags<Win32SurfaceCreateFlagBitsKHR, VkWin32SurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  enum class XlibSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  using XlibSurfaceCreateFlagsKHR = Flags<XlibSurfaceCreateFlagBitsKHR, VkXlibSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  enum class XcbSurfaceCreateFlagBitsKHR
-  {
-  };
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  using XcbSurfaceCreateFlagsKHR = Flags<XcbSurfaceCreateFlagBitsKHR, VkXcbSurfaceCreateFlagsKHR>;
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  enum class IOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  using IOSSurfaceCreateFlagsMVK = Flags<IOSSurfaceCreateFlagBitsMVK, VkIOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  enum class MacOSSurfaceCreateFlagBitsMVK
-  {
-  };
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  using MacOSSurfaceCreateFlagsMVK = Flags<MacOSSurfaceCreateFlagBitsMVK, VkMacOSSurfaceCreateFlagsMVK>;
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  enum class CommandPoolTrimFlagBitsKHR
-  {
-  };
-
-  using CommandPoolTrimFlagsKHR = Flags<CommandPoolTrimFlagBitsKHR, VkCommandPoolTrimFlagsKHR>;
-
-  enum class PipelineViewportSwizzleStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineViewportSwizzleStateCreateFlagsNV = Flags<PipelineViewportSwizzleStateCreateFlagBitsNV, VkPipelineViewportSwizzleStateCreateFlagsNV>;
-
-  enum class PipelineDiscardRectangleStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineDiscardRectangleStateCreateFlagsEXT = Flags<PipelineDiscardRectangleStateCreateFlagBitsEXT, VkPipelineDiscardRectangleStateCreateFlagsEXT>;
-
-  enum class PipelineCoverageToColorStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageToColorStateCreateFlagsNV = Flags<PipelineCoverageToColorStateCreateFlagBitsNV, VkPipelineCoverageToColorStateCreateFlagsNV>;
-
-  enum class PipelineCoverageModulationStateCreateFlagBitsNV
-  {
-  };
-
-  using PipelineCoverageModulationStateCreateFlagsNV = Flags<PipelineCoverageModulationStateCreateFlagBitsNV, VkPipelineCoverageModulationStateCreateFlagsNV>;
-
-  enum class ValidationCacheCreateFlagBitsEXT
-  {
-  };
-
-  using ValidationCacheCreateFlagsEXT = Flags<ValidationCacheCreateFlagBitsEXT, VkValidationCacheCreateFlagsEXT>;
-
-  enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT
-  {
-  };
-
-  using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags<PipelineRasterizationConservativeStateCreateFlagBitsEXT, VkPipelineRasterizationConservativeStateCreateFlagsEXT>;
-
-  class DeviceMemory
-  {
-  public:
-    DeviceMemory()
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    DeviceMemory( std::nullptr_t )
-      : m_deviceMemory(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory )
-      : m_deviceMemory( deviceMemory )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DeviceMemory & operator=(VkDeviceMemory deviceMemory)
-    {
-      m_deviceMemory = deviceMemory;
-      return *this; 
-    }
-#endif
-
-    DeviceMemory & operator=( std::nullptr_t )
-    {
-      m_deviceMemory = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory == rhs.m_deviceMemory;
-    }
-
-    bool operator!=(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory != rhs.m_deviceMemory;
-    }
-
-    bool operator<(DeviceMemory const & rhs ) const
-    {
-      return m_deviceMemory < rhs.m_deviceMemory;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const
-    {
-      return m_deviceMemory;
-    }
-
-    explicit operator bool() const
-    {
-      return m_deviceMemory != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_deviceMemory == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDeviceMemory m_deviceMemory;
-  };
-
-  static_assert( sizeof( DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" );
-
-  class CommandPool
-  {
-  public:
-    CommandPool()
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    CommandPool( std::nullptr_t )
-      : m_commandPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool )
-      : m_commandPool( commandPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    CommandPool & operator=(VkCommandPool commandPool)
-    {
-      m_commandPool = commandPool;
-      return *this; 
-    }
-#endif
-
-    CommandPool & operator=( std::nullptr_t )
-    {
-      m_commandPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( CommandPool const & rhs ) const
-    {
-      return m_commandPool == rhs.m_commandPool;
-    }
-
-    bool operator!=(CommandPool const & rhs ) const
-    {
-      return m_commandPool != rhs.m_commandPool;
-    }
-
-    bool operator<(CommandPool const & rhs ) const
-    {
-      return m_commandPool < rhs.m_commandPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const
-    {
-      return m_commandPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_commandPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_commandPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkCommandPool m_commandPool;
-  };
-
-  static_assert( sizeof( CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" );
-
-  class Buffer
-  {
-  public:
-    Buffer()
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    Buffer( std::nullptr_t )
-      : m_buffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer )
-      : m_buffer( buffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Buffer & operator=(VkBuffer buffer)
-    {
-      m_buffer = buffer;
-      return *this; 
-    }
-#endif
-
-    Buffer & operator=( std::nullptr_t )
-    {
-      m_buffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Buffer const & rhs ) const
-    {
-      return m_buffer == rhs.m_buffer;
-    }
-
-    bool operator!=(Buffer const & rhs ) const
-    {
-      return m_buffer != rhs.m_buffer;
-    }
-
-    bool operator<(Buffer const & rhs ) const
-    {
-      return m_buffer < rhs.m_buffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const
-    {
-      return m_buffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_buffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_buffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBuffer m_buffer;
-  };
-
-  static_assert( sizeof( Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" );
-
-  class BufferView
-  {
-  public:
-    BufferView()
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    BufferView( std::nullptr_t )
-      : m_bufferView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView )
-      : m_bufferView( bufferView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    BufferView & operator=(VkBufferView bufferView)
-    {
-      m_bufferView = bufferView;
-      return *this; 
-    }
-#endif
-
-    BufferView & operator=( std::nullptr_t )
-    {
-      m_bufferView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( BufferView const & rhs ) const
-    {
-      return m_bufferView == rhs.m_bufferView;
-    }
-
-    bool operator!=(BufferView const & rhs ) const
-    {
-      return m_bufferView != rhs.m_bufferView;
-    }
-
-    bool operator<(BufferView const & rhs ) const
-    {
-      return m_bufferView < rhs.m_bufferView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const
-    {
-      return m_bufferView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_bufferView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_bufferView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkBufferView m_bufferView;
-  };
-
-  static_assert( sizeof( BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" );
-
-  class Image
-  {
-  public:
-    Image()
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    Image( std::nullptr_t )
-      : m_image(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image )
-      : m_image( image )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Image & operator=(VkImage image)
-    {
-      m_image = image;
-      return *this; 
-    }
-#endif
-
-    Image & operator=( std::nullptr_t )
-    {
-      m_image = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Image const & rhs ) const
-    {
-      return m_image == rhs.m_image;
-    }
-
-    bool operator!=(Image const & rhs ) const
-    {
-      return m_image != rhs.m_image;
-    }
-
-    bool operator<(Image const & rhs ) const
-    {
-      return m_image < rhs.m_image;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const
-    {
-      return m_image;
-    }
-
-    explicit operator bool() const
-    {
-      return m_image != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_image == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImage m_image;
-  };
-
-  static_assert( sizeof( Image ) == sizeof( VkImage ), "handle and wrapper have different size!" );
-
-  class ImageView
-  {
-  public:
-    ImageView()
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    ImageView( std::nullptr_t )
-      : m_imageView(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView )
-      : m_imageView( imageView )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ImageView & operator=(VkImageView imageView)
-    {
-      m_imageView = imageView;
-      return *this; 
-    }
-#endif
-
-    ImageView & operator=( std::nullptr_t )
-    {
-      m_imageView = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ImageView const & rhs ) const
-    {
-      return m_imageView == rhs.m_imageView;
-    }
-
-    bool operator!=(ImageView const & rhs ) const
-    {
-      return m_imageView != rhs.m_imageView;
-    }
-
-    bool operator<(ImageView const & rhs ) const
-    {
-      return m_imageView < rhs.m_imageView;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const
-    {
-      return m_imageView;
-    }
-
-    explicit operator bool() const
-    {
-      return m_imageView != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_imageView == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkImageView m_imageView;
-  };
-
-  static_assert( sizeof( ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" );
-
-  class ShaderModule
-  {
-  public:
-    ShaderModule()
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    ShaderModule( std::nullptr_t )
-      : m_shaderModule(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule )
-      : m_shaderModule( shaderModule )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ShaderModule & operator=(VkShaderModule shaderModule)
-    {
-      m_shaderModule = shaderModule;
-      return *this; 
-    }
-#endif
-
-    ShaderModule & operator=( std::nullptr_t )
-    {
-      m_shaderModule = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ShaderModule const & rhs ) const
-    {
-      return m_shaderModule == rhs.m_shaderModule;
-    }
-
-    bool operator!=(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule != rhs.m_shaderModule;
-    }
-
-    bool operator<(ShaderModule const & rhs ) const
-    {
-      return m_shaderModule < rhs.m_shaderModule;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const
-    {
-      return m_shaderModule;
-    }
-
-    explicit operator bool() const
-    {
-      return m_shaderModule != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_shaderModule == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkShaderModule m_shaderModule;
-  };
-
-  static_assert( sizeof( ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" );
-
-  class Pipeline
-  {
-  public:
-    Pipeline()
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    Pipeline( std::nullptr_t )
-      : m_pipeline(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline )
-      : m_pipeline( pipeline )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Pipeline & operator=(VkPipeline pipeline)
-    {
-      m_pipeline = pipeline;
-      return *this; 
-    }
-#endif
-
-    Pipeline & operator=( std::nullptr_t )
-    {
-      m_pipeline = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Pipeline const & rhs ) const
-    {
-      return m_pipeline == rhs.m_pipeline;
-    }
-
-    bool operator!=(Pipeline const & rhs ) const
-    {
-      return m_pipeline != rhs.m_pipeline;
-    }
-
-    bool operator<(Pipeline const & rhs ) const
-    {
-      return m_pipeline < rhs.m_pipeline;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const
-    {
-      return m_pipeline;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipeline != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipeline == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipeline m_pipeline;
-  };
-
-  static_assert( sizeof( Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" );
-
-  class PipelineLayout
-  {
-  public:
-    PipelineLayout()
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    PipelineLayout( std::nullptr_t )
-      : m_pipelineLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout )
-      : m_pipelineLayout( pipelineLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineLayout & operator=(VkPipelineLayout pipelineLayout)
-    {
-      m_pipelineLayout = pipelineLayout;
-      return *this; 
-    }
-#endif
-
-    PipelineLayout & operator=( std::nullptr_t )
-    {
-      m_pipelineLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout == rhs.m_pipelineLayout;
-    }
-
-    bool operator!=(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout != rhs.m_pipelineLayout;
-    }
-
-    bool operator<(PipelineLayout const & rhs ) const
-    {
-      return m_pipelineLayout < rhs.m_pipelineLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const
-    {
-      return m_pipelineLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineLayout m_pipelineLayout;
-  };
-
-  static_assert( sizeof( PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" );
-
-  class Sampler
-  {
-  public:
-    Sampler()
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    Sampler( std::nullptr_t )
-      : m_sampler(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler )
-      : m_sampler( sampler )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Sampler & operator=(VkSampler sampler)
-    {
-      m_sampler = sampler;
-      return *this; 
-    }
-#endif
-
-    Sampler & operator=( std::nullptr_t )
-    {
-      m_sampler = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Sampler const & rhs ) const
-    {
-      return m_sampler == rhs.m_sampler;
-    }
-
-    bool operator!=(Sampler const & rhs ) const
-    {
-      return m_sampler != rhs.m_sampler;
-    }
-
-    bool operator<(Sampler const & rhs ) const
-    {
-      return m_sampler < rhs.m_sampler;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const
-    {
-      return m_sampler;
-    }
-
-    explicit operator bool() const
-    {
-      return m_sampler != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_sampler == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSampler m_sampler;
-  };
-
-  static_assert( sizeof( Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" );
-
-  class DescriptorSet
-  {
-  public:
-    DescriptorSet()
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    DescriptorSet( std::nullptr_t )
-      : m_descriptorSet(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet )
-      : m_descriptorSet( descriptorSet )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSet & operator=(VkDescriptorSet descriptorSet)
-    {
-      m_descriptorSet = descriptorSet;
-      return *this; 
-    }
-#endif
-
-    DescriptorSet & operator=( std::nullptr_t )
-    {
-      m_descriptorSet = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet == rhs.m_descriptorSet;
-    }
-
-    bool operator!=(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet != rhs.m_descriptorSet;
-    }
-
-    bool operator<(DescriptorSet const & rhs ) const
-    {
-      return m_descriptorSet < rhs.m_descriptorSet;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const
-    {
-      return m_descriptorSet;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSet != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSet == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSet m_descriptorSet;
-  };
-
-  static_assert( sizeof( DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" );
-
-  class DescriptorSetLayout
-  {
-  public:
-    DescriptorSetLayout()
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    DescriptorSetLayout( std::nullptr_t )
-      : m_descriptorSetLayout(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout )
-      : m_descriptorSetLayout( descriptorSetLayout )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorSetLayout & operator=(VkDescriptorSetLayout descriptorSetLayout)
-    {
-      m_descriptorSetLayout = descriptorSetLayout;
-      return *this; 
-    }
-#endif
-
-    DescriptorSetLayout & operator=( std::nullptr_t )
-    {
-      m_descriptorSetLayout = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout == rhs.m_descriptorSetLayout;
-    }
-
-    bool operator!=(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout != rhs.m_descriptorSetLayout;
-    }
-
-    bool operator<(DescriptorSetLayout const & rhs ) const
-    {
-      return m_descriptorSetLayout < rhs.m_descriptorSetLayout;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const
-    {
-      return m_descriptorSetLayout;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorSetLayout != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorSetLayout == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorSetLayout m_descriptorSetLayout;
-  };
-
-  static_assert( sizeof( DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" );
-
-  class DescriptorPool
-  {
-  public:
-    DescriptorPool()
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    DescriptorPool( std::nullptr_t )
-      : m_descriptorPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool )
-      : m_descriptorPool( descriptorPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorPool & operator=(VkDescriptorPool descriptorPool)
-    {
-      m_descriptorPool = descriptorPool;
-      return *this; 
-    }
-#endif
-
-    DescriptorPool & operator=( std::nullptr_t )
-    {
-      m_descriptorPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool == rhs.m_descriptorPool;
-    }
-
-    bool operator!=(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool != rhs.m_descriptorPool;
-    }
-
-    bool operator<(DescriptorPool const & rhs ) const
-    {
-      return m_descriptorPool < rhs.m_descriptorPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const
-    {
-      return m_descriptorPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorPool m_descriptorPool;
-  };
-
-  static_assert( sizeof( DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" );
-
-  class Fence
-  {
-  public:
-    Fence()
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    Fence( std::nullptr_t )
-      : m_fence(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence )
-      : m_fence( fence )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Fence & operator=(VkFence fence)
-    {
-      m_fence = fence;
-      return *this; 
-    }
-#endif
-
-    Fence & operator=( std::nullptr_t )
-    {
-      m_fence = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Fence const & rhs ) const
-    {
-      return m_fence == rhs.m_fence;
-    }
-
-    bool operator!=(Fence const & rhs ) const
-    {
-      return m_fence != rhs.m_fence;
-    }
-
-    bool operator<(Fence const & rhs ) const
-    {
-      return m_fence < rhs.m_fence;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const
-    {
-      return m_fence;
-    }
-
-    explicit operator bool() const
-    {
-      return m_fence != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_fence == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFence m_fence;
-  };
-
-  static_assert( sizeof( Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" );
-
-  class Semaphore
-  {
-  public:
-    Semaphore()
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    Semaphore( std::nullptr_t )
-      : m_semaphore(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore )
-      : m_semaphore( semaphore )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Semaphore & operator=(VkSemaphore semaphore)
-    {
-      m_semaphore = semaphore;
-      return *this; 
-    }
-#endif
-
-    Semaphore & operator=( std::nullptr_t )
-    {
-      m_semaphore = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Semaphore const & rhs ) const
-    {
-      return m_semaphore == rhs.m_semaphore;
-    }
-
-    bool operator!=(Semaphore const & rhs ) const
-    {
-      return m_semaphore != rhs.m_semaphore;
-    }
-
-    bool operator<(Semaphore const & rhs ) const
-    {
-      return m_semaphore < rhs.m_semaphore;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const
-    {
-      return m_semaphore;
-    }
-
-    explicit operator bool() const
-    {
-      return m_semaphore != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_semaphore == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSemaphore m_semaphore;
-  };
-
-  static_assert( sizeof( Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" );
-
-  class Event
-  {
-  public:
-    Event()
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    Event( std::nullptr_t )
-      : m_event(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event )
-      : m_event( event )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Event & operator=(VkEvent event)
-    {
-      m_event = event;
-      return *this; 
-    }
-#endif
-
-    Event & operator=( std::nullptr_t )
-    {
-      m_event = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Event const & rhs ) const
-    {
-      return m_event == rhs.m_event;
-    }
-
-    bool operator!=(Event const & rhs ) const
-    {
-      return m_event != rhs.m_event;
-    }
-
-    bool operator<(Event const & rhs ) const
-    {
-      return m_event < rhs.m_event;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const
-    {
-      return m_event;
-    }
-
-    explicit operator bool() const
-    {
-      return m_event != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_event == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkEvent m_event;
-  };
-
-  static_assert( sizeof( Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" );
-
-  class QueryPool
-  {
-  public:
-    QueryPool()
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    QueryPool( std::nullptr_t )
-      : m_queryPool(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool )
-      : m_queryPool( queryPool )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    QueryPool & operator=(VkQueryPool queryPool)
-    {
-      m_queryPool = queryPool;
-      return *this; 
-    }
-#endif
-
-    QueryPool & operator=( std::nullptr_t )
-    {
-      m_queryPool = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( QueryPool const & rhs ) const
-    {
-      return m_queryPool == rhs.m_queryPool;
-    }
-
-    bool operator!=(QueryPool const & rhs ) const
-    {
-      return m_queryPool != rhs.m_queryPool;
-    }
-
-    bool operator<(QueryPool const & rhs ) const
-    {
-      return m_queryPool < rhs.m_queryPool;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const
-    {
-      return m_queryPool;
-    }
-
-    explicit operator bool() const
-    {
-      return m_queryPool != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_queryPool == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkQueryPool m_queryPool;
-  };
-
-  static_assert( sizeof( QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" );
-
-  class Framebuffer
-  {
-  public:
-    Framebuffer()
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    Framebuffer( std::nullptr_t )
-      : m_framebuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer )
-      : m_framebuffer( framebuffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Framebuffer & operator=(VkFramebuffer framebuffer)
-    {
-      m_framebuffer = framebuffer;
-      return *this; 
-    }
-#endif
-
-    Framebuffer & operator=( std::nullptr_t )
-    {
-      m_framebuffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Framebuffer const & rhs ) const
-    {
-      return m_framebuffer == rhs.m_framebuffer;
-    }
-
-    bool operator!=(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer != rhs.m_framebuffer;
-    }
-
-    bool operator<(Framebuffer const & rhs ) const
-    {
-      return m_framebuffer < rhs.m_framebuffer;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const
-    {
-      return m_framebuffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_framebuffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_framebuffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkFramebuffer m_framebuffer;
-  };
-
-  static_assert( sizeof( Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" );
-
-  class RenderPass
-  {
-  public:
-    RenderPass()
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    RenderPass( std::nullptr_t )
-      : m_renderPass(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass )
-      : m_renderPass( renderPass )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    RenderPass & operator=(VkRenderPass renderPass)
-    {
-      m_renderPass = renderPass;
-      return *this; 
-    }
-#endif
-
-    RenderPass & operator=( std::nullptr_t )
-    {
-      m_renderPass = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( RenderPass const & rhs ) const
-    {
-      return m_renderPass == rhs.m_renderPass;
-    }
-
-    bool operator!=(RenderPass const & rhs ) const
-    {
-      return m_renderPass != rhs.m_renderPass;
-    }
-
-    bool operator<(RenderPass const & rhs ) const
-    {
-      return m_renderPass < rhs.m_renderPass;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const
-    {
-      return m_renderPass;
-    }
-
-    explicit operator bool() const
-    {
-      return m_renderPass != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_renderPass == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkRenderPass m_renderPass;
-  };
-
-  static_assert( sizeof( RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" );
-
-  class PipelineCache
-  {
-  public:
-    PipelineCache()
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    PipelineCache( std::nullptr_t )
-      : m_pipelineCache(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache )
-      : m_pipelineCache( pipelineCache )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PipelineCache & operator=(VkPipelineCache pipelineCache)
-    {
-      m_pipelineCache = pipelineCache;
-      return *this; 
-    }
-#endif
-
-    PipelineCache & operator=( std::nullptr_t )
-    {
-      m_pipelineCache = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache == rhs.m_pipelineCache;
-    }
-
-    bool operator!=(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache != rhs.m_pipelineCache;
-    }
-
-    bool operator<(PipelineCache const & rhs ) const
-    {
-      return m_pipelineCache < rhs.m_pipelineCache;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const
-    {
-      return m_pipelineCache;
-    }
-
-    explicit operator bool() const
-    {
-      return m_pipelineCache != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_pipelineCache == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPipelineCache m_pipelineCache;
-  };
-
-  static_assert( sizeof( PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" );
-
-  class ObjectTableNVX
-  {
-  public:
-    ObjectTableNVX()
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    ObjectTableNVX( std::nullptr_t )
-      : m_objectTableNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ObjectTableNVX( VkObjectTableNVX objectTableNVX )
-      : m_objectTableNVX( objectTableNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ObjectTableNVX & operator=(VkObjectTableNVX objectTableNVX)
-    {
-      m_objectTableNVX = objectTableNVX;
-      return *this; 
-    }
-#endif
-
-    ObjectTableNVX & operator=( std::nullptr_t )
-    {
-      m_objectTableNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX == rhs.m_objectTableNVX;
-    }
-
-    bool operator!=(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX != rhs.m_objectTableNVX;
-    }
-
-    bool operator<(ObjectTableNVX const & rhs ) const
-    {
-      return m_objectTableNVX < rhs.m_objectTableNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkObjectTableNVX() const
-    {
-      return m_objectTableNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_objectTableNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_objectTableNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkObjectTableNVX m_objectTableNVX;
-  };
-
-  static_assert( sizeof( ObjectTableNVX ) == sizeof( VkObjectTableNVX ), "handle and wrapper have different size!" );
-
-  class IndirectCommandsLayoutNVX
-  {
-  public:
-    IndirectCommandsLayoutNVX()
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    IndirectCommandsLayoutNVX( std::nullptr_t )
-      : m_indirectCommandsLayoutNVX(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNVX( VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
-      : m_indirectCommandsLayoutNVX( indirectCommandsLayoutNVX )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    IndirectCommandsLayoutNVX & operator=(VkIndirectCommandsLayoutNVX indirectCommandsLayoutNVX)
-    {
-      m_indirectCommandsLayoutNVX = indirectCommandsLayoutNVX;
-      return *this; 
-    }
-#endif
-
-    IndirectCommandsLayoutNVX & operator=( std::nullptr_t )
-    {
-      m_indirectCommandsLayoutNVX = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX == rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator!=(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX != rhs.m_indirectCommandsLayoutNVX;
-    }
-
-    bool operator<(IndirectCommandsLayoutNVX const & rhs ) const
-    {
-      return m_indirectCommandsLayoutNVX < rhs.m_indirectCommandsLayoutNVX;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNVX() const
-    {
-      return m_indirectCommandsLayoutNVX;
-    }
-
-    explicit operator bool() const
-    {
-      return m_indirectCommandsLayoutNVX != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_indirectCommandsLayoutNVX == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkIndirectCommandsLayoutNVX m_indirectCommandsLayoutNVX;
-  };
-
-  static_assert( sizeof( IndirectCommandsLayoutNVX ) == sizeof( VkIndirectCommandsLayoutNVX ), "handle and wrapper have different size!" );
-
-  class DescriptorUpdateTemplateKHR
-  {
-  public:
-    DescriptorUpdateTemplateKHR()
-      : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE)
-    {}
-
-    DescriptorUpdateTemplateKHR( std::nullptr_t )
-      : m_descriptorUpdateTemplateKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplateKHR( VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
-      : m_descriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DescriptorUpdateTemplateKHR & operator=(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR)
-    {
-      m_descriptorUpdateTemplateKHR = descriptorUpdateTemplateKHR;
-      return *this; 
-    }
-#endif
-
-    DescriptorUpdateTemplateKHR & operator=( std::nullptr_t )
-    {
-      m_descriptorUpdateTemplateKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DescriptorUpdateTemplateKHR const & rhs ) const
-    {
-      return m_descriptorUpdateTemplateKHR == rhs.m_descriptorUpdateTemplateKHR;
-    }
-
-    bool operator!=(DescriptorUpdateTemplateKHR const & rhs ) const
-    {
-      return m_descriptorUpdateTemplateKHR != rhs.m_descriptorUpdateTemplateKHR;
-    }
-
-    bool operator<(DescriptorUpdateTemplateKHR const & rhs ) const
-    {
-      return m_descriptorUpdateTemplateKHR < rhs.m_descriptorUpdateTemplateKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplateKHR() const
-    {
-      return m_descriptorUpdateTemplateKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_descriptorUpdateTemplateKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_descriptorUpdateTemplateKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDescriptorUpdateTemplateKHR m_descriptorUpdateTemplateKHR;
-  };
-
-  static_assert( sizeof( DescriptorUpdateTemplateKHR ) == sizeof( VkDescriptorUpdateTemplateKHR ), "handle and wrapper have different size!" );
-
-  class SamplerYcbcrConversionKHR
-  {
-  public:
-    SamplerYcbcrConversionKHR()
-      : m_samplerYcbcrConversionKHR(VK_NULL_HANDLE)
-    {}
-
-    SamplerYcbcrConversionKHR( std::nullptr_t )
-      : m_samplerYcbcrConversionKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversionKHR( VkSamplerYcbcrConversionKHR samplerYcbcrConversionKHR )
-      : m_samplerYcbcrConversionKHR( samplerYcbcrConversionKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SamplerYcbcrConversionKHR & operator=(VkSamplerYcbcrConversionKHR samplerYcbcrConversionKHR)
-    {
-      m_samplerYcbcrConversionKHR = samplerYcbcrConversionKHR;
-      return *this; 
-    }
-#endif
-
-    SamplerYcbcrConversionKHR & operator=( std::nullptr_t )
-    {
-      m_samplerYcbcrConversionKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SamplerYcbcrConversionKHR const & rhs ) const
-    {
-      return m_samplerYcbcrConversionKHR == rhs.m_samplerYcbcrConversionKHR;
-    }
-
-    bool operator!=(SamplerYcbcrConversionKHR const & rhs ) const
-    {
-      return m_samplerYcbcrConversionKHR != rhs.m_samplerYcbcrConversionKHR;
-    }
-
-    bool operator<(SamplerYcbcrConversionKHR const & rhs ) const
-    {
-      return m_samplerYcbcrConversionKHR < rhs.m_samplerYcbcrConversionKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversionKHR() const
-    {
-      return m_samplerYcbcrConversionKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_samplerYcbcrConversionKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_samplerYcbcrConversionKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSamplerYcbcrConversionKHR m_samplerYcbcrConversionKHR;
-  };
-
-  static_assert( sizeof( SamplerYcbcrConversionKHR ) == sizeof( VkSamplerYcbcrConversionKHR ), "handle and wrapper have different size!" );
-
-  class ValidationCacheEXT
-  {
-  public:
-    ValidationCacheEXT()
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    ValidationCacheEXT( std::nullptr_t )
-      : m_validationCacheEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT )
-      : m_validationCacheEXT( validationCacheEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    ValidationCacheEXT & operator=(VkValidationCacheEXT validationCacheEXT)
-    {
-      m_validationCacheEXT = validationCacheEXT;
-      return *this; 
-    }
-#endif
-
-    ValidationCacheEXT & operator=( std::nullptr_t )
-    {
-      m_validationCacheEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT == rhs.m_validationCacheEXT;
-    }
-
-    bool operator!=(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT != rhs.m_validationCacheEXT;
-    }
-
-    bool operator<(ValidationCacheEXT const & rhs ) const
-    {
-      return m_validationCacheEXT < rhs.m_validationCacheEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const
-    {
-      return m_validationCacheEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_validationCacheEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_validationCacheEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkValidationCacheEXT m_validationCacheEXT;
-  };
-
-  static_assert( sizeof( ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" );
-
-  class DisplayKHR
-  {
-  public:
-    DisplayKHR()
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    DisplayKHR( std::nullptr_t )
-      : m_displayKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR )
-      : m_displayKHR( displayKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayKHR & operator=(VkDisplayKHR displayKHR)
-    {
-      m_displayKHR = displayKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayKHR & operator=( std::nullptr_t )
-    {
-      m_displayKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR == rhs.m_displayKHR;
-    }
-
-    bool operator!=(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR != rhs.m_displayKHR;
-    }
-
-    bool operator<(DisplayKHR const & rhs ) const
-    {
-      return m_displayKHR < rhs.m_displayKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const
-    {
-      return m_displayKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayKHR m_displayKHR;
-  };
-
-  static_assert( sizeof( DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" );
-
-  class DisplayModeKHR
-  {
-  public:
-    DisplayModeKHR()
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    DisplayModeKHR( std::nullptr_t )
-      : m_displayModeKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR )
-      : m_displayModeKHR( displayModeKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DisplayModeKHR & operator=(VkDisplayModeKHR displayModeKHR)
-    {
-      m_displayModeKHR = displayModeKHR;
-      return *this; 
-    }
-#endif
-
-    DisplayModeKHR & operator=( std::nullptr_t )
-    {
-      m_displayModeKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR == rhs.m_displayModeKHR;
-    }
-
-    bool operator!=(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR != rhs.m_displayModeKHR;
-    }
-
-    bool operator<(DisplayModeKHR const & rhs ) const
-    {
-      return m_displayModeKHR < rhs.m_displayModeKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const
-    {
-      return m_displayModeKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_displayModeKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_displayModeKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDisplayModeKHR m_displayModeKHR;
-  };
-
-  static_assert( sizeof( DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" );
-
-  class SurfaceKHR
-  {
-  public:
-    SurfaceKHR()
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    SurfaceKHR( std::nullptr_t )
-      : m_surfaceKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR )
-      : m_surfaceKHR( surfaceKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SurfaceKHR & operator=(VkSurfaceKHR surfaceKHR)
-    {
-      m_surfaceKHR = surfaceKHR;
-      return *this; 
-    }
-#endif
-
-    SurfaceKHR & operator=( std::nullptr_t )
-    {
-      m_surfaceKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR == rhs.m_surfaceKHR;
-    }
-
-    bool operator!=(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR != rhs.m_surfaceKHR;
-    }
-
-    bool operator<(SurfaceKHR const & rhs ) const
-    {
-      return m_surfaceKHR < rhs.m_surfaceKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const
-    {
-      return m_surfaceKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_surfaceKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_surfaceKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSurfaceKHR m_surfaceKHR;
-  };
-
-  static_assert( sizeof( SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" );
-
-  class SwapchainKHR
-  {
-  public:
-    SwapchainKHR()
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    SwapchainKHR( std::nullptr_t )
-      : m_swapchainKHR(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR )
-      : m_swapchainKHR( swapchainKHR )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    SwapchainKHR & operator=(VkSwapchainKHR swapchainKHR)
-    {
-      m_swapchainKHR = swapchainKHR;
-      return *this; 
-    }
-#endif
-
-    SwapchainKHR & operator=( std::nullptr_t )
-    {
-      m_swapchainKHR = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR == rhs.m_swapchainKHR;
-    }
-
-    bool operator!=(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR != rhs.m_swapchainKHR;
-    }
-
-    bool operator<(SwapchainKHR const & rhs ) const
-    {
-      return m_swapchainKHR < rhs.m_swapchainKHR;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const
-    {
-      return m_swapchainKHR;
-    }
-
-    explicit operator bool() const
-    {
-      return m_swapchainKHR != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_swapchainKHR == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkSwapchainKHR m_swapchainKHR;
-  };
-
-  static_assert( sizeof( SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" );
-
-  class DebugReportCallbackEXT
-  {
-  public:
-    DebugReportCallbackEXT()
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    DebugReportCallbackEXT( std::nullptr_t )
-      : m_debugReportCallbackEXT(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT )
-      : m_debugReportCallbackEXT( debugReportCallbackEXT )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    DebugReportCallbackEXT & operator=(VkDebugReportCallbackEXT debugReportCallbackEXT)
-    {
-      m_debugReportCallbackEXT = debugReportCallbackEXT;
-      return *this; 
-    }
-#endif
-
-    DebugReportCallbackEXT & operator=( std::nullptr_t )
-    {
-      m_debugReportCallbackEXT = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT == rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator!=(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT != rhs.m_debugReportCallbackEXT;
-    }
-
-    bool operator<(DebugReportCallbackEXT const & rhs ) const
-    {
-      return m_debugReportCallbackEXT < rhs.m_debugReportCallbackEXT;
-    }
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const
-    {
-      return m_debugReportCallbackEXT;
-    }
-
-    explicit operator bool() const
-    {
-      return m_debugReportCallbackEXT != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_debugReportCallbackEXT == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDebugReportCallbackEXT m_debugReportCallbackEXT;
-  };
-
-  static_assert( sizeof( DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), "handle and wrapper have different size!" );
-
-  struct Offset2D
-  {
-    Offset2D( int32_t x_ = 0, int32_t y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    Offset2D( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-    }
-
-    Offset2D& operator=( VkOffset2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset2D ) );
-      return *this;
-    }
-    Offset2D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset2D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator const VkOffset2D&() const
-    {
-      return *reinterpret_cast<const VkOffset2D*>(this);
-    }
-
-    bool operator==( Offset2D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( Offset2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-  };
-  static_assert( sizeof( Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" );
-
-  struct Offset3D
-  {
-    Offset3D( int32_t x_ = 0, int32_t y_ = 0, int32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    Offset3D( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-    }
-
-    Offset3D& operator=( VkOffset3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Offset3D ) );
-      return *this;
-    }
-    Offset3D& setX( int32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Offset3D& setY( int32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Offset3D& setZ( int32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator const VkOffset3D&() const
-    {
-      return *reinterpret_cast<const VkOffset3D*>(this);
-    }
-
-    bool operator==( Offset3D const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( Offset3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    int32_t x;
-    int32_t y;
-    int32_t z;
-  };
-  static_assert( sizeof( Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" );
-
-  struct Extent2D
-  {
-    Extent2D( uint32_t width_ = 0, uint32_t height_ = 0 )
-      : width( width_ )
-      , height( height_ )
-    {
-    }
-
-    Extent2D( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-    }
-
-    Extent2D& operator=( VkExtent2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent2D ) );
-      return *this;
-    }
-    Extent2D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent2D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    operator const VkExtent2D&() const
-    {
-      return *reinterpret_cast<const VkExtent2D*>(this);
-    }
-
-    bool operator==( Extent2D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height );
-    }
-
-    bool operator!=( Extent2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-  };
-  static_assert( sizeof( Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" );
-
-  struct Extent3D
-  {
-    Extent3D( uint32_t width_ = 0, uint32_t height_ = 0, uint32_t depth_ = 0 )
-      : width( width_ )
-      , height( height_ )
-      , depth( depth_ )
-    {
-    }
-
-    Extent3D( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-    }
-
-    Extent3D& operator=( VkExtent3D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Extent3D ) );
-      return *this;
-    }
-    Extent3D& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Extent3D& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Extent3D& setDepth( uint32_t depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    operator const VkExtent3D&() const
-    {
-      return *reinterpret_cast<const VkExtent3D*>(this);
-    }
-
-    bool operator==( Extent3D const& rhs ) const
-    {
-      return ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( depth == rhs.depth );
-    }
-
-    bool operator!=( Extent3D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t width;
-    uint32_t height;
-    uint32_t depth;
-  };
-  static_assert( sizeof( Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" );
-
-  struct Viewport
-  {
-    Viewport( float x_ = 0, float y_ = 0, float width_ = 0, float height_ = 0, float minDepth_ = 0, float maxDepth_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , width( width_ )
-      , height( height_ )
-      , minDepth( minDepth_ )
-      , maxDepth( maxDepth_ )
-    {
-    }
-
-    Viewport( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-    }
-
-    Viewport& operator=( VkViewport const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Viewport ) );
-      return *this;
-    }
-    Viewport& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    Viewport& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    Viewport& setWidth( float width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    Viewport& setHeight( float height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    Viewport& setMinDepth( float minDepth_ )
-    {
-      minDepth = minDepth_;
-      return *this;
-    }
-
-    Viewport& setMaxDepth( float maxDepth_ )
-    {
-      maxDepth = maxDepth_;
-      return *this;
-    }
-
-    operator const VkViewport&() const
-    {
-      return *reinterpret_cast<const VkViewport*>(this);
-    }
-
-    bool operator==( Viewport const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( minDepth == rhs.minDepth )
-          && ( maxDepth == rhs.maxDepth );
-    }
-
-    bool operator!=( Viewport const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-    float width;
-    float height;
-    float minDepth;
-    float maxDepth;
-  };
-  static_assert( sizeof( Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" );
-
-  struct Rect2D
-  {
-    Rect2D( Offset2D offset_ = Offset2D(), Extent2D extent_ = Extent2D() )
-      : offset( offset_ )
-      , extent( extent_ )
-    {
-    }
-
-    Rect2D( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-    }
-
-    Rect2D& operator=( VkRect2D const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Rect2D ) );
-      return *this;
-    }
-    Rect2D& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    Rect2D& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator const VkRect2D&() const
-    {
-      return *reinterpret_cast<const VkRect2D*>(this);
-    }
-
-    bool operator==( Rect2D const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( Rect2D const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-  };
-  static_assert( sizeof( Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" );
-
-  struct ClearRect
-  {
-    ClearRect( Rect2D rect_ = Rect2D(), uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
-      : rect( rect_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ClearRect( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-    }
-
-    ClearRect& operator=( VkClearRect const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearRect ) );
-      return *this;
-    }
-    ClearRect& setRect( Rect2D rect_ )
-    {
-      rect = rect_;
-      return *this;
-    }
-
-    ClearRect& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ClearRect& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator const VkClearRect&() const
-    {
-      return *reinterpret_cast<const VkClearRect*>(this);
-    }
-
-    bool operator==( ClearRect const& rhs ) const
-    {
-      return ( rect == rhs.rect )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ClearRect const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Rect2D rect;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" );
-
-  struct ExtensionProperties
-  {
-    operator const VkExtensionProperties&() const
-    {
-      return *reinterpret_cast<const VkExtensionProperties*>(this);
-    }
-
-    bool operator==( ExtensionProperties const& rhs ) const
-    {
-      return ( memcmp( extensionName, rhs.extensionName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion );
-    }
-
-    bool operator!=( ExtensionProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-  };
-  static_assert( sizeof( ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" );
-
-  struct LayerProperties
-  {
-    operator const VkLayerProperties&() const
-    {
-      return *reinterpret_cast<const VkLayerProperties*>(this);
-    }
-
-    bool operator==( LayerProperties const& rhs ) const
-    {
-      return ( memcmp( layerName, rhs.layerName, VK_MAX_EXTENSION_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( specVersion == rhs.specVersion )
-          && ( implementationVersion == rhs.implementationVersion )
-          && ( memcmp( description, rhs.description, VK_MAX_DESCRIPTION_SIZE * sizeof( char ) ) == 0 );
-    }
-
-    bool operator!=( LayerProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    char layerName[VK_MAX_EXTENSION_NAME_SIZE];
-    uint32_t specVersion;
-    uint32_t implementationVersion;
-    char description[VK_MAX_DESCRIPTION_SIZE];
-  };
-  static_assert( sizeof( LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" );
-
-  struct AllocationCallbacks
-  {
-    AllocationCallbacks( void* pUserData_ = nullptr, PFN_vkAllocationFunction pfnAllocation_ = nullptr, PFN_vkReallocationFunction pfnReallocation_ = nullptr, PFN_vkFreeFunction pfnFree_ = nullptr, PFN_vkInternalAllocationNotification pfnInternalAllocation_ = nullptr, PFN_vkInternalFreeNotification pfnInternalFree_ = nullptr )
-      : pUserData( pUserData_ )
-      , pfnAllocation( pfnAllocation_ )
-      , pfnReallocation( pfnReallocation_ )
-      , pfnFree( pfnFree_ )
-      , pfnInternalAllocation( pfnInternalAllocation_ )
-      , pfnInternalFree( pfnInternalFree_ )
-    {
-    }
-
-    AllocationCallbacks( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-    }
-
-    AllocationCallbacks& operator=( VkAllocationCallbacks const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AllocationCallbacks ) );
-      return *this;
-    }
-    AllocationCallbacks& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ )
-    {
-      pfnAllocation = pfnAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ )
-    {
-      pfnReallocation = pfnReallocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnFree( PFN_vkFreeFunction pfnFree_ )
-    {
-      pfnFree = pfnFree_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ )
-    {
-      pfnInternalAllocation = pfnInternalAllocation_;
-      return *this;
-    }
-
-    AllocationCallbacks& setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ )
-    {
-      pfnInternalFree = pfnInternalFree_;
-      return *this;
-    }
-
-    operator const VkAllocationCallbacks&() const
-    {
-      return *reinterpret_cast<const VkAllocationCallbacks*>(this);
-    }
-
-    bool operator==( AllocationCallbacks const& rhs ) const
-    {
-      return ( pUserData == rhs.pUserData )
-          && ( pfnAllocation == rhs.pfnAllocation )
-          && ( pfnReallocation == rhs.pfnReallocation )
-          && ( pfnFree == rhs.pfnFree )
-          && ( pfnInternalAllocation == rhs.pfnInternalAllocation )
-          && ( pfnInternalFree == rhs.pfnInternalFree );
-    }
-
-    bool operator!=( AllocationCallbacks const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    void* pUserData;
-    PFN_vkAllocationFunction pfnAllocation;
-    PFN_vkReallocationFunction pfnReallocation;
-    PFN_vkFreeFunction pfnFree;
-    PFN_vkInternalAllocationNotification pfnInternalAllocation;
-    PFN_vkInternalFreeNotification pfnInternalFree;
-  };
-  static_assert( sizeof( AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" );
-
-  struct MemoryRequirements
-  {
-    operator const VkMemoryRequirements&() const
-    {
-      return *reinterpret_cast<const VkMemoryRequirements*>(this);
-    }
-
-    bool operator==( MemoryRequirements const& rhs ) const
-    {
-      return ( size == rhs.size )
-          && ( alignment == rhs.alignment )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize size;
-    DeviceSize alignment;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" );
-
-  struct DescriptorBufferInfo
-  {
-    DescriptorBufferInfo( Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize range_ = 0 )
-      : buffer( buffer_ )
-      , offset( offset_ )
-      , range( range_ )
-    {
-    }
-
-    DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-    }
-
-    DescriptorBufferInfo& operator=( VkDescriptorBufferInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorBufferInfo ) );
-      return *this;
-    }
-    DescriptorBufferInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorBufferInfo& setRange( DeviceSize range_ )
-    {
-      range = range_;
-      return *this;
-    }
-
-    operator const VkDescriptorBufferInfo&() const
-    {
-      return *reinterpret_cast<const VkDescriptorBufferInfo*>(this);
-    }
-
-    bool operator==( DescriptorBufferInfo const& rhs ) const
-    {
-      return ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( range == rhs.range );
-    }
-
-    bool operator!=( DescriptorBufferInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize range;
-  };
-  static_assert( sizeof( DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" );
-
-  struct SubresourceLayout
-  {
-    operator const VkSubresourceLayout&() const
-    {
-      return *reinterpret_cast<const VkSubresourceLayout*>(this);
-    }
-
-    bool operator==( SubresourceLayout const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( size == rhs.size )
-          && ( rowPitch == rhs.rowPitch )
-          && ( arrayPitch == rhs.arrayPitch )
-          && ( depthPitch == rhs.depthPitch );
-    }
-
-    bool operator!=( SubresourceLayout const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize offset;
-    DeviceSize size;
-    DeviceSize rowPitch;
-    DeviceSize arrayPitch;
-    DeviceSize depthPitch;
-  };
-  static_assert( sizeof( SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" );
-
-  struct BufferCopy
-  {
-    BufferCopy( DeviceSize srcOffset_ = 0, DeviceSize dstOffset_ = 0, DeviceSize size_ = 0 )
-      : srcOffset( srcOffset_ )
-      , dstOffset( dstOffset_ )
-      , size( size_ )
-    {
-    }
-
-    BufferCopy( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-    }
-
-    BufferCopy& operator=( VkBufferCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCopy ) );
-      return *this;
-    }
-    BufferCopy& setSrcOffset( DeviceSize srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    BufferCopy& setDstOffset( DeviceSize dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    BufferCopy& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator const VkBufferCopy&() const
-    {
-      return *reinterpret_cast<const VkBufferCopy*>(this);
-    }
-
-    bool operator==( BufferCopy const& rhs ) const
-    {
-      return ( srcOffset == rhs.srcOffset )
-          && ( dstOffset == rhs.dstOffset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( BufferCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize srcOffset;
-    DeviceSize dstOffset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" );
-
-  struct SpecializationMapEntry
-  {
-    SpecializationMapEntry( uint32_t constantID_ = 0, uint32_t offset_ = 0, size_t size_ = 0 )
-      : constantID( constantID_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    SpecializationMapEntry( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-    }
-
-    SpecializationMapEntry& operator=( VkSpecializationMapEntry const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationMapEntry ) );
-      return *this;
-    }
-    SpecializationMapEntry& setConstantID( uint32_t constantID_ )
-    {
-      constantID = constantID_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    SpecializationMapEntry& setSize( size_t size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator const VkSpecializationMapEntry&() const
-    {
-      return *reinterpret_cast<const VkSpecializationMapEntry*>(this);
-    }
-
-    bool operator==( SpecializationMapEntry const& rhs ) const
-    {
-      return ( constantID == rhs.constantID )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( SpecializationMapEntry const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t constantID;
-    uint32_t offset;
-    size_t size;
-  };
-  static_assert( sizeof( SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), "struct and wrapper have different size!" );
-
-  struct SpecializationInfo
-  {
-    SpecializationInfo( uint32_t mapEntryCount_ = 0, const SpecializationMapEntry* pMapEntries_ = nullptr, size_t dataSize_ = 0, const void* pData_ = nullptr )
-      : mapEntryCount( mapEntryCount_ )
-      , pMapEntries( pMapEntries_ )
-      , dataSize( dataSize_ )
-      , pData( pData_ )
-    {
-    }
-
-    SpecializationInfo( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-    }
-
-    SpecializationInfo& operator=( VkSpecializationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SpecializationInfo ) );
-      return *this;
-    }
-    SpecializationInfo& setMapEntryCount( uint32_t mapEntryCount_ )
-    {
-      mapEntryCount = mapEntryCount_;
-      return *this;
-    }
-
-    SpecializationInfo& setPMapEntries( const SpecializationMapEntry* pMapEntries_ )
-    {
-      pMapEntries = pMapEntries_;
-      return *this;
-    }
-
-    SpecializationInfo& setDataSize( size_t dataSize_ )
-    {
-      dataSize = dataSize_;
-      return *this;
-    }
-
-    SpecializationInfo& setPData( const void* pData_ )
-    {
-      pData = pData_;
-      return *this;
-    }
-
-    operator const VkSpecializationInfo&() const
-    {
-      return *reinterpret_cast<const VkSpecializationInfo*>(this);
-    }
-
-    bool operator==( SpecializationInfo const& rhs ) const
-    {
-      return ( mapEntryCount == rhs.mapEntryCount )
-          && ( pMapEntries == rhs.pMapEntries )
-          && ( dataSize == rhs.dataSize )
-          && ( pData == rhs.pData );
-    }
-
-    bool operator!=( SpecializationInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t mapEntryCount;
-    const SpecializationMapEntry* pMapEntries;
-    size_t dataSize;
-    const void* pData;
-  };
-  static_assert( sizeof( SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" );
-
-  union ClearColorValue
-  {
-    ClearColorValue( const std::array<float,4>& float32_ = { {0} } )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-    }
-
-    ClearColorValue( const std::array<int32_t,4>& int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-    }
-
-    ClearColorValue( const std::array<uint32_t,4>& uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-    }
-
-    ClearColorValue& setFloat32( std::array<float,4> float32_ )
-    {
-      memcpy( &float32, float32_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    ClearColorValue& setInt32( std::array<int32_t,4> int32_ )
-    {
-      memcpy( &int32, int32_.data(), 4 * sizeof( int32_t ) );
-      return *this;
-    }
-
-    ClearColorValue& setUint32( std::array<uint32_t,4> uint32_ )
-    {
-      memcpy( &uint32, uint32_.data(), 4 * sizeof( uint32_t ) );
-      return *this;
-    }
-
-    operator VkClearColorValue const& () const
-    {
-      return *reinterpret_cast<const VkClearColorValue*>(this);
-    }
-
-    float float32[4];
-    int32_t int32[4];
-    uint32_t uint32[4];
-  };
-
-  struct ClearDepthStencilValue
-  {
-    ClearDepthStencilValue( float depth_ = 0, uint32_t stencil_ = 0 )
-      : depth( depth_ )
-      , stencil( stencil_ )
-    {
-    }
-
-    ClearDepthStencilValue( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-    }
-
-    ClearDepthStencilValue& operator=( VkClearDepthStencilValue const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearDepthStencilValue ) );
-      return *this;
-    }
-    ClearDepthStencilValue& setDepth( float depth_ )
-    {
-      depth = depth_;
-      return *this;
-    }
-
-    ClearDepthStencilValue& setStencil( uint32_t stencil_ )
-    {
-      stencil = stencil_;
-      return *this;
-    }
-
-    operator const VkClearDepthStencilValue&() const
-    {
-      return *reinterpret_cast<const VkClearDepthStencilValue*>(this);
-    }
-
-    bool operator==( ClearDepthStencilValue const& rhs ) const
-    {
-      return ( depth == rhs.depth )
-          && ( stencil == rhs.stencil );
-    }
-
-    bool operator!=( ClearDepthStencilValue const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float depth;
-    uint32_t stencil;
-  };
-  static_assert( sizeof( ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), "struct and wrapper have different size!" );
-
-  union ClearValue
-  {
-    ClearValue( ClearColorValue color_ = ClearColorValue() )
-    {
-      color = color_;
-    }
-
-    ClearValue( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-    }
-
-    ClearValue& setColor( ClearColorValue color_ )
-    {
-      color = color_;
-      return *this;
-    }
-
-    ClearValue& setDepthStencil( ClearDepthStencilValue depthStencil_ )
-    {
-      depthStencil = depthStencil_;
-      return *this;
-    }
-
-    operator VkClearValue const& () const
-    {
-      return *reinterpret_cast<const VkClearValue*>(this);
-    }
-
-#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-    ClearColorValue color;
-    ClearDepthStencilValue depthStencil;
-#else
-    VkClearColorValue color;
-    VkClearDepthStencilValue depthStencil;
-#endif  // VULKAN_HPP_HAS_UNRESTRICTED_UNIONS
-  };
-
-  struct PhysicalDeviceFeatures
-  {
-    PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = 0, Bool32 fullDrawIndexUint32_ = 0, Bool32 imageCubeArray_ = 0, Bool32 independentBlend_ = 0, Bool32 geometryShader_ = 0, Bool32 tessellationShader_ = 0, Bool32 sampleRateShading_ = 0, Bool32 dualSrcBlend_ = 0, Bool32 logicOp_ = 0, Bool32 multiDrawIndirect_ = 0, Bool32 drawIndirectFirstInstance_ = 0, Bool32 depthClamp_ = 0, Bool32 depthBiasClamp_ = 0, Bool32 fillModeNonSolid_ = 0, Bool32 depthBounds_ = 0, Bool32 wideLines_ = 0, Bool32 largePoints_ = 0, Bool32 alphaToOne_ = 0, Bool32 multiViewport_ = 0, Bool32 samplerAnisotropy_ = 0, Bool32 textureCompressionETC2_ = 0, Bool32 textureCompressionASTC_LDR_ = 0, Bool32 textureCompressionBC_ = 0, Bool32 occlusionQueryPrecise_ = 0, Bool32 pipelineStatisticsQuery_ = 0, Bool32 vertexPipelineStoresAndAtomics_ = 0, Bool32 fragmentStoresAndAtomics_ = 0, Bool32 shaderTessellationAndGeometryPointSize_ = 0, Bool32 shaderImageGatherExtended_ = 0, Bool32 shaderStorageImageExtendedFormats_ = 0, Bool32 shaderStorageImageMultisample_ = 0, Bool32 shaderStorageImageReadWithoutFormat_ = 0, Bool32 shaderStorageImageWriteWithoutFormat_ = 0, Bool32 shaderUniformBufferArrayDynamicIndexing_ = 0, Bool32 shaderSampledImageArrayDynamicIndexing_ = 0, Bool32 shaderStorageBufferArrayDynamicIndexing_ = 0, Bool32 shaderStorageImageArrayDynamicIndexing_ = 0, Bool32 shaderClipDistance_ = 0, Bool32 shaderCullDistance_ = 0, Bool32 shaderFloat64_ = 0, Bool32 shaderInt64_ = 0, Bool32 shaderInt16_ = 0, Bool32 shaderResourceResidency_ = 0, Bool32 shaderResourceMinLod_ = 0, Bool32 sparseBinding_ = 0, Bool32 sparseResidencyBuffer_ = 0, Bool32 sparseResidencyImage2D_ = 0, Bool32 sparseResidencyImage3D_ = 0, Bool32 sparseResidency2Samples_ = 0, Bool32 sparseResidency4Samples_ = 0, Bool32 sparseResidency8Samples_ = 0, Bool32 sparseResidency16Samples_ = 0, Bool32 sparseResidencyAliased_ = 0, Bool32 variableMultisampleRate_ = 0, Bool32 inheritedQueries_ = 0 )
-      : robustBufferAccess( robustBufferAccess_ )
-      , fullDrawIndexUint32( fullDrawIndexUint32_ )
-      , imageCubeArray( imageCubeArray_ )
-      , independentBlend( independentBlend_ )
-      , geometryShader( geometryShader_ )
-      , tessellationShader( tessellationShader_ )
-      , sampleRateShading( sampleRateShading_ )
-      , dualSrcBlend( dualSrcBlend_ )
-      , logicOp( logicOp_ )
-      , multiDrawIndirect( multiDrawIndirect_ )
-      , drawIndirectFirstInstance( drawIndirectFirstInstance_ )
-      , depthClamp( depthClamp_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , fillModeNonSolid( fillModeNonSolid_ )
-      , depthBounds( depthBounds_ )
-      , wideLines( wideLines_ )
-      , largePoints( largePoints_ )
-      , alphaToOne( alphaToOne_ )
-      , multiViewport( multiViewport_ )
-      , samplerAnisotropy( samplerAnisotropy_ )
-      , textureCompressionETC2( textureCompressionETC2_ )
-      , textureCompressionASTC_LDR( textureCompressionASTC_LDR_ )
-      , textureCompressionBC( textureCompressionBC_ )
-      , occlusionQueryPrecise( occlusionQueryPrecise_ )
-      , pipelineStatisticsQuery( pipelineStatisticsQuery_ )
-      , vertexPipelineStoresAndAtomics( vertexPipelineStoresAndAtomics_ )
-      , fragmentStoresAndAtomics( fragmentStoresAndAtomics_ )
-      , shaderTessellationAndGeometryPointSize( shaderTessellationAndGeometryPointSize_ )
-      , shaderImageGatherExtended( shaderImageGatherExtended_ )
-      , shaderStorageImageExtendedFormats( shaderStorageImageExtendedFormats_ )
-      , shaderStorageImageMultisample( shaderStorageImageMultisample_ )
-      , shaderStorageImageReadWithoutFormat( shaderStorageImageReadWithoutFormat_ )
-      , shaderStorageImageWriteWithoutFormat( shaderStorageImageWriteWithoutFormat_ )
-      , shaderUniformBufferArrayDynamicIndexing( shaderUniformBufferArrayDynamicIndexing_ )
-      , shaderSampledImageArrayDynamicIndexing( shaderSampledImageArrayDynamicIndexing_ )
-      , shaderStorageBufferArrayDynamicIndexing( shaderStorageBufferArrayDynamicIndexing_ )
-      , shaderStorageImageArrayDynamicIndexing( shaderStorageImageArrayDynamicIndexing_ )
-      , shaderClipDistance( shaderClipDistance_ )
-      , shaderCullDistance( shaderCullDistance_ )
-      , shaderFloat64( shaderFloat64_ )
-      , shaderInt64( shaderInt64_ )
-      , shaderInt16( shaderInt16_ )
-      , shaderResourceResidency( shaderResourceResidency_ )
-      , shaderResourceMinLod( shaderResourceMinLod_ )
-      , sparseBinding( sparseBinding_ )
-      , sparseResidencyBuffer( sparseResidencyBuffer_ )
-      , sparseResidencyImage2D( sparseResidencyImage2D_ )
-      , sparseResidencyImage3D( sparseResidencyImage3D_ )
-      , sparseResidency2Samples( sparseResidency2Samples_ )
-      , sparseResidency4Samples( sparseResidency4Samples_ )
-      , sparseResidency8Samples( sparseResidency8Samples_ )
-      , sparseResidency16Samples( sparseResidency16Samples_ )
-      , sparseResidencyAliased( sparseResidencyAliased_ )
-      , variableMultisampleRate( variableMultisampleRate_ )
-      , inheritedQueries( inheritedQueries_ )
-    {
-    }
-
-    PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-    }
-
-    PhysicalDeviceFeatures& operator=( VkPhysicalDeviceFeatures const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures ) );
-      return *this;
-    }
-    PhysicalDeviceFeatures& setRobustBufferAccess( Bool32 robustBufferAccess_ )
-    {
-      robustBufferAccess = robustBufferAccess_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ )
-    {
-      fullDrawIndexUint32 = fullDrawIndexUint32_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setImageCubeArray( Bool32 imageCubeArray_ )
-    {
-      imageCubeArray = imageCubeArray_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setIndependentBlend( Bool32 independentBlend_ )
-    {
-      independentBlend = independentBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setGeometryShader( Bool32 geometryShader_ )
-    {
-      geometryShader = geometryShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTessellationShader( Bool32 tessellationShader_ )
-    {
-      tessellationShader = tessellationShader_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSampleRateShading( Bool32 sampleRateShading_ )
-    {
-      sampleRateShading = sampleRateShading_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDualSrcBlend( Bool32 dualSrcBlend_ )
-    {
-      dualSrcBlend = dualSrcBlend_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLogicOp( Bool32 logicOp_ )
-    {
-      logicOp = logicOp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiDrawIndirect( Bool32 multiDrawIndirect_ )
-    {
-      multiDrawIndirect = multiDrawIndirect_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ )
-    {
-      drawIndirectFirstInstance = drawIndirectFirstInstance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthClamp( Bool32 depthClamp_ )
-    {
-      depthClamp = depthClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBiasClamp( Bool32 depthBiasClamp_ )
-    {
-      depthBiasClamp = depthBiasClamp_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFillModeNonSolid( Bool32 fillModeNonSolid_ )
-    {
-      fillModeNonSolid = fillModeNonSolid_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setDepthBounds( Bool32 depthBounds_ )
-    {
-      depthBounds = depthBounds_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setWideLines( Bool32 wideLines_ )
-    {
-      wideLines = wideLines_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setLargePoints( Bool32 largePoints_ )
-    {
-      largePoints = largePoints_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setAlphaToOne( Bool32 alphaToOne_ )
-    {
-      alphaToOne = alphaToOne_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setMultiViewport( Bool32 multiViewport_ )
-    {
-      multiViewport = multiViewport_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSamplerAnisotropy( Bool32 samplerAnisotropy_ )
-    {
-      samplerAnisotropy = samplerAnisotropy_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionETC2( Bool32 textureCompressionETC2_ )
-    {
-      textureCompressionETC2 = textureCompressionETC2_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ )
-    {
-      textureCompressionASTC_LDR = textureCompressionASTC_LDR_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setTextureCompressionBC( Bool32 textureCompressionBC_ )
-    {
-      textureCompressionBC = textureCompressionBC_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ )
-    {
-      occlusionQueryPrecise = occlusionQueryPrecise_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ )
-    {
-      pipelineStatisticsQuery = pipelineStatisticsQuery_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ )
-    {
-      vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ )
-    {
-      fragmentStoresAndAtomics = fragmentStoresAndAtomics_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ )
-    {
-      shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ )
-    {
-      shaderImageGatherExtended = shaderImageGatherExtended_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ )
-    {
-      shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ )
-    {
-      shaderStorageImageMultisample = shaderStorageImageMultisample_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ )
-    {
-      shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ )
-    {
-      shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ )
-    {
-      shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ )
-    {
-      shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ )
-    {
-      shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ )
-    {
-      shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderClipDistance( Bool32 shaderClipDistance_ )
-    {
-      shaderClipDistance = shaderClipDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderCullDistance( Bool32 shaderCullDistance_ )
-    {
-      shaderCullDistance = shaderCullDistance_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderFloat64( Bool32 shaderFloat64_ )
-    {
-      shaderFloat64 = shaderFloat64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt64( Bool32 shaderInt64_ )
-    {
-      shaderInt64 = shaderInt64_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderInt16( Bool32 shaderInt16_ )
-    {
-      shaderInt16 = shaderInt16_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceResidency( Bool32 shaderResourceResidency_ )
-    {
-      shaderResourceResidency = shaderResourceResidency_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setShaderResourceMinLod( Bool32 shaderResourceMinLod_ )
-    {
-      shaderResourceMinLod = shaderResourceMinLod_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseBinding( Bool32 sparseBinding_ )
-    {
-      sparseBinding = sparseBinding_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ )
-    {
-      sparseResidencyBuffer = sparseResidencyBuffer_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ )
-    {
-      sparseResidencyImage2D = sparseResidencyImage2D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ )
-    {
-      sparseResidencyImage3D = sparseResidencyImage3D_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency2Samples( Bool32 sparseResidency2Samples_ )
-    {
-      sparseResidency2Samples = sparseResidency2Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency4Samples( Bool32 sparseResidency4Samples_ )
-    {
-      sparseResidency4Samples = sparseResidency4Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency8Samples( Bool32 sparseResidency8Samples_ )
-    {
-      sparseResidency8Samples = sparseResidency8Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidency16Samples( Bool32 sparseResidency16Samples_ )
-    {
-      sparseResidency16Samples = sparseResidency16Samples_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setSparseResidencyAliased( Bool32 sparseResidencyAliased_ )
-    {
-      sparseResidencyAliased = sparseResidencyAliased_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setVariableMultisampleRate( Bool32 variableMultisampleRate_ )
-    {
-      variableMultisampleRate = variableMultisampleRate_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures& setInheritedQueries( Bool32 inheritedQueries_ )
-    {
-      inheritedQueries = inheritedQueries_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceFeatures&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFeatures*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return ( robustBufferAccess == rhs.robustBufferAccess )
-          && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 )
-          && ( imageCubeArray == rhs.imageCubeArray )
-          && ( independentBlend == rhs.independentBlend )
-          && ( geometryShader == rhs.geometryShader )
-          && ( tessellationShader == rhs.tessellationShader )
-          && ( sampleRateShading == rhs.sampleRateShading )
-          && ( dualSrcBlend == rhs.dualSrcBlend )
-          && ( logicOp == rhs.logicOp )
-          && ( multiDrawIndirect == rhs.multiDrawIndirect )
-          && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance )
-          && ( depthClamp == rhs.depthClamp )
-          && ( depthBiasClamp == rhs.depthBiasClamp )
-          && ( fillModeNonSolid == rhs.fillModeNonSolid )
-          && ( depthBounds == rhs.depthBounds )
-          && ( wideLines == rhs.wideLines )
-          && ( largePoints == rhs.largePoints )
-          && ( alphaToOne == rhs.alphaToOne )
-          && ( multiViewport == rhs.multiViewport )
-          && ( samplerAnisotropy == rhs.samplerAnisotropy )
-          && ( textureCompressionETC2 == rhs.textureCompressionETC2 )
-          && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR )
-          && ( textureCompressionBC == rhs.textureCompressionBC )
-          && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise )
-          && ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery )
-          && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics )
-          && ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics )
-          && ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize )
-          && ( shaderImageGatherExtended == rhs.shaderImageGatherExtended )
-          && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats )
-          && ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample )
-          && ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat )
-          && ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat )
-          && ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing )
-          && ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing )
-          && ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing )
-          && ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing )
-          && ( shaderClipDistance == rhs.shaderClipDistance )
-          && ( shaderCullDistance == rhs.shaderCullDistance )
-          && ( shaderFloat64 == rhs.shaderFloat64 )
-          && ( shaderInt64 == rhs.shaderInt64 )
-          && ( shaderInt16 == rhs.shaderInt16 )
-          && ( shaderResourceResidency == rhs.shaderResourceResidency )
-          && ( shaderResourceMinLod == rhs.shaderResourceMinLod )
-          && ( sparseBinding == rhs.sparseBinding )
-          && ( sparseResidencyBuffer == rhs.sparseResidencyBuffer )
-          && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D )
-          && ( sparseResidencyImage3D == rhs.sparseResidencyImage3D )
-          && ( sparseResidency2Samples == rhs.sparseResidency2Samples )
-          && ( sparseResidency4Samples == rhs.sparseResidency4Samples )
-          && ( sparseResidency8Samples == rhs.sparseResidency8Samples )
-          && ( sparseResidency16Samples == rhs.sparseResidency16Samples )
-          && ( sparseResidencyAliased == rhs.sparseResidencyAliased )
-          && ( variableMultisampleRate == rhs.variableMultisampleRate )
-          && ( inheritedQueries == rhs.inheritedQueries );
-    }
-
-    bool operator!=( PhysicalDeviceFeatures const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 robustBufferAccess;
-    Bool32 fullDrawIndexUint32;
-    Bool32 imageCubeArray;
-    Bool32 independentBlend;
-    Bool32 geometryShader;
-    Bool32 tessellationShader;
-    Bool32 sampleRateShading;
-    Bool32 dualSrcBlend;
-    Bool32 logicOp;
-    Bool32 multiDrawIndirect;
-    Bool32 drawIndirectFirstInstance;
-    Bool32 depthClamp;
-    Bool32 depthBiasClamp;
-    Bool32 fillModeNonSolid;
-    Bool32 depthBounds;
-    Bool32 wideLines;
-    Bool32 largePoints;
-    Bool32 alphaToOne;
-    Bool32 multiViewport;
-    Bool32 samplerAnisotropy;
-    Bool32 textureCompressionETC2;
-    Bool32 textureCompressionASTC_LDR;
-    Bool32 textureCompressionBC;
-    Bool32 occlusionQueryPrecise;
-    Bool32 pipelineStatisticsQuery;
-    Bool32 vertexPipelineStoresAndAtomics;
-    Bool32 fragmentStoresAndAtomics;
-    Bool32 shaderTessellationAndGeometryPointSize;
-    Bool32 shaderImageGatherExtended;
-    Bool32 shaderStorageImageExtendedFormats;
-    Bool32 shaderStorageImageMultisample;
-    Bool32 shaderStorageImageReadWithoutFormat;
-    Bool32 shaderStorageImageWriteWithoutFormat;
-    Bool32 shaderUniformBufferArrayDynamicIndexing;
-    Bool32 shaderSampledImageArrayDynamicIndexing;
-    Bool32 shaderStorageBufferArrayDynamicIndexing;
-    Bool32 shaderStorageImageArrayDynamicIndexing;
-    Bool32 shaderClipDistance;
-    Bool32 shaderCullDistance;
-    Bool32 shaderFloat64;
-    Bool32 shaderInt64;
-    Bool32 shaderInt16;
-    Bool32 shaderResourceResidency;
-    Bool32 shaderResourceMinLod;
-    Bool32 sparseBinding;
-    Bool32 sparseResidencyBuffer;
-    Bool32 sparseResidencyImage2D;
-    Bool32 sparseResidencyImage3D;
-    Bool32 sparseResidency2Samples;
-    Bool32 sparseResidency4Samples;
-    Bool32 sparseResidency8Samples;
-    Bool32 sparseResidency16Samples;
-    Bool32 sparseResidencyAliased;
-    Bool32 variableMultisampleRate;
-    Bool32 inheritedQueries;
-  };
-  static_assert( sizeof( PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSparseProperties
-  {
-    operator const VkPhysicalDeviceSparseProperties&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSparseProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape )
-          && ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape )
-          && ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape )
-          && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize )
-          && ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
-    }
-
-    bool operator!=( PhysicalDeviceSparseProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 residencyStandard2DBlockShape;
-    Bool32 residencyStandard2DMultisampleBlockShape;
-    Bool32 residencyStandard3DBlockShape;
-    Bool32 residencyAlignedMipSize;
-    Bool32 residencyNonResidentStrict;
-  };
-  static_assert( sizeof( PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), "struct and wrapper have different size!" );
-
-  struct DrawIndirectCommand
-  {
-    DrawIndirectCommand( uint32_t vertexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstVertex_ = 0, uint32_t firstInstance_ = 0 )
-      : vertexCount( vertexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstVertex( firstVertex_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndirectCommand( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-    }
-
-    DrawIndirectCommand& operator=( VkDrawIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndirectCommand ) );
-      return *this;
-    }
-    DrawIndirectCommand& setVertexCount( uint32_t vertexCount_ )
-    {
-      vertexCount = vertexCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstVertex( uint32_t firstVertex_ )
-    {
-      firstVertex = firstVertex_;
-      return *this;
-    }
-
-    DrawIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator const VkDrawIndirectCommand&() const
-    {
-      return *reinterpret_cast<const VkDrawIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndirectCommand const& rhs ) const
-    {
-      return ( vertexCount == rhs.vertexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstVertex == rhs.firstVertex )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t vertexCount;
-    uint32_t instanceCount;
-    uint32_t firstVertex;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DrawIndexedIndirectCommand
-  {
-    DrawIndexedIndirectCommand( uint32_t indexCount_ = 0, uint32_t instanceCount_ = 0, uint32_t firstIndex_ = 0, int32_t vertexOffset_ = 0, uint32_t firstInstance_ = 0 )
-      : indexCount( indexCount_ )
-      , instanceCount( instanceCount_ )
-      , firstIndex( firstIndex_ )
-      , vertexOffset( vertexOffset_ )
-      , firstInstance( firstInstance_ )
-    {
-    }
-
-    DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-    }
-
-    DrawIndexedIndirectCommand& operator=( VkDrawIndexedIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DrawIndexedIndirectCommand ) );
-      return *this;
-    }
-    DrawIndexedIndirectCommand& setIndexCount( uint32_t indexCount_ )
-    {
-      indexCount = indexCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setInstanceCount( uint32_t instanceCount_ )
-    {
-      instanceCount = instanceCount_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstIndex( uint32_t firstIndex_ )
-    {
-      firstIndex = firstIndex_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setVertexOffset( int32_t vertexOffset_ )
-    {
-      vertexOffset = vertexOffset_;
-      return *this;
-    }
-
-    DrawIndexedIndirectCommand& setFirstInstance( uint32_t firstInstance_ )
-    {
-      firstInstance = firstInstance_;
-      return *this;
-    }
-
-    operator const VkDrawIndexedIndirectCommand&() const
-    {
-      return *reinterpret_cast<const VkDrawIndexedIndirectCommand*>(this);
-    }
-
-    bool operator==( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return ( indexCount == rhs.indexCount )
-          && ( instanceCount == rhs.instanceCount )
-          && ( firstIndex == rhs.firstIndex )
-          && ( vertexOffset == rhs.vertexOffset )
-          && ( firstInstance == rhs.firstInstance );
-    }
-
-    bool operator!=( DrawIndexedIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t indexCount;
-    uint32_t instanceCount;
-    uint32_t firstIndex;
-    int32_t vertexOffset;
-    uint32_t firstInstance;
-  };
-  static_assert( sizeof( DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DispatchIndirectCommand
-  {
-    DispatchIndirectCommand( uint32_t x_ = 0, uint32_t y_ = 0, uint32_t z_ = 0 )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-    {
-    }
-
-    DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-    }
-
-    DispatchIndirectCommand& operator=( VkDispatchIndirectCommand const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DispatchIndirectCommand ) );
-      return *this;
-    }
-    DispatchIndirectCommand& setX( uint32_t x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setY( uint32_t y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    DispatchIndirectCommand& setZ( uint32_t z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    operator const VkDispatchIndirectCommand&() const
-    {
-      return *reinterpret_cast<const VkDispatchIndirectCommand*>(this);
-    }
-
-    bool operator==( DispatchIndirectCommand const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z );
-    }
-
-    bool operator!=( DispatchIndirectCommand const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t x;
-    uint32_t y;
-    uint32_t z;
-  };
-  static_assert( sizeof( DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), "struct and wrapper have different size!" );
-
-  struct DisplayPlanePropertiesKHR
-  {
-    operator const VkDisplayPlanePropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlanePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return ( currentDisplay == rhs.currentDisplay )
-          && ( currentStackIndex == rhs.currentStackIndex );
-    }
-
-    bool operator!=( DisplayPlanePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayKHR currentDisplay;
-    uint32_t currentStackIndex;
-  };
-  static_assert( sizeof( DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModeParametersKHR
-  {
-    DisplayModeParametersKHR( Extent2D visibleRegion_ = Extent2D(), uint32_t refreshRate_ = 0 )
-      : visibleRegion( visibleRegion_ )
-      , refreshRate( refreshRate_ )
-    {
-    }
-
-    DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-    }
-
-    DisplayModeParametersKHR& operator=( VkDisplayModeParametersKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeParametersKHR ) );
-      return *this;
-    }
-    DisplayModeParametersKHR& setVisibleRegion( Extent2D visibleRegion_ )
-    {
-      visibleRegion = visibleRegion_;
-      return *this;
-    }
-
-    DisplayModeParametersKHR& setRefreshRate( uint32_t refreshRate_ )
-    {
-      refreshRate = refreshRate_;
-      return *this;
-    }
-
-    operator const VkDisplayModeParametersKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayModeParametersKHR*>(this);
-    }
-
-    bool operator==( DisplayModeParametersKHR const& rhs ) const
-    {
-      return ( visibleRegion == rhs.visibleRegion )
-          && ( refreshRate == rhs.refreshRate );
-    }
-
-    bool operator!=( DisplayModeParametersKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Extent2D visibleRegion;
-    uint32_t refreshRate;
-  };
-  static_assert( sizeof( DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayModePropertiesKHR
-  {
-    operator const VkDisplayModePropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayModePropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return ( displayMode == rhs.displayMode )
-          && ( parameters == rhs.parameters );
-    }
-
-    bool operator!=( DisplayModePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayModeKHR displayMode;
-    DisplayModeParametersKHR parameters;
-  };
-  static_assert( sizeof( DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct RectLayerKHR
-  {
-    RectLayerKHR( Offset2D offset_ = Offset2D(), Extent2D extent_ = Extent2D(), uint32_t layer_ = 0 )
-      : offset( offset_ )
-      , extent( extent_ )
-      , layer( layer_ )
-    {
-    }
-
-    RectLayerKHR( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-    }
-
-    RectLayerKHR& operator=( VkRectLayerKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RectLayerKHR ) );
-      return *this;
-    }
-    RectLayerKHR& setOffset( Offset2D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    RectLayerKHR& setExtent( Extent2D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    RectLayerKHR& setLayer( uint32_t layer_ )
-    {
-      layer = layer_;
-      return *this;
-    }
-
-    operator const VkRectLayerKHR&() const
-    {
-      return *reinterpret_cast<const VkRectLayerKHR*>(this);
-    }
-
-    bool operator==( RectLayerKHR const& rhs ) const
-    {
-      return ( offset == rhs.offset )
-          && ( extent == rhs.extent )
-          && ( layer == rhs.layer );
-    }
-
-    bool operator!=( RectLayerKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Offset2D offset;
-    Extent2D extent;
-    uint32_t layer;
-  };
-  static_assert( sizeof( RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" );
-
-  struct PresentRegionKHR
-  {
-    PresentRegionKHR( uint32_t rectangleCount_ = 0, const RectLayerKHR* pRectangles_ = nullptr )
-      : rectangleCount( rectangleCount_ )
-      , pRectangles( pRectangles_ )
-    {
-    }
-
-    PresentRegionKHR( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-    }
-
-    PresentRegionKHR& operator=( VkPresentRegionKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionKHR ) );
-      return *this;
-    }
-    PresentRegionKHR& setRectangleCount( uint32_t rectangleCount_ )
-    {
-      rectangleCount = rectangleCount_;
-      return *this;
-    }
-
-    PresentRegionKHR& setPRectangles( const RectLayerKHR* pRectangles_ )
-    {
-      pRectangles = pRectangles_;
-      return *this;
-    }
-
-    operator const VkPresentRegionKHR&() const
-    {
-      return *reinterpret_cast<const VkPresentRegionKHR*>(this);
-    }
-
-    bool operator==( PresentRegionKHR const& rhs ) const
-    {
-      return ( rectangleCount == rhs.rectangleCount )
-          && ( pRectangles == rhs.pRectangles );
-    }
-
-    bool operator!=( PresentRegionKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t rectangleCount;
-    const RectLayerKHR* pRectangles;
-  };
-  static_assert( sizeof( PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" );
-
-  struct XYColorEXT
-  {
-    XYColorEXT( float x_ = 0, float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    XYColorEXT( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-    }
-
-    XYColorEXT& operator=( VkXYColorEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XYColorEXT ) );
-      return *this;
-    }
-    XYColorEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    XYColorEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator const VkXYColorEXT&() const
-    {
-      return *reinterpret_cast<const VkXYColorEXT*>(this);
-    }
-
-    bool operator==( XYColorEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( XYColorEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" );
-
-  struct RefreshCycleDurationGOOGLE
-  {
-    RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = 0 )
-      : refreshDuration( refreshDuration_ )
-    {
-    }
-
-    RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
-    }
-
-    RefreshCycleDurationGOOGLE& operator=( VkRefreshCycleDurationGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RefreshCycleDurationGOOGLE ) );
-      return *this;
-    }
-    RefreshCycleDurationGOOGLE& setRefreshDuration( uint64_t refreshDuration_ )
-    {
-      refreshDuration = refreshDuration_;
-      return *this;
-    }
-
-    operator const VkRefreshCycleDurationGOOGLE&() const
-    {
-      return *reinterpret_cast<const VkRefreshCycleDurationGOOGLE*>(this);
-    }
-
-    bool operator==( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return ( refreshDuration == rhs.refreshDuration );
-    }
-
-    bool operator!=( RefreshCycleDurationGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint64_t refreshDuration;
-  };
-  static_assert( sizeof( RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PastPresentationTimingGOOGLE
-  {
-    PastPresentationTimingGOOGLE( uint32_t presentID_ = 0, uint64_t desiredPresentTime_ = 0, uint64_t actualPresentTime_ = 0, uint64_t earliestPresentTime_ = 0, uint64_t presentMargin_ = 0 )
-      : presentID( presentID_ )
-      , desiredPresentTime( desiredPresentTime_ )
-      , actualPresentTime( actualPresentTime_ )
-      , earliestPresentTime( earliestPresentTime_ )
-      , presentMargin( presentMargin_ )
-    {
-    }
-
-    PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) );
-    }
-
-    PastPresentationTimingGOOGLE& operator=( VkPastPresentationTimingGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PastPresentationTimingGOOGLE ) );
-      return *this;
-    }
-    PastPresentationTimingGOOGLE& setPresentID( uint32_t presentID_ )
-    {
-      presentID = presentID_;
-      return *this;
-    }
-
-    PastPresentationTimingGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ )
-    {
-      desiredPresentTime = desiredPresentTime_;
-      return *this;
-    }
-
-    PastPresentationTimingGOOGLE& setActualPresentTime( uint64_t actualPresentTime_ )
-    {
-      actualPresentTime = actualPresentTime_;
-      return *this;
-    }
-
-    PastPresentationTimingGOOGLE& setEarliestPresentTime( uint64_t earliestPresentTime_ )
-    {
-      earliestPresentTime = earliestPresentTime_;
-      return *this;
-    }
-
-    PastPresentationTimingGOOGLE& setPresentMargin( uint64_t presentMargin_ )
-    {
-      presentMargin = presentMargin_;
-      return *this;
-    }
-
-    operator const VkPastPresentationTimingGOOGLE&() const
-    {
-      return *reinterpret_cast<const VkPastPresentationTimingGOOGLE*>(this);
-    }
-
-    bool operator==( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime )
-          && ( actualPresentTime == rhs.actualPresentTime )
-          && ( earliestPresentTime == rhs.earliestPresentTime )
-          && ( presentMargin == rhs.presentMargin );
-    }
-
-    bool operator!=( PastPresentationTimingGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-    uint64_t actualPresentTime;
-    uint64_t earliestPresentTime;
-    uint64_t presentMargin;
-  };
-  static_assert( sizeof( PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), "struct and wrapper have different size!" );
-
-  struct PresentTimeGOOGLE
-  {
-    PresentTimeGOOGLE( uint32_t presentID_ = 0, uint64_t desiredPresentTime_ = 0 )
-      : presentID( presentID_ )
-      , desiredPresentTime( desiredPresentTime_ )
-    {
-    }
-
-    PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-    }
-
-    PresentTimeGOOGLE& operator=( VkPresentTimeGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimeGOOGLE ) );
-      return *this;
-    }
-    PresentTimeGOOGLE& setPresentID( uint32_t presentID_ )
-    {
-      presentID = presentID_;
-      return *this;
-    }
-
-    PresentTimeGOOGLE& setDesiredPresentTime( uint64_t desiredPresentTime_ )
-    {
-      desiredPresentTime = desiredPresentTime_;
-      return *this;
-    }
-
-    operator const VkPresentTimeGOOGLE&() const
-    {
-      return *reinterpret_cast<const VkPresentTimeGOOGLE*>(this);
-    }
-
-    bool operator==( PresentTimeGOOGLE const& rhs ) const
-    {
-      return ( presentID == rhs.presentID )
-          && ( desiredPresentTime == rhs.desiredPresentTime );
-    }
-
-    bool operator!=( PresentTimeGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t presentID;
-    uint64_t desiredPresentTime;
-  };
-  static_assert( sizeof( PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" );
-
-  struct ViewportWScalingNV
-  {
-    ViewportWScalingNV( float xcoeff_ = 0, float ycoeff_ = 0 )
-      : xcoeff( xcoeff_ )
-      , ycoeff( ycoeff_ )
-    {
-    }
-
-    ViewportWScalingNV( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-    }
-
-    ViewportWScalingNV& operator=( VkViewportWScalingNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportWScalingNV ) );
-      return *this;
-    }
-    ViewportWScalingNV& setXcoeff( float xcoeff_ )
-    {
-      xcoeff = xcoeff_;
-      return *this;
-    }
-
-    ViewportWScalingNV& setYcoeff( float ycoeff_ )
-    {
-      ycoeff = ycoeff_;
-      return *this;
-    }
-
-    operator const VkViewportWScalingNV&() const
-    {
-      return *reinterpret_cast<const VkViewportWScalingNV*>(this);
-    }
-
-    bool operator==( ViewportWScalingNV const& rhs ) const
-    {
-      return ( xcoeff == rhs.xcoeff )
-          && ( ycoeff == rhs.ycoeff );
-    }
-
-    bool operator!=( ViewportWScalingNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float xcoeff;
-    float ycoeff;
-  };
-  static_assert( sizeof( ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" );
-
-  struct SampleLocationEXT
-  {
-    SampleLocationEXT( float x_ = 0, float y_ = 0 )
-      : x( x_ )
-      , y( y_ )
-    {
-    }
-
-    SampleLocationEXT( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-    }
-
-    SampleLocationEXT& operator=( VkSampleLocationEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationEXT ) );
-      return *this;
-    }
-    SampleLocationEXT& setX( float x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    SampleLocationEXT& setY( float y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    operator const VkSampleLocationEXT&() const
-    {
-      return *reinterpret_cast<const VkSampleLocationEXT*>(this);
-    }
-
-    bool operator==( SampleLocationEXT const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y );
-    }
-
-    bool operator!=( SampleLocationEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    float x;
-    float y;
-  };
-  static_assert( sizeof( SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" );
-
-  struct ShaderResourceUsageAMD
-  {
-    operator const VkShaderResourceUsageAMD&() const
-    {
-      return *reinterpret_cast<const VkShaderResourceUsageAMD*>(this);
-    }
-
-    bool operator==( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return ( numUsedVgprs == rhs.numUsedVgprs )
-          && ( numUsedSgprs == rhs.numUsedSgprs )
-          && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup )
-          && ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes )
-          && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
-    }
-
-    bool operator!=( ShaderResourceUsageAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t numUsedVgprs;
-    uint32_t numUsedSgprs;
-    uint32_t ldsSizePerLocalWorkGroup;
-    size_t ldsUsageSizeInBytes;
-    size_t scratchMemUsageInBytes;
-  };
-  static_assert( sizeof( ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), "struct and wrapper have different size!" );
-
-  enum class ImageLayout
-  {
-    eUndefined = VK_IMAGE_LAYOUT_UNDEFINED,
-    eGeneral = VK_IMAGE_LAYOUT_GENERAL,
-    eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-    eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
-    eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL,
-    eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-    eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-    eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-    ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED,
-    ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-    eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR,
-    eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR,
-    eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
-  };
-
-  struct DescriptorImageInfo
-  {
-    DescriptorImageInfo( Sampler sampler_ = Sampler(), ImageView imageView_ = ImageView(), ImageLayout imageLayout_ = ImageLayout::eUndefined )
-      : sampler( sampler_ )
-      , imageView( imageView_ )
-      , imageLayout( imageLayout_ )
-    {
-    }
-
-    DescriptorImageInfo( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-    }
-
-    DescriptorImageInfo& operator=( VkDescriptorImageInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorImageInfo ) );
-      return *this;
-    }
-    DescriptorImageInfo& setSampler( Sampler sampler_ )
-    {
-      sampler = sampler_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageView( ImageView imageView_ )
-    {
-      imageView = imageView_;
-      return *this;
-    }
-
-    DescriptorImageInfo& setImageLayout( ImageLayout imageLayout_ )
-    {
-      imageLayout = imageLayout_;
-      return *this;
-    }
-
-    operator const VkDescriptorImageInfo&() const
-    {
-      return *reinterpret_cast<const VkDescriptorImageInfo*>(this);
-    }
-
-    bool operator==( DescriptorImageInfo const& rhs ) const
-    {
-      return ( sampler == rhs.sampler )
-          && ( imageView == rhs.imageView )
-          && ( imageLayout == rhs.imageLayout );
-    }
-
-    bool operator!=( DescriptorImageInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Sampler sampler;
-    ImageView imageView;
-    ImageLayout imageLayout;
-  };
-  static_assert( sizeof( DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" );
-
-  struct AttachmentReference
-  {
-    AttachmentReference( uint32_t attachment_ = 0, ImageLayout layout_ = ImageLayout::eUndefined )
-      : attachment( attachment_ )
-      , layout( layout_ )
-    {
-    }
-
-    AttachmentReference( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-    }
-
-    AttachmentReference& operator=( VkAttachmentReference const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentReference ) );
-      return *this;
-    }
-    AttachmentReference& setAttachment( uint32_t attachment_ )
-    {
-      attachment = attachment_;
-      return *this;
-    }
-
-    AttachmentReference& setLayout( ImageLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    operator const VkAttachmentReference&() const
-    {
-      return *reinterpret_cast<const VkAttachmentReference*>(this);
-    }
-
-    bool operator==( AttachmentReference const& rhs ) const
-    {
-      return ( attachment == rhs.attachment )
-          && ( layout == rhs.layout );
-    }
-
-    bool operator!=( AttachmentReference const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t attachment;
-    ImageLayout layout;
-  };
-  static_assert( sizeof( AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" );
-
-  enum class AttachmentLoadOp
-  {
-    eLoad = VK_ATTACHMENT_LOAD_OP_LOAD,
-    eClear = VK_ATTACHMENT_LOAD_OP_CLEAR,
-    eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE
-  };
-
-  enum class AttachmentStoreOp
-  {
-    eStore = VK_ATTACHMENT_STORE_OP_STORE,
-    eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE
-  };
-
-  enum class ImageType
-  {
-    e1D = VK_IMAGE_TYPE_1D,
-    e2D = VK_IMAGE_TYPE_2D,
-    e3D = VK_IMAGE_TYPE_3D
-  };
-
-  enum class ImageTiling
-  {
-    eOptimal = VK_IMAGE_TILING_OPTIMAL,
-    eLinear = VK_IMAGE_TILING_LINEAR
-  };
-
-  enum class ImageViewType
-  {
-    e1D = VK_IMAGE_VIEW_TYPE_1D,
-    e2D = VK_IMAGE_VIEW_TYPE_2D,
-    e3D = VK_IMAGE_VIEW_TYPE_3D,
-    eCube = VK_IMAGE_VIEW_TYPE_CUBE,
-    e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY,
-    e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY,
-    eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY
-  };
-
-  enum class CommandBufferLevel
-  {
-    ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-    eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY
-  };
-
-  enum class ComponentSwizzle
-  {
-    eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY,
-    eZero = VK_COMPONENT_SWIZZLE_ZERO,
-    eOne = VK_COMPONENT_SWIZZLE_ONE,
-    eR = VK_COMPONENT_SWIZZLE_R,
-    eG = VK_COMPONENT_SWIZZLE_G,
-    eB = VK_COMPONENT_SWIZZLE_B,
-    eA = VK_COMPONENT_SWIZZLE_A
-  };
-
-  struct ComponentMapping
-  {
-    ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, ComponentSwizzle g_ = ComponentSwizzle::eIdentity, ComponentSwizzle b_ = ComponentSwizzle::eIdentity, ComponentSwizzle a_ = ComponentSwizzle::eIdentity )
-      : r( r_ )
-      , g( g_ )
-      , b( b_ )
-      , a( a_ )
-    {
-    }
-
-    ComponentMapping( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-    }
-
-    ComponentMapping& operator=( VkComponentMapping const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComponentMapping ) );
-      return *this;
-    }
-    ComponentMapping& setR( ComponentSwizzle r_ )
-    {
-      r = r_;
-      return *this;
-    }
-
-    ComponentMapping& setG( ComponentSwizzle g_ )
-    {
-      g = g_;
-      return *this;
-    }
-
-    ComponentMapping& setB( ComponentSwizzle b_ )
-    {
-      b = b_;
-      return *this;
-    }
-
-    ComponentMapping& setA( ComponentSwizzle a_ )
-    {
-      a = a_;
-      return *this;
-    }
-
-    operator const VkComponentMapping&() const
-    {
-      return *reinterpret_cast<const VkComponentMapping*>(this);
-    }
-
-    bool operator==( ComponentMapping const& rhs ) const
-    {
-      return ( r == rhs.r )
-          && ( g == rhs.g )
-          && ( b == rhs.b )
-          && ( a == rhs.a );
-    }
-
-    bool operator!=( ComponentMapping const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ComponentSwizzle r;
-    ComponentSwizzle g;
-    ComponentSwizzle b;
-    ComponentSwizzle a;
-  };
-  static_assert( sizeof( ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" );
-
-  enum class DescriptorType
-  {
-    eSampler = VK_DESCRIPTOR_TYPE_SAMPLER,
-    eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-    eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
-    eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
-    eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
-    eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-    eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
-    eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
-    eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
-    eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT
-  };
-
-  struct DescriptorPoolSize
-  {
-    DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0 )
-      : type( type_ )
-      , descriptorCount( descriptorCount_ )
-    {
-    }
-
-    DescriptorPoolSize( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-    }
-
-    DescriptorPoolSize& operator=( VkDescriptorPoolSize const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolSize ) );
-      return *this;
-    }
-    DescriptorPoolSize& setType( DescriptorType type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    DescriptorPoolSize& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    operator const VkDescriptorPoolSize&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolSize*>(this);
-    }
-
-    bool operator==( DescriptorPoolSize const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( descriptorCount == rhs.descriptorCount );
-    }
-
-    bool operator!=( DescriptorPoolSize const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DescriptorType type;
-    uint32_t descriptorCount;
-  };
-  static_assert( sizeof( DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" );
-
-  struct DescriptorUpdateTemplateEntryKHR
-  {
-    DescriptorUpdateTemplateEntryKHR( uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, size_t offset_ = 0, size_t stride_ = 0 )
-      : dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , offset( offset_ )
-      , stride( stride_ )
-    {
-    }
-
-    DescriptorUpdateTemplateEntryKHR( VkDescriptorUpdateTemplateEntryKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) );
-    }
-
-    DescriptorUpdateTemplateEntryKHR& operator=( VkDescriptorUpdateTemplateEntryKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateEntryKHR ) );
-      return *this;
-    }
-    DescriptorUpdateTemplateEntryKHR& setDstBinding( uint32_t dstBinding_ )
-    {
-      dstBinding = dstBinding_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntryKHR& setDstArrayElement( uint32_t dstArrayElement_ )
-    {
-      dstArrayElement = dstArrayElement_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntryKHR& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntryKHR& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntryKHR& setOffset( size_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateEntryKHR& setStride( size_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    operator const VkDescriptorUpdateTemplateEntryKHR&() const
-    {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateEntryKHR*>(this);
-    }
-
-    bool operator==( DescriptorUpdateTemplateEntryKHR const& rhs ) const
-    {
-      return ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( descriptorType == rhs.descriptorType )
-          && ( offset == rhs.offset )
-          && ( stride == rhs.stride );
-    }
-
-    bool operator!=( DescriptorUpdateTemplateEntryKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    size_t offset;
-    size_t stride;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateEntryKHR ) == sizeof( VkDescriptorUpdateTemplateEntryKHR ), "struct and wrapper have different size!" );
-
-  enum class QueryType
-  {
-    eOcclusion = VK_QUERY_TYPE_OCCLUSION,
-    ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS,
-    eTimestamp = VK_QUERY_TYPE_TIMESTAMP
-  };
-
-  enum class BorderColor
-  {
-    eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-    eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,
-    eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
-    eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
-    eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
-    eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE
-  };
-
-  enum class PipelineBindPoint
-  {
-    eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS,
-    eCompute = VK_PIPELINE_BIND_POINT_COMPUTE
-  };
-
-  enum class PipelineCacheHeaderVersion
-  {
-    eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE
-  };
-
-  enum class PrimitiveTopology
-  {
-    ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
-    eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST,
-    eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
-    eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-    eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
-    eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
-    eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY,
-    eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
-    eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY,
-    eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY,
-    ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST
-  };
-
-  enum class SharingMode
-  {
-    eExclusive = VK_SHARING_MODE_EXCLUSIVE,
-    eConcurrent = VK_SHARING_MODE_CONCURRENT
-  };
-
-  enum class IndexType
-  {
-    eUint16 = VK_INDEX_TYPE_UINT16,
-    eUint32 = VK_INDEX_TYPE_UINT32
-  };
-
-  enum class Filter
-  {
-    eNearest = VK_FILTER_NEAREST,
-    eLinear = VK_FILTER_LINEAR,
-    eCubicIMG = VK_FILTER_CUBIC_IMG
-  };
-
-  enum class SamplerMipmapMode
-  {
-    eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST,
-    eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR
-  };
-
-  enum class SamplerAddressMode
-  {
-    eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT,
-    eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
-    eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
-    eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-    eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE
-  };
-
-  enum class CompareOp
-  {
-    eNever = VK_COMPARE_OP_NEVER,
-    eLess = VK_COMPARE_OP_LESS,
-    eEqual = VK_COMPARE_OP_EQUAL,
-    eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL,
-    eGreater = VK_COMPARE_OP_GREATER,
-    eNotEqual = VK_COMPARE_OP_NOT_EQUAL,
-    eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL,
-    eAlways = VK_COMPARE_OP_ALWAYS
-  };
-
-  enum class PolygonMode
-  {
-    eFill = VK_POLYGON_MODE_FILL,
-    eLine = VK_POLYGON_MODE_LINE,
-    ePoint = VK_POLYGON_MODE_POINT,
-    eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV
-  };
-
-  enum class CullModeFlagBits
-  {
-    eNone = VK_CULL_MODE_NONE,
-    eFront = VK_CULL_MODE_FRONT_BIT,
-    eBack = VK_CULL_MODE_BACK_BIT,
-    eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK
-  };
-
-  using CullModeFlags = Flags<CullModeFlagBits, VkCullModeFlags>;
-
-  VULKAN_HPP_INLINE CullModeFlags operator|( CullModeFlagBits bit0, CullModeFlagBits bit1 )
-  {
-    return CullModeFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CullModeFlags operator~( CullModeFlagBits bits )
-  {
-    return ~( CullModeFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CullModeFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CullModeFlagBits::eNone) | VkFlags(CullModeFlagBits::eFront) | VkFlags(CullModeFlagBits::eBack) | VkFlags(CullModeFlagBits::eFrontAndBack)
-    };
-  };
-
-  enum class FrontFace
-  {
-    eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE,
-    eClockwise = VK_FRONT_FACE_CLOCKWISE
-  };
-
-  enum class BlendFactor
-  {
-    eZero = VK_BLEND_FACTOR_ZERO,
-    eOne = VK_BLEND_FACTOR_ONE,
-    eSrcColor = VK_BLEND_FACTOR_SRC_COLOR,
-    eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
-    eDstColor = VK_BLEND_FACTOR_DST_COLOR,
-    eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
-    eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA,
-    eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
-    eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA,
-    eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
-    eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR,
-    eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
-    eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA,
-    eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
-    eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
-    eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR,
-    eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR,
-    eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA,
-    eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
-  };
-
-  enum class BlendOp
-  {
-    eAdd = VK_BLEND_OP_ADD,
-    eSubtract = VK_BLEND_OP_SUBTRACT,
-    eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT,
-    eMin = VK_BLEND_OP_MIN,
-    eMax = VK_BLEND_OP_MAX,
-    eZeroEXT = VK_BLEND_OP_ZERO_EXT,
-    eSrcEXT = VK_BLEND_OP_SRC_EXT,
-    eDstEXT = VK_BLEND_OP_DST_EXT,
-    eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT,
-    eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT,
-    eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT,
-    eDstInEXT = VK_BLEND_OP_DST_IN_EXT,
-    eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT,
-    eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT,
-    eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT,
-    eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT,
-    eXorEXT = VK_BLEND_OP_XOR_EXT,
-    eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT,
-    eScreenEXT = VK_BLEND_OP_SCREEN_EXT,
-    eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT,
-    eDarkenEXT = VK_BLEND_OP_DARKEN_EXT,
-    eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT,
-    eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT,
-    eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT,
-    eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT,
-    eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT,
-    eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT,
-    eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT,
-    eInvertEXT = VK_BLEND_OP_INVERT_EXT,
-    eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT,
-    eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT,
-    eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT,
-    eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT,
-    eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT,
-    ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT,
-    eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT,
-    eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT,
-    eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT,
-    eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT,
-    eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT,
-    ePlusEXT = VK_BLEND_OP_PLUS_EXT,
-    ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT,
-    ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT,
-    ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT,
-    eMinusEXT = VK_BLEND_OP_MINUS_EXT,
-    eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT,
-    eContrastEXT = VK_BLEND_OP_CONTRAST_EXT,
-    eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT,
-    eRedEXT = VK_BLEND_OP_RED_EXT,
-    eGreenEXT = VK_BLEND_OP_GREEN_EXT,
-    eBlueEXT = VK_BLEND_OP_BLUE_EXT
-  };
-
-  enum class StencilOp
-  {
-    eKeep = VK_STENCIL_OP_KEEP,
-    eZero = VK_STENCIL_OP_ZERO,
-    eReplace = VK_STENCIL_OP_REPLACE,
-    eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP,
-    eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP,
-    eInvert = VK_STENCIL_OP_INVERT,
-    eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP,
-    eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP
-  };
-
-  struct StencilOpState
-  {
-    StencilOpState( StencilOp failOp_ = StencilOp::eKeep, StencilOp passOp_ = StencilOp::eKeep, StencilOp depthFailOp_ = StencilOp::eKeep, CompareOp compareOp_ = CompareOp::eNever, uint32_t compareMask_ = 0, uint32_t writeMask_ = 0, uint32_t reference_ = 0 )
-      : failOp( failOp_ )
-      , passOp( passOp_ )
-      , depthFailOp( depthFailOp_ )
-      , compareOp( compareOp_ )
-      , compareMask( compareMask_ )
-      , writeMask( writeMask_ )
-      , reference( reference_ )
-    {
-    }
-
-    StencilOpState( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-    }
-
-    StencilOpState& operator=( VkStencilOpState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( StencilOpState ) );
-      return *this;
-    }
-    StencilOpState& setFailOp( StencilOp failOp_ )
-    {
-      failOp = failOp_;
-      return *this;
-    }
-
-    StencilOpState& setPassOp( StencilOp passOp_ )
-    {
-      passOp = passOp_;
-      return *this;
-    }
-
-    StencilOpState& setDepthFailOp( StencilOp depthFailOp_ )
-    {
-      depthFailOp = depthFailOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareOp( CompareOp compareOp_ )
-    {
-      compareOp = compareOp_;
-      return *this;
-    }
-
-    StencilOpState& setCompareMask( uint32_t compareMask_ )
-    {
-      compareMask = compareMask_;
-      return *this;
-    }
-
-    StencilOpState& setWriteMask( uint32_t writeMask_ )
-    {
-      writeMask = writeMask_;
-      return *this;
-    }
-
-    StencilOpState& setReference( uint32_t reference_ )
-    {
-      reference = reference_;
-      return *this;
-    }
-
-    operator const VkStencilOpState&() const
-    {
-      return *reinterpret_cast<const VkStencilOpState*>(this);
-    }
-
-    bool operator==( StencilOpState const& rhs ) const
-    {
-      return ( failOp == rhs.failOp )
-          && ( passOp == rhs.passOp )
-          && ( depthFailOp == rhs.depthFailOp )
-          && ( compareOp == rhs.compareOp )
-          && ( compareMask == rhs.compareMask )
-          && ( writeMask == rhs.writeMask )
-          && ( reference == rhs.reference );
-    }
-
-    bool operator!=( StencilOpState const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    StencilOp failOp;
-    StencilOp passOp;
-    StencilOp depthFailOp;
-    CompareOp compareOp;
-    uint32_t compareMask;
-    uint32_t writeMask;
-    uint32_t reference;
-  };
-  static_assert( sizeof( StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" );
-
-  enum class LogicOp
-  {
-    eClear = VK_LOGIC_OP_CLEAR,
-    eAnd = VK_LOGIC_OP_AND,
-    eAndReverse = VK_LOGIC_OP_AND_REVERSE,
-    eCopy = VK_LOGIC_OP_COPY,
-    eAndInverted = VK_LOGIC_OP_AND_INVERTED,
-    eNoOp = VK_LOGIC_OP_NO_OP,
-    eXor = VK_LOGIC_OP_XOR,
-    eOr = VK_LOGIC_OP_OR,
-    eNor = VK_LOGIC_OP_NOR,
-    eEquivalent = VK_LOGIC_OP_EQUIVALENT,
-    eInvert = VK_LOGIC_OP_INVERT,
-    eOrReverse = VK_LOGIC_OP_OR_REVERSE,
-    eCopyInverted = VK_LOGIC_OP_COPY_INVERTED,
-    eOrInverted = VK_LOGIC_OP_OR_INVERTED,
-    eNand = VK_LOGIC_OP_NAND,
-    eSet = VK_LOGIC_OP_SET
-  };
-
-  enum class InternalAllocationType
-  {
-    eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE
-  };
-
-  enum class SystemAllocationScope
-  {
-    eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
-    eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT,
-    eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE,
-    eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE,
-    eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
-  };
-
-  enum class PhysicalDeviceType
-  {
-    eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER,
-    eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
-    eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU,
-    eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU,
-    eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU
-  };
-
-  enum class VertexInputRate
-  {
-    eVertex = VK_VERTEX_INPUT_RATE_VERTEX,
-    eInstance = VK_VERTEX_INPUT_RATE_INSTANCE
-  };
-
-  struct VertexInputBindingDescription
-  {
-    VertexInputBindingDescription( uint32_t binding_ = 0, uint32_t stride_ = 0, VertexInputRate inputRate_ = VertexInputRate::eVertex )
-      : binding( binding_ )
-      , stride( stride_ )
-      , inputRate( inputRate_ )
-    {
-    }
-
-    VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-    }
-
-    VertexInputBindingDescription& operator=( VkVertexInputBindingDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputBindingDescription ) );
-      return *this;
-    }
-    VertexInputBindingDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setStride( uint32_t stride_ )
-    {
-      stride = stride_;
-      return *this;
-    }
-
-    VertexInputBindingDescription& setInputRate( VertexInputRate inputRate_ )
-    {
-      inputRate = inputRate_;
-      return *this;
-    }
-
-    operator const VkVertexInputBindingDescription&() const
-    {
-      return *reinterpret_cast<const VkVertexInputBindingDescription*>(this);
-    }
-
-    bool operator==( VertexInputBindingDescription const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( stride == rhs.stride )
-          && ( inputRate == rhs.inputRate );
-    }
-
-    bool operator!=( VertexInputBindingDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    uint32_t stride;
-    VertexInputRate inputRate;
-  };
-  static_assert( sizeof( VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), "struct and wrapper have different size!" );
-
-  enum class Format
-  {
-    eUndefined = VK_FORMAT_UNDEFINED,
-    eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8,
-    eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16,
-    eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16,
-    eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16,
-    eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16,
-    eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16,
-    eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16,
-    eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16,
-    eR8Unorm = VK_FORMAT_R8_UNORM,
-    eR8Snorm = VK_FORMAT_R8_SNORM,
-    eR8Uscaled = VK_FORMAT_R8_USCALED,
-    eR8Sscaled = VK_FORMAT_R8_SSCALED,
-    eR8Uint = VK_FORMAT_R8_UINT,
-    eR8Sint = VK_FORMAT_R8_SINT,
-    eR8Srgb = VK_FORMAT_R8_SRGB,
-    eR8G8Unorm = VK_FORMAT_R8G8_UNORM,
-    eR8G8Snorm = VK_FORMAT_R8G8_SNORM,
-    eR8G8Uscaled = VK_FORMAT_R8G8_USCALED,
-    eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED,
-    eR8G8Uint = VK_FORMAT_R8G8_UINT,
-    eR8G8Sint = VK_FORMAT_R8G8_SINT,
-    eR8G8Srgb = VK_FORMAT_R8G8_SRGB,
-    eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM,
-    eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM,
-    eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED,
-    eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED,
-    eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT,
-    eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT,
-    eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB,
-    eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM,
-    eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM,
-    eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED,
-    eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED,
-    eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT,
-    eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT,
-    eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB,
-    eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM,
-    eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM,
-    eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED,
-    eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED,
-    eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT,
-    eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT,
-    eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB,
-    eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM,
-    eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM,
-    eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED,
-    eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED,
-    eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT,
-    eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT,
-    eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB,
-    eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32,
-    eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
-    eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32,
-    eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
-    eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32,
-    eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32,
-    eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
-    eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32,
-    eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
-    eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32,
-    eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
-    eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32,
-    eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32,
-    eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32,
-    eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
-    eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32,
-    eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
-    eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32,
-    eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32,
-    eR16Unorm = VK_FORMAT_R16_UNORM,
-    eR16Snorm = VK_FORMAT_R16_SNORM,
-    eR16Uscaled = VK_FORMAT_R16_USCALED,
-    eR16Sscaled = VK_FORMAT_R16_SSCALED,
-    eR16Uint = VK_FORMAT_R16_UINT,
-    eR16Sint = VK_FORMAT_R16_SINT,
-    eR16Sfloat = VK_FORMAT_R16_SFLOAT,
-    eR16G16Unorm = VK_FORMAT_R16G16_UNORM,
-    eR16G16Snorm = VK_FORMAT_R16G16_SNORM,
-    eR16G16Uscaled = VK_FORMAT_R16G16_USCALED,
-    eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED,
-    eR16G16Uint = VK_FORMAT_R16G16_UINT,
-    eR16G16Sint = VK_FORMAT_R16G16_SINT,
-    eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT,
-    eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM,
-    eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM,
-    eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED,
-    eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED,
-    eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT,
-    eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT,
-    eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT,
-    eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM,
-    eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM,
-    eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED,
-    eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED,
-    eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT,
-    eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT,
-    eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT,
-    eR32Uint = VK_FORMAT_R32_UINT,
-    eR32Sint = VK_FORMAT_R32_SINT,
-    eR32Sfloat = VK_FORMAT_R32_SFLOAT,
-    eR32G32Uint = VK_FORMAT_R32G32_UINT,
-    eR32G32Sint = VK_FORMAT_R32G32_SINT,
-    eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT,
-    eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT,
-    eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT,
-    eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT,
-    eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT,
-    eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT,
-    eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT,
-    eR64Uint = VK_FORMAT_R64_UINT,
-    eR64Sint = VK_FORMAT_R64_SINT,
-    eR64Sfloat = VK_FORMAT_R64_SFLOAT,
-    eR64G64Uint = VK_FORMAT_R64G64_UINT,
-    eR64G64Sint = VK_FORMAT_R64G64_SINT,
-    eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT,
-    eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT,
-    eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT,
-    eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT,
-    eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT,
-    eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT,
-    eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT,
-    eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32,
-    eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
-    eD16Unorm = VK_FORMAT_D16_UNORM,
-    eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32,
-    eD32Sfloat = VK_FORMAT_D32_SFLOAT,
-    eS8Uint = VK_FORMAT_S8_UINT,
-    eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT,
-    eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT,
-    eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT,
-    eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK,
-    eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK,
-    eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK,
-    eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK,
-    eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK,
-    eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK,
-    eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK,
-    eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK,
-    eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK,
-    eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK,
-    eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK,
-    eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK,
-    eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK,
-    eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK,
-    eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK,
-    eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK,
-    eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK,
-    eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK,
-    eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK,
-    eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK,
-    eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK,
-    eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK,
-    eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK,
-    eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK,
-    eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK,
-    eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK,
-    eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK,
-    eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK,
-    eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK,
-    eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK,
-    eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK,
-    eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK,
-    eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK,
-    eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK,
-    eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK,
-    eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK,
-    eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK,
-    eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK,
-    eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK,
-    eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK,
-    eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK,
-    eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK,
-    eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK,
-    eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK,
-    eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK,
-    eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK,
-    eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK,
-    eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK,
-    eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK,
-    eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK,
-    eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK,
-    eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK,
-    eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK,
-    eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
-    ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG,
-    ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG,
-    ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG,
-    ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG,
-    ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG,
-    ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG,
-    ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG,
-    ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG,
-    eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
-    eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
-    eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
-    eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
-    eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
-    eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
-    eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
-    eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR,
-    eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
-    eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
-    eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
-    eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
-    eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
-    eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
-    eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
-    eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
-    eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
-    eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR,
-    eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
-    eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
-    eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
-    eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
-    eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
-    eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
-    eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
-    eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
-    eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
-    eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
-    eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
-    eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
-    eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
-    eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
-    eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
-    eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
-  };
-
-  struct VertexInputAttributeDescription
-  {
-    VertexInputAttributeDescription( uint32_t location_ = 0, uint32_t binding_ = 0, Format format_ = Format::eUndefined, uint32_t offset_ = 0 )
-      : location( location_ )
-      , binding( binding_ )
-      , format( format_ )
-      , offset( offset_ )
-    {
-    }
-
-    VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-    }
-
-    VertexInputAttributeDescription& operator=( VkVertexInputAttributeDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( VertexInputAttributeDescription ) );
-      return *this;
-    }
-    VertexInputAttributeDescription& setLocation( uint32_t location_ )
-    {
-      location = location_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    VertexInputAttributeDescription& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator const VkVertexInputAttributeDescription&() const
-    {
-      return *reinterpret_cast<const VkVertexInputAttributeDescription*>(this);
-    }
-
-    bool operator==( VertexInputAttributeDescription const& rhs ) const
-    {
-      return ( location == rhs.location )
-          && ( binding == rhs.binding )
-          && ( format == rhs.format )
-          && ( offset == rhs.offset );
-    }
-
-    bool operator!=( VertexInputAttributeDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t location;
-    uint32_t binding;
-    Format format;
-    uint32_t offset;
-  };
-  static_assert( sizeof( VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), "struct and wrapper have different size!" );
-
-  enum class StructureType
-  {
-    eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-    eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-    eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-    eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-    eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-    eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-    eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
-    eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
-    eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-    eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-    eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
-    eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
-    eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-    eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
-    eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
-    eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-    eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-    ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
-    ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-    ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-    ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
-    ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
-    ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-    ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-    ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-    ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
-    ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
-    ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-    eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-    eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
-    ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-    eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-    eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
-    eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
-    eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
-    eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-    eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
-    eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-    eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-    eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-    eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
-    eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
-    eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-    eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-    eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
-    eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-    eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-    eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO,
-    eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
-    eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-    ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-    eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR,
-    eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR,
-    eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR,
-    eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
-    eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
-    eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
-    eMirSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR,
-    eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
-    eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
-    eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
-    ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
-    eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
-    eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
-    eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT,
-    eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
-    eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
-    eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
-    eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
-    eRenderPassMultiviewCreateInfoKHX = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX,
-    ePhysicalDeviceMultiviewFeaturesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX,
-    ePhysicalDeviceMultiviewPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX,
-    eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
-    eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
-    eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
-    eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
-    eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
-    ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
-    ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,
-    eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR,
-    eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR,
-    ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
-    eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR,
-    ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR,
-    eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR,
-    ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
-    eMemoryAllocateFlagsInfoKHX = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHX,
-    eDeviceGroupRenderPassBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHX,
-    eDeviceGroupCommandBufferBeginInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHX,
-    eDeviceGroupSubmitInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHX,
-    eDeviceGroupBindSparseInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHX,
-    eAcquireNextImageInfoKHX = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHX,
-    eBindBufferMemoryDeviceGroupInfoKHX = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHX,
-    eBindImageMemoryDeviceGroupInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHX,
-    eDeviceGroupPresentCapabilitiesKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHX,
-    eImageSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHX,
-    eBindImageMemorySwapchainInfoKHX = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHX,
-    eDeviceGroupPresentInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHX,
-    eDeviceGroupSwapchainCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHX,
-    eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
-    eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
-    ePhysicalDeviceGroupPropertiesKHX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHX,
-    eDeviceGroupDeviceCreateInfoKHX = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHX,
-    ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
-    eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
-    ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
-    eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
-    ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR,
-    eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
-    eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
-    eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
-    eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
-    eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
-    eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
-    eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
-    eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
-    eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
-    eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
-    eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
-    ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
-    eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
-    eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
-    eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
-    eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
-    eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
-    eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
-    eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
-    eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
-    ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
-    ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
-    ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
-    eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
-    eObjectTableCreateInfoNVX = VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX,
-    eIndirectCommandsLayoutCreateInfoNVX = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX,
-    eCmdProcessCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX,
-    eCmdReserveSpaceForCommandsInfoNVX = VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX,
-    eDeviceGeneratedCommandsLimitsNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX,
-    eDeviceGeneratedCommandsFeaturesNVX = VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX,
-    ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
-    eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
-    eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT,
-    eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT,
-    eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT,
-    eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
-    ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
-    ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
-    ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
-    ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
-    ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
-    ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
-    ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
-    eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
-    eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
-    ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
-    eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
-    eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
-    eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
-    eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
-    eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
-    eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
-    eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR,
-    ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR,
-    eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR,
-    eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,
-    ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR,
-    ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
-    eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
-    eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR,
-    ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR,
-    eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK,
-    eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
-    eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
-    eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
-    ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT,
-    eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
-    eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
-    eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
-    ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
-    ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
-    eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT,
-    eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
-    eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
-    eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR,
-    eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
-    eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR,
-    eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR,
-    ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
-    ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
-    ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
-    ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
-    ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
-    eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
-    eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
-    eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
-    eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR,
-    ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR,
-    eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR,
-    eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR,
-    eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
-    eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT,
-    eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
-    eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
-    eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
-    eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
-    ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT
-  };
-
-  struct ApplicationInfo
-  {
-    ApplicationInfo( const char* pApplicationName_ = nullptr, uint32_t applicationVersion_ = 0, const char* pEngineName_ = nullptr, uint32_t engineVersion_ = 0, uint32_t apiVersion_ = 0 )
-      : pApplicationName( pApplicationName_ )
-      , applicationVersion( applicationVersion_ )
-      , pEngineName( pEngineName_ )
-      , engineVersion( engineVersion_ )
-      , apiVersion( apiVersion_ )
-    {
-    }
-
-    ApplicationInfo( VkApplicationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ApplicationInfo ) );
-    }
-
-    ApplicationInfo& operator=( VkApplicationInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ApplicationInfo ) );
-      return *this;
-    }
-    ApplicationInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ApplicationInfo& setPApplicationName( const char* pApplicationName_ )
-    {
-      pApplicationName = pApplicationName_;
-      return *this;
-    }
-
-    ApplicationInfo& setApplicationVersion( uint32_t applicationVersion_ )
-    {
-      applicationVersion = applicationVersion_;
-      return *this;
-    }
-
-    ApplicationInfo& setPEngineName( const char* pEngineName_ )
-    {
-      pEngineName = pEngineName_;
-      return *this;
-    }
-
-    ApplicationInfo& setEngineVersion( uint32_t engineVersion_ )
-    {
-      engineVersion = engineVersion_;
-      return *this;
-    }
-
-    ApplicationInfo& setApiVersion( uint32_t apiVersion_ )
-    {
-      apiVersion = apiVersion_;
-      return *this;
-    }
-
-    operator const VkApplicationInfo&() const
-    {
-      return *reinterpret_cast<const VkApplicationInfo*>(this);
-    }
-
-    bool operator==( ApplicationInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pApplicationName == rhs.pApplicationName )
-          && ( applicationVersion == rhs.applicationVersion )
-          && ( pEngineName == rhs.pEngineName )
-          && ( engineVersion == rhs.engineVersion )
-          && ( apiVersion == rhs.apiVersion );
-    }
-
-    bool operator!=( ApplicationInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eApplicationInfo;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pApplicationName;
-    uint32_t applicationVersion;
-    const char* pEngineName;
-    uint32_t engineVersion;
-    uint32_t apiVersion;
-  };
-  static_assert( sizeof( ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" );
-
-  struct DeviceQueueCreateInfo
-  {
-    DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = DeviceQueueCreateFlags(), uint32_t queueFamilyIndex_ = 0, uint32_t queueCount_ = 0, const float* pQueuePriorities_ = nullptr )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-      , queueCount( queueCount_ )
-      , pQueuePriorities( pQueuePriorities_ )
-    {
-    }
-
-    DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
-    }
-
-    DeviceQueueCreateInfo& operator=( VkDeviceQueueCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueCreateInfo ) );
-      return *this;
-    }
-    DeviceQueueCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setFlags( DeviceQueueCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
-    {
-      queueFamilyIndex = queueFamilyIndex_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setQueueCount( uint32_t queueCount_ )
-    {
-      queueCount = queueCount_;
-      return *this;
-    }
-
-    DeviceQueueCreateInfo& setPQueuePriorities( const float* pQueuePriorities_ )
-    {
-      pQueuePriorities = pQueuePriorities_;
-      return *this;
-    }
-
-    operator const VkDeviceQueueCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkDeviceQueueCreateInfo*>(this);
-    }
-
-    bool operator==( DeviceQueueCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueFamilyIndex == rhs.queueFamilyIndex )
-          && ( queueCount == rhs.queueCount )
-          && ( pQueuePriorities == rhs.pQueuePriorities );
-    }
-
-    bool operator!=( DeviceQueueCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceQueueCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceQueueCreateFlags flags;
-    uint32_t queueFamilyIndex;
-    uint32_t queueCount;
-    const float* pQueuePriorities;
-  };
-  static_assert( sizeof( DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), "struct and wrapper have different size!" );
-
-  struct DeviceCreateInfo
-  {
-    DeviceCreateInfo( DeviceCreateFlags flags_ = DeviceCreateFlags(), uint32_t queueCreateInfoCount_ = 0, const DeviceQueueCreateInfo* pQueueCreateInfos_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr, const PhysicalDeviceFeatures* pEnabledFeatures_ = nullptr )
-      : flags( flags_ )
-      , queueCreateInfoCount( queueCreateInfoCount_ )
-      , pQueueCreateInfos( pQueueCreateInfos_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-      , pEnabledFeatures( pEnabledFeatures_ )
-    {
-    }
-
-    DeviceCreateInfo( VkDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
-    }
-
-    DeviceCreateInfo& operator=( VkDeviceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceCreateInfo ) );
-      return *this;
-    }
-    DeviceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setFlags( DeviceCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ )
-    {
-      queueCreateInfoCount = queueCreateInfoCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPQueueCreateInfos( const DeviceQueueCreateInfo* pQueueCreateInfos_ )
-    {
-      pQueueCreateInfos = pQueueCreateInfos_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
-    {
-      enabledLayerCount = enabledLayerCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
-    {
-      ppEnabledLayerNames = ppEnabledLayerNames_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
-    {
-      enabledExtensionCount = enabledExtensionCount_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
-    {
-      ppEnabledExtensionNames = ppEnabledExtensionNames_;
-      return *this;
-    }
-
-    DeviceCreateInfo& setPEnabledFeatures( const PhysicalDeviceFeatures* pEnabledFeatures_ )
-    {
-      pEnabledFeatures = pEnabledFeatures_;
-      return *this;
-    }
-
-    operator const VkDeviceCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkDeviceCreateInfo*>(this);
-    }
-
-    bool operator==( DeviceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueCreateInfoCount == rhs.queueCreateInfoCount )
-          && ( pQueueCreateInfos == rhs.pQueueCreateInfos )
-          && ( enabledLayerCount == rhs.enabledLayerCount )
-          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
-          && ( enabledExtensionCount == rhs.enabledExtensionCount )
-          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames )
-          && ( pEnabledFeatures == rhs.pEnabledFeatures );
-    }
-
-    bool operator!=( DeviceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceCreateFlags flags;
-    uint32_t queueCreateInfoCount;
-    const DeviceQueueCreateInfo* pQueueCreateInfos;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
-    const PhysicalDeviceFeatures* pEnabledFeatures;
-  };
-  static_assert( sizeof( DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" );
-
-  struct InstanceCreateInfo
-  {
-    InstanceCreateInfo( InstanceCreateFlags flags_ = InstanceCreateFlags(), const ApplicationInfo* pApplicationInfo_ = nullptr, uint32_t enabledLayerCount_ = 0, const char* const* ppEnabledLayerNames_ = nullptr, uint32_t enabledExtensionCount_ = 0, const char* const* ppEnabledExtensionNames_ = nullptr )
-      : flags( flags_ )
-      , pApplicationInfo( pApplicationInfo_ )
-      , enabledLayerCount( enabledLayerCount_ )
-      , ppEnabledLayerNames( ppEnabledLayerNames_ )
-      , enabledExtensionCount( enabledExtensionCount_ )
-      , ppEnabledExtensionNames( ppEnabledExtensionNames_ )
-    {
-    }
-
-    InstanceCreateInfo( VkInstanceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
-    }
-
-    InstanceCreateInfo& operator=( VkInstanceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InstanceCreateInfo ) );
-      return *this;
-    }
-    InstanceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setFlags( InstanceCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setPApplicationInfo( const ApplicationInfo* pApplicationInfo_ )
-    {
-      pApplicationInfo = pApplicationInfo_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setEnabledLayerCount( uint32_t enabledLayerCount_ )
-    {
-      enabledLayerCount = enabledLayerCount_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setPpEnabledLayerNames( const char* const* ppEnabledLayerNames_ )
-    {
-      ppEnabledLayerNames = ppEnabledLayerNames_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setEnabledExtensionCount( uint32_t enabledExtensionCount_ )
-    {
-      enabledExtensionCount = enabledExtensionCount_;
-      return *this;
-    }
-
-    InstanceCreateInfo& setPpEnabledExtensionNames( const char* const* ppEnabledExtensionNames_ )
-    {
-      ppEnabledExtensionNames = ppEnabledExtensionNames_;
-      return *this;
-    }
-
-    operator const VkInstanceCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkInstanceCreateInfo*>(this);
-    }
-
-    bool operator==( InstanceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pApplicationInfo == rhs.pApplicationInfo )
-          && ( enabledLayerCount == rhs.enabledLayerCount )
-          && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames )
-          && ( enabledExtensionCount == rhs.enabledExtensionCount )
-          && ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
-    }
-
-    bool operator!=( InstanceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eInstanceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    InstanceCreateFlags flags;
-    const ApplicationInfo* pApplicationInfo;
-    uint32_t enabledLayerCount;
-    const char* const* ppEnabledLayerNames;
-    uint32_t enabledExtensionCount;
-    const char* const* ppEnabledExtensionNames;
-  };
-  static_assert( sizeof( InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" );
-
-  struct MemoryAllocateInfo
-  {
-    MemoryAllocateInfo( DeviceSize allocationSize_ = 0, uint32_t memoryTypeIndex_ = 0 )
-      : allocationSize( allocationSize_ )
-      , memoryTypeIndex( memoryTypeIndex_ )
-    {
-    }
-
-    MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
-    }
-
-    MemoryAllocateInfo& operator=( VkMemoryAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateInfo ) );
-      return *this;
-    }
-    MemoryAllocateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryAllocateInfo& setAllocationSize( DeviceSize allocationSize_ )
-    {
-      allocationSize = allocationSize_;
-      return *this;
-    }
-
-    MemoryAllocateInfo& setMemoryTypeIndex( uint32_t memoryTypeIndex_ )
-    {
-      memoryTypeIndex = memoryTypeIndex_;
-      return *this;
-    }
-
-    operator const VkMemoryAllocateInfo&() const
-    {
-      return *reinterpret_cast<const VkMemoryAllocateInfo*>(this);
-    }
-
-    bool operator==( MemoryAllocateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( allocationSize == rhs.allocationSize )
-          && ( memoryTypeIndex == rhs.memoryTypeIndex );
-    }
-
-    bool operator!=( MemoryAllocateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceSize allocationSize;
-    uint32_t memoryTypeIndex;
-  };
-  static_assert( sizeof( MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" );
-
-  struct MappedMemoryRange
-  {
-    MappedMemoryRange( DeviceMemory memory_ = DeviceMemory(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
-      : memory( memory_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    MappedMemoryRange( VkMappedMemoryRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
-    }
-
-    MappedMemoryRange& operator=( VkMappedMemoryRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MappedMemoryRange ) );
-      return *this;
-    }
-    MappedMemoryRange& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MappedMemoryRange& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    MappedMemoryRange& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    MappedMemoryRange& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator const VkMappedMemoryRange&() const
-    {
-      return *reinterpret_cast<const VkMappedMemoryRange*>(this);
-    }
-
-    bool operator==( MappedMemoryRange const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( MappedMemoryRange const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMappedMemoryRange;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    DeviceSize offset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" );
-
-  struct WriteDescriptorSet
-  {
-    WriteDescriptorSet( DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, const DescriptorImageInfo* pImageInfo_ = nullptr, const DescriptorBufferInfo* pBufferInfo_ = nullptr, const BufferView* pTexelBufferView_ = nullptr )
-      : dstSet( dstSet_ )
-      , dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-      , descriptorType( descriptorType_ )
-      , pImageInfo( pImageInfo_ )
-      , pBufferInfo( pBufferInfo_ )
-      , pTexelBufferView( pTexelBufferView_ )
-    {
-    }
-
-    WriteDescriptorSet( VkWriteDescriptorSet const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
-    }
-
-    WriteDescriptorSet& operator=( VkWriteDescriptorSet const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WriteDescriptorSet ) );
-      return *this;
-    }
-    WriteDescriptorSet& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setDstSet( DescriptorSet dstSet_ )
-    {
-      dstSet = dstSet_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setDstBinding( uint32_t dstBinding_ )
-    {
-      dstBinding = dstBinding_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
-    {
-      dstArrayElement = dstArrayElement_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPImageInfo( const DescriptorImageInfo* pImageInfo_ )
-    {
-      pImageInfo = pImageInfo_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPBufferInfo( const DescriptorBufferInfo* pBufferInfo_ )
-    {
-      pBufferInfo = pBufferInfo_;
-      return *this;
-    }
-
-    WriteDescriptorSet& setPTexelBufferView( const BufferView* pTexelBufferView_ )
-    {
-      pTexelBufferView = pTexelBufferView_;
-      return *this;
-    }
-
-    operator const VkWriteDescriptorSet&() const
-    {
-      return *reinterpret_cast<const VkWriteDescriptorSet*>(this);
-    }
-
-    bool operator==( WriteDescriptorSet const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dstSet == rhs.dstSet )
-          && ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( descriptorType == rhs.descriptorType )
-          && ( pImageInfo == rhs.pImageInfo )
-          && ( pBufferInfo == rhs.pBufferInfo )
-          && ( pTexelBufferView == rhs.pTexelBufferView );
-    }
-
-    bool operator!=( WriteDescriptorSet const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWriteDescriptorSet;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSet dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-    DescriptorType descriptorType;
-    const DescriptorImageInfo* pImageInfo;
-    const DescriptorBufferInfo* pBufferInfo;
-    const BufferView* pTexelBufferView;
-  };
-  static_assert( sizeof( WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" );
-
-  struct CopyDescriptorSet
-  {
-    CopyDescriptorSet( DescriptorSet srcSet_ = DescriptorSet(), uint32_t srcBinding_ = 0, uint32_t srcArrayElement_ = 0, DescriptorSet dstSet_ = DescriptorSet(), uint32_t dstBinding_ = 0, uint32_t dstArrayElement_ = 0, uint32_t descriptorCount_ = 0 )
-      : srcSet( srcSet_ )
-      , srcBinding( srcBinding_ )
-      , srcArrayElement( srcArrayElement_ )
-      , dstSet( dstSet_ )
-      , dstBinding( dstBinding_ )
-      , dstArrayElement( dstArrayElement_ )
-      , descriptorCount( descriptorCount_ )
-    {
-    }
-
-    CopyDescriptorSet( VkCopyDescriptorSet const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
-    }
-
-    CopyDescriptorSet& operator=( VkCopyDescriptorSet const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CopyDescriptorSet ) );
-      return *this;
-    }
-    CopyDescriptorSet& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setSrcSet( DescriptorSet srcSet_ )
-    {
-      srcSet = srcSet_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setSrcBinding( uint32_t srcBinding_ )
-    {
-      srcBinding = srcBinding_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setSrcArrayElement( uint32_t srcArrayElement_ )
-    {
-      srcArrayElement = srcArrayElement_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setDstSet( DescriptorSet dstSet_ )
-    {
-      dstSet = dstSet_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setDstBinding( uint32_t dstBinding_ )
-    {
-      dstBinding = dstBinding_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setDstArrayElement( uint32_t dstArrayElement_ )
-    {
-      dstArrayElement = dstArrayElement_;
-      return *this;
-    }
-
-    CopyDescriptorSet& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    operator const VkCopyDescriptorSet&() const
-    {
-      return *reinterpret_cast<const VkCopyDescriptorSet*>(this);
-    }
-
-    bool operator==( CopyDescriptorSet const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcSet == rhs.srcSet )
-          && ( srcBinding == rhs.srcBinding )
-          && ( srcArrayElement == rhs.srcArrayElement )
-          && ( dstSet == rhs.dstSet )
-          && ( dstBinding == rhs.dstBinding )
-          && ( dstArrayElement == rhs.dstArrayElement )
-          && ( descriptorCount == rhs.descriptorCount );
-    }
-
-    bool operator!=( CopyDescriptorSet const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCopyDescriptorSet;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSet srcSet;
-    uint32_t srcBinding;
-    uint32_t srcArrayElement;
-    DescriptorSet dstSet;
-    uint32_t dstBinding;
-    uint32_t dstArrayElement;
-    uint32_t descriptorCount;
-  };
-  static_assert( sizeof( CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" );
-
-  struct BufferViewCreateInfo
-  {
-    BufferViewCreateInfo( BufferViewCreateFlags flags_ = BufferViewCreateFlags(), Buffer buffer_ = Buffer(), Format format_ = Format::eUndefined, DeviceSize offset_ = 0, DeviceSize range_ = 0 )
-      : flags( flags_ )
-      , buffer( buffer_ )
-      , format( format_ )
-      , offset( offset_ )
-      , range( range_ )
-    {
-    }
-
-    BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
-    }
-
-    BufferViewCreateInfo& operator=( VkBufferViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferViewCreateInfo ) );
-      return *this;
-    }
-    BufferViewCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BufferViewCreateInfo& setFlags( BufferViewCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    BufferViewCreateInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    BufferViewCreateInfo& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    BufferViewCreateInfo& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    BufferViewCreateInfo& setRange( DeviceSize range_ )
-    {
-      range = range_;
-      return *this;
-    }
-
-    operator const VkBufferViewCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkBufferViewCreateInfo*>(this);
-    }
-
-    bool operator==( BufferViewCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer )
-          && ( format == rhs.format )
-          && ( offset == rhs.offset )
-          && ( range == rhs.range );
-    }
-
-    bool operator!=( BufferViewCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBufferViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferViewCreateFlags flags;
-    Buffer buffer;
-    Format format;
-    DeviceSize offset;
-    DeviceSize range;
-  };
-  static_assert( sizeof( BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" );
-
-  struct ShaderModuleCreateInfo
-  {
-    ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = ShaderModuleCreateFlags(), size_t codeSize_ = 0, const uint32_t* pCode_ = nullptr )
-      : flags( flags_ )
-      , codeSize( codeSize_ )
-      , pCode( pCode_ )
-    {
-    }
-
-    ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
-    }
-
-    ShaderModuleCreateInfo& operator=( VkShaderModuleCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleCreateInfo ) );
-      return *this;
-    }
-    ShaderModuleCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ShaderModuleCreateInfo& setFlags( ShaderModuleCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ShaderModuleCreateInfo& setCodeSize( size_t codeSize_ )
-    {
-      codeSize = codeSize_;
-      return *this;
-    }
-
-    ShaderModuleCreateInfo& setPCode( const uint32_t* pCode_ )
-    {
-      pCode = pCode_;
-      return *this;
-    }
-
-    operator const VkShaderModuleCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkShaderModuleCreateInfo*>(this);
-    }
-
-    bool operator==( ShaderModuleCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( codeSize == rhs.codeSize )
-          && ( pCode == rhs.pCode );
-    }
-
-    bool operator!=( ShaderModuleCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eShaderModuleCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ShaderModuleCreateFlags flags;
-    size_t codeSize;
-    const uint32_t* pCode;
-  };
-  static_assert( sizeof( ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), "struct and wrapper have different size!" );
-
-  struct DescriptorSetAllocateInfo
-  {
-    DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = DescriptorPool(), uint32_t descriptorSetCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr )
-      : descriptorPool( descriptorPool_ )
-      , descriptorSetCount( descriptorSetCount_ )
-      , pSetLayouts( pSetLayouts_ )
-    {
-    }
-
-    DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
-    }
-
-    DescriptorSetAllocateInfo& operator=( VkDescriptorSetAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetAllocateInfo ) );
-      return *this;
-    }
-    DescriptorSetAllocateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorSetAllocateInfo& setDescriptorPool( DescriptorPool descriptorPool_ )
-    {
-      descriptorPool = descriptorPool_;
-      return *this;
-    }
-
-    DescriptorSetAllocateInfo& setDescriptorSetCount( uint32_t descriptorSetCount_ )
-    {
-      descriptorSetCount = descriptorSetCount_;
-      return *this;
-    }
-
-    DescriptorSetAllocateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
-    {
-      pSetLayouts = pSetLayouts_;
-      return *this;
-    }
-
-    operator const VkDescriptorSetAllocateInfo&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetAllocateInfo*>(this);
-    }
-
-    bool operator==( DescriptorSetAllocateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( descriptorPool == rhs.descriptorPool )
-          && ( descriptorSetCount == rhs.descriptorSetCount )
-          && ( pSetLayouts == rhs.pSetLayouts );
-    }
-
-    bool operator!=( DescriptorSetAllocateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorPool descriptorPool;
-    uint32_t descriptorSetCount;
-    const DescriptorSetLayout* pSetLayouts;
-  };
-  static_assert( sizeof( DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineVertexInputStateCreateInfo
-  {
-    PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = PipelineVertexInputStateCreateFlags(), uint32_t vertexBindingDescriptionCount_ = 0, const VertexInputBindingDescription* pVertexBindingDescriptions_ = nullptr, uint32_t vertexAttributeDescriptionCount_ = 0, const VertexInputAttributeDescription* pVertexAttributeDescriptions_ = nullptr )
-      : flags( flags_ )
-      , vertexBindingDescriptionCount( vertexBindingDescriptionCount_ )
-      , pVertexBindingDescriptions( pVertexBindingDescriptions_ )
-      , vertexAttributeDescriptionCount( vertexAttributeDescriptionCount_ )
-      , pVertexAttributeDescriptions( pVertexAttributeDescriptions_ )
-    {
-    }
-
-    PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
-    }
-
-    PipelineVertexInputStateCreateInfo& operator=( VkPipelineVertexInputStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineVertexInputStateCreateInfo ) );
-      return *this;
-    }
-    PipelineVertexInputStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineVertexInputStateCreateInfo& setFlags( PipelineVertexInputStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineVertexInputStateCreateInfo& setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ )
-    {
-      vertexBindingDescriptionCount = vertexBindingDescriptionCount_;
-      return *this;
-    }
-
-    PipelineVertexInputStateCreateInfo& setPVertexBindingDescriptions( const VertexInputBindingDescription* pVertexBindingDescriptions_ )
-    {
-      pVertexBindingDescriptions = pVertexBindingDescriptions_;
-      return *this;
-    }
-
-    PipelineVertexInputStateCreateInfo& setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ )
-    {
-      vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_;
-      return *this;
-    }
-
-    PipelineVertexInputStateCreateInfo& setPVertexAttributeDescriptions( const VertexInputAttributeDescription* pVertexAttributeDescriptions_ )
-    {
-      pVertexAttributeDescriptions = pVertexAttributeDescriptions_;
-      return *this;
-    }
-
-    operator const VkPipelineVertexInputStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineVertexInputStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineVertexInputStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount )
-          && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions )
-          && ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount )
-          && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
-    }
-
-    bool operator!=( PipelineVertexInputStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineVertexInputStateCreateFlags flags;
-    uint32_t vertexBindingDescriptionCount;
-    const VertexInputBindingDescription* pVertexBindingDescriptions;
-    uint32_t vertexAttributeDescriptionCount;
-    const VertexInputAttributeDescription* pVertexAttributeDescriptions;
-  };
-  static_assert( sizeof( PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineInputAssemblyStateCreateInfo
-  {
-    PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = PipelineInputAssemblyStateCreateFlags(), PrimitiveTopology topology_ = PrimitiveTopology::ePointList, Bool32 primitiveRestartEnable_ = 0 )
-      : flags( flags_ )
-      , topology( topology_ )
-      , primitiveRestartEnable( primitiveRestartEnable_ )
-    {
-    }
-
-    PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
-    }
-
-    PipelineInputAssemblyStateCreateInfo& operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineInputAssemblyStateCreateInfo ) );
-      return *this;
-    }
-    PipelineInputAssemblyStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineInputAssemblyStateCreateInfo& setFlags( PipelineInputAssemblyStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineInputAssemblyStateCreateInfo& setTopology( PrimitiveTopology topology_ )
-    {
-      topology = topology_;
-      return *this;
-    }
-
-    PipelineInputAssemblyStateCreateInfo& setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ )
-    {
-      primitiveRestartEnable = primitiveRestartEnable_;
-      return *this;
-    }
-
-    operator const VkPipelineInputAssemblyStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineInputAssemblyStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineInputAssemblyStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( topology == rhs.topology )
-          && ( primitiveRestartEnable == rhs.primitiveRestartEnable );
-    }
-
-    bool operator!=( PipelineInputAssemblyStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineInputAssemblyStateCreateFlags flags;
-    PrimitiveTopology topology;
-    Bool32 primitiveRestartEnable;
-  };
-  static_assert( sizeof( PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineTessellationStateCreateInfo
-  {
-    PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = PipelineTessellationStateCreateFlags(), uint32_t patchControlPoints_ = 0 )
-      : flags( flags_ )
-      , patchControlPoints( patchControlPoints_ )
-    {
-    }
-
-    PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
-    }
-
-    PipelineTessellationStateCreateInfo& operator=( VkPipelineTessellationStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationStateCreateInfo ) );
-      return *this;
-    }
-    PipelineTessellationStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineTessellationStateCreateInfo& setFlags( PipelineTessellationStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineTessellationStateCreateInfo& setPatchControlPoints( uint32_t patchControlPoints_ )
-    {
-      patchControlPoints = patchControlPoints_;
-      return *this;
-    }
-
-    operator const VkPipelineTessellationStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineTessellationStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineTessellationStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( patchControlPoints == rhs.patchControlPoints );
-    }
-
-    bool operator!=( PipelineTessellationStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineTessellationStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineTessellationStateCreateFlags flags;
-    uint32_t patchControlPoints;
-  };
-  static_assert( sizeof( PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineViewportStateCreateInfo
-  {
-    PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = PipelineViewportStateCreateFlags(), uint32_t viewportCount_ = 0, const Viewport* pViewports_ = nullptr, uint32_t scissorCount_ = 0, const Rect2D* pScissors_ = nullptr )
-      : flags( flags_ )
-      , viewportCount( viewportCount_ )
-      , pViewports( pViewports_ )
-      , scissorCount( scissorCount_ )
-      , pScissors( pScissors_ )
-    {
-    }
-
-    PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
-    }
-
-    PipelineViewportStateCreateInfo& operator=( VkPipelineViewportStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportStateCreateInfo ) );
-      return *this;
-    }
-    PipelineViewportStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineViewportStateCreateInfo& setFlags( PipelineViewportStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineViewportStateCreateInfo& setViewportCount( uint32_t viewportCount_ )
-    {
-      viewportCount = viewportCount_;
-      return *this;
-    }
-
-    PipelineViewportStateCreateInfo& setPViewports( const Viewport* pViewports_ )
-    {
-      pViewports = pViewports_;
-      return *this;
-    }
-
-    PipelineViewportStateCreateInfo& setScissorCount( uint32_t scissorCount_ )
-    {
-      scissorCount = scissorCount_;
-      return *this;
-    }
-
-    PipelineViewportStateCreateInfo& setPScissors( const Rect2D* pScissors_ )
-    {
-      pScissors = pScissors_;
-      return *this;
-    }
-
-    operator const VkPipelineViewportStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineViewportStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineViewportStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( viewportCount == rhs.viewportCount )
-          && ( pViewports == rhs.pViewports )
-          && ( scissorCount == rhs.scissorCount )
-          && ( pScissors == rhs.pScissors );
-    }
-
-    bool operator!=( PipelineViewportStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineViewportStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineViewportStateCreateFlags flags;
-    uint32_t viewportCount;
-    const Viewport* pViewports;
-    uint32_t scissorCount;
-    const Rect2D* pScissors;
-  };
-  static_assert( sizeof( PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineRasterizationStateCreateInfo
-  {
-    PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = PipelineRasterizationStateCreateFlags(), Bool32 depthClampEnable_ = 0, Bool32 rasterizerDiscardEnable_ = 0, PolygonMode polygonMode_ = PolygonMode::eFill, CullModeFlags cullMode_ = CullModeFlags(), FrontFace frontFace_ = FrontFace::eCounterClockwise, Bool32 depthBiasEnable_ = 0, float depthBiasConstantFactor_ = 0, float depthBiasClamp_ = 0, float depthBiasSlopeFactor_ = 0, float lineWidth_ = 0 )
-      : flags( flags_ )
-      , depthClampEnable( depthClampEnable_ )
-      , rasterizerDiscardEnable( rasterizerDiscardEnable_ )
-      , polygonMode( polygonMode_ )
-      , cullMode( cullMode_ )
-      , frontFace( frontFace_ )
-      , depthBiasEnable( depthBiasEnable_ )
-      , depthBiasConstantFactor( depthBiasConstantFactor_ )
-      , depthBiasClamp( depthBiasClamp_ )
-      , depthBiasSlopeFactor( depthBiasSlopeFactor_ )
-      , lineWidth( lineWidth_ )
-    {
-    }
-
-    PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
-    }
-
-    PipelineRasterizationStateCreateInfo& operator=( VkPipelineRasterizationStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateCreateInfo ) );
-      return *this;
-    }
-    PipelineRasterizationStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setFlags( PipelineRasterizationStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setDepthClampEnable( Bool32 depthClampEnable_ )
-    {
-      depthClampEnable = depthClampEnable_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ )
-    {
-      rasterizerDiscardEnable = rasterizerDiscardEnable_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setPolygonMode( PolygonMode polygonMode_ )
-    {
-      polygonMode = polygonMode_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setCullMode( CullModeFlags cullMode_ )
-    {
-      cullMode = cullMode_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setFrontFace( FrontFace frontFace_ )
-    {
-      frontFace = frontFace_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setDepthBiasEnable( Bool32 depthBiasEnable_ )
-    {
-      depthBiasEnable = depthBiasEnable_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setDepthBiasConstantFactor( float depthBiasConstantFactor_ )
-    {
-      depthBiasConstantFactor = depthBiasConstantFactor_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setDepthBiasClamp( float depthBiasClamp_ )
-    {
-      depthBiasClamp = depthBiasClamp_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ )
-    {
-      depthBiasSlopeFactor = depthBiasSlopeFactor_;
-      return *this;
-    }
-
-    PipelineRasterizationStateCreateInfo& setLineWidth( float lineWidth_ )
-    {
-      lineWidth = lineWidth_;
-      return *this;
-    }
-
-    operator const VkPipelineRasterizationStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineRasterizationStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( depthClampEnable == rhs.depthClampEnable )
-          && ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable )
-          && ( polygonMode == rhs.polygonMode )
-          && ( cullMode == rhs.cullMode )
-          && ( frontFace == rhs.frontFace )
-          && ( depthBiasEnable == rhs.depthBiasEnable )
-          && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor )
-          && ( depthBiasClamp == rhs.depthBiasClamp )
-          && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor )
-          && ( lineWidth == rhs.lineWidth );
-    }
-
-    bool operator!=( PipelineRasterizationStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationStateCreateFlags flags;
-    Bool32 depthClampEnable;
-    Bool32 rasterizerDiscardEnable;
-    PolygonMode polygonMode;
-    CullModeFlags cullMode;
-    FrontFace frontFace;
-    Bool32 depthBiasEnable;
-    float depthBiasConstantFactor;
-    float depthBiasClamp;
-    float depthBiasSlopeFactor;
-    float lineWidth;
-  };
-  static_assert( sizeof( PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineDepthStencilStateCreateInfo
-  {
-    PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = PipelineDepthStencilStateCreateFlags(), Bool32 depthTestEnable_ = 0, Bool32 depthWriteEnable_ = 0, CompareOp depthCompareOp_ = CompareOp::eNever, Bool32 depthBoundsTestEnable_ = 0, Bool32 stencilTestEnable_ = 0, StencilOpState front_ = StencilOpState(), StencilOpState back_ = StencilOpState(), float minDepthBounds_ = 0, float maxDepthBounds_ = 0 )
-      : flags( flags_ )
-      , depthTestEnable( depthTestEnable_ )
-      , depthWriteEnable( depthWriteEnable_ )
-      , depthCompareOp( depthCompareOp_ )
-      , depthBoundsTestEnable( depthBoundsTestEnable_ )
-      , stencilTestEnable( stencilTestEnable_ )
-      , front( front_ )
-      , back( back_ )
-      , minDepthBounds( minDepthBounds_ )
-      , maxDepthBounds( maxDepthBounds_ )
-    {
-    }
-
-    PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
-    }
-
-    PipelineDepthStencilStateCreateInfo& operator=( VkPipelineDepthStencilStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDepthStencilStateCreateInfo ) );
-      return *this;
-    }
-    PipelineDepthStencilStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setFlags( PipelineDepthStencilStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setDepthTestEnable( Bool32 depthTestEnable_ )
-    {
-      depthTestEnable = depthTestEnable_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setDepthWriteEnable( Bool32 depthWriteEnable_ )
-    {
-      depthWriteEnable = depthWriteEnable_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setDepthCompareOp( CompareOp depthCompareOp_ )
-    {
-      depthCompareOp = depthCompareOp_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ )
-    {
-      depthBoundsTestEnable = depthBoundsTestEnable_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setStencilTestEnable( Bool32 stencilTestEnable_ )
-    {
-      stencilTestEnable = stencilTestEnable_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setFront( StencilOpState front_ )
-    {
-      front = front_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setBack( StencilOpState back_ )
-    {
-      back = back_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setMinDepthBounds( float minDepthBounds_ )
-    {
-      minDepthBounds = minDepthBounds_;
-      return *this;
-    }
-
-    PipelineDepthStencilStateCreateInfo& setMaxDepthBounds( float maxDepthBounds_ )
-    {
-      maxDepthBounds = maxDepthBounds_;
-      return *this;
-    }
-
-    operator const VkPipelineDepthStencilStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineDepthStencilStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineDepthStencilStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( depthTestEnable == rhs.depthTestEnable )
-          && ( depthWriteEnable == rhs.depthWriteEnable )
-          && ( depthCompareOp == rhs.depthCompareOp )
-          && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable )
-          && ( stencilTestEnable == rhs.stencilTestEnable )
-          && ( front == rhs.front )
-          && ( back == rhs.back )
-          && ( minDepthBounds == rhs.minDepthBounds )
-          && ( maxDepthBounds == rhs.maxDepthBounds );
-    }
-
-    bool operator!=( PipelineDepthStencilStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDepthStencilStateCreateFlags flags;
-    Bool32 depthTestEnable;
-    Bool32 depthWriteEnable;
-    CompareOp depthCompareOp;
-    Bool32 depthBoundsTestEnable;
-    Bool32 stencilTestEnable;
-    StencilOpState front;
-    StencilOpState back;
-    float minDepthBounds;
-    float maxDepthBounds;
-  };
-  static_assert( sizeof( PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineCacheCreateInfo
-  {
-    PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = PipelineCacheCreateFlags(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
-      : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
-    {
-    }
-
-    PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
-    }
-
-    PipelineCacheCreateInfo& operator=( VkPipelineCacheCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCacheCreateInfo ) );
-      return *this;
-    }
-    PipelineCacheCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setFlags( PipelineCacheCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setInitialDataSize( size_t initialDataSize_ )
-    {
-      initialDataSize = initialDataSize_;
-      return *this;
-    }
-
-    PipelineCacheCreateInfo& setPInitialData( const void* pInitialData_ )
-    {
-      pInitialData = pInitialData_;
-      return *this;
-    }
-
-    operator const VkPipelineCacheCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineCacheCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineCacheCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( initialDataSize == rhs.initialDataSize )
-          && ( pInitialData == rhs.pInitialData );
-    }
-
-    bool operator!=( PipelineCacheCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCacheCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCacheCreateFlags flags;
-    size_t initialDataSize;
-    const void* pInitialData;
-  };
-  static_assert( sizeof( PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), "struct and wrapper have different size!" );
-
-  struct SamplerCreateInfo
-  {
-    SamplerCreateInfo( SamplerCreateFlags flags_ = SamplerCreateFlags(), Filter magFilter_ = Filter::eNearest, Filter minFilter_ = Filter::eNearest, SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, float mipLodBias_ = 0, Bool32 anisotropyEnable_ = 0, float maxAnisotropy_ = 0, Bool32 compareEnable_ = 0, CompareOp compareOp_ = CompareOp::eNever, float minLod_ = 0, float maxLod_ = 0, BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, Bool32 unnormalizedCoordinates_ = 0 )
-      : flags( flags_ )
-      , magFilter( magFilter_ )
-      , minFilter( minFilter_ )
-      , mipmapMode( mipmapMode_ )
-      , addressModeU( addressModeU_ )
-      , addressModeV( addressModeV_ )
-      , addressModeW( addressModeW_ )
-      , mipLodBias( mipLodBias_ )
-      , anisotropyEnable( anisotropyEnable_ )
-      , maxAnisotropy( maxAnisotropy_ )
-      , compareEnable( compareEnable_ )
-      , compareOp( compareOp_ )
-      , minLod( minLod_ )
-      , maxLod( maxLod_ )
-      , borderColor( borderColor_ )
-      , unnormalizedCoordinates( unnormalizedCoordinates_ )
-    {
-    }
-
-    SamplerCreateInfo( VkSamplerCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
-    }
-
-    SamplerCreateInfo& operator=( VkSamplerCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerCreateInfo ) );
-      return *this;
-    }
-    SamplerCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setFlags( SamplerCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMagFilter( Filter magFilter_ )
-    {
-      magFilter = magFilter_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMinFilter( Filter minFilter_ )
-    {
-      minFilter = minFilter_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMipmapMode( SamplerMipmapMode mipmapMode_ )
-    {
-      mipmapMode = mipmapMode_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeU( SamplerAddressMode addressModeU_ )
-    {
-      addressModeU = addressModeU_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeV( SamplerAddressMode addressModeV_ )
-    {
-      addressModeV = addressModeV_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAddressModeW( SamplerAddressMode addressModeW_ )
-    {
-      addressModeW = addressModeW_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMipLodBias( float mipLodBias_ )
-    {
-      mipLodBias = mipLodBias_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setAnisotropyEnable( Bool32 anisotropyEnable_ )
-    {
-      anisotropyEnable = anisotropyEnable_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMaxAnisotropy( float maxAnisotropy_ )
-    {
-      maxAnisotropy = maxAnisotropy_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setCompareEnable( Bool32 compareEnable_ )
-    {
-      compareEnable = compareEnable_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setCompareOp( CompareOp compareOp_ )
-    {
-      compareOp = compareOp_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMinLod( float minLod_ )
-    {
-      minLod = minLod_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setMaxLod( float maxLod_ )
-    {
-      maxLod = maxLod_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setBorderColor( BorderColor borderColor_ )
-    {
-      borderColor = borderColor_;
-      return *this;
-    }
-
-    SamplerCreateInfo& setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ )
-    {
-      unnormalizedCoordinates = unnormalizedCoordinates_;
-      return *this;
-    }
-
-    operator const VkSamplerCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkSamplerCreateInfo*>(this);
-    }
-
-    bool operator==( SamplerCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( magFilter == rhs.magFilter )
-          && ( minFilter == rhs.minFilter )
-          && ( mipmapMode == rhs.mipmapMode )
-          && ( addressModeU == rhs.addressModeU )
-          && ( addressModeV == rhs.addressModeV )
-          && ( addressModeW == rhs.addressModeW )
-          && ( mipLodBias == rhs.mipLodBias )
-          && ( anisotropyEnable == rhs.anisotropyEnable )
-          && ( maxAnisotropy == rhs.maxAnisotropy )
-          && ( compareEnable == rhs.compareEnable )
-          && ( compareOp == rhs.compareOp )
-          && ( minLod == rhs.minLod )
-          && ( maxLod == rhs.maxLod )
-          && ( borderColor == rhs.borderColor )
-          && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
-    }
-
-    bool operator!=( SamplerCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerCreateFlags flags;
-    Filter magFilter;
-    Filter minFilter;
-    SamplerMipmapMode mipmapMode;
-    SamplerAddressMode addressModeU;
-    SamplerAddressMode addressModeV;
-    SamplerAddressMode addressModeW;
-    float mipLodBias;
-    Bool32 anisotropyEnable;
-    float maxAnisotropy;
-    Bool32 compareEnable;
-    CompareOp compareOp;
-    float minLod;
-    float maxLod;
-    BorderColor borderColor;
-    Bool32 unnormalizedCoordinates;
-  };
-  static_assert( sizeof( SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" );
-
-  struct CommandBufferAllocateInfo
-  {
-    CommandBufferAllocateInfo( CommandPool commandPool_ = CommandPool(), CommandBufferLevel level_ = CommandBufferLevel::ePrimary, uint32_t commandBufferCount_ = 0 )
-      : commandPool( commandPool_ )
-      , level( level_ )
-      , commandBufferCount( commandBufferCount_ )
-    {
-    }
-
-    CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
-    }
-
-    CommandBufferAllocateInfo& operator=( VkCommandBufferAllocateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferAllocateInfo ) );
-      return *this;
-    }
-    CommandBufferAllocateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setCommandPool( CommandPool commandPool_ )
-    {
-      commandPool = commandPool_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setLevel( CommandBufferLevel level_ )
-    {
-      level = level_;
-      return *this;
-    }
-
-    CommandBufferAllocateInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    operator const VkCommandBufferAllocateInfo&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferAllocateInfo*>(this);
-    }
-
-    bool operator==( CommandBufferAllocateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( commandPool == rhs.commandPool )
-          && ( level == rhs.level )
-          && ( commandBufferCount == rhs.commandBufferCount );
-    }
-
-    bool operator!=( CommandBufferAllocateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferAllocateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPool commandPool;
-    CommandBufferLevel level;
-    uint32_t commandBufferCount;
-  };
-  static_assert( sizeof( CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), "struct and wrapper have different size!" );
-
-  struct RenderPassBeginInfo
-  {
-    RenderPassBeginInfo( RenderPass renderPass_ = RenderPass(), Framebuffer framebuffer_ = Framebuffer(), Rect2D renderArea_ = Rect2D(), uint32_t clearValueCount_ = 0, const ClearValue* pClearValues_ = nullptr )
-      : renderPass( renderPass_ )
-      , framebuffer( framebuffer_ )
-      , renderArea( renderArea_ )
-      , clearValueCount( clearValueCount_ )
-      , pClearValues( pClearValues_ )
-    {
-    }
-
-    RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
-    }
-
-    RenderPassBeginInfo& operator=( VkRenderPassBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassBeginInfo ) );
-      return *this;
-    }
-    RenderPassBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setFramebuffer( Framebuffer framebuffer_ )
-    {
-      framebuffer = framebuffer_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setRenderArea( Rect2D renderArea_ )
-    {
-      renderArea = renderArea_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setClearValueCount( uint32_t clearValueCount_ )
-    {
-      clearValueCount = clearValueCount_;
-      return *this;
-    }
-
-    RenderPassBeginInfo& setPClearValues( const ClearValue* pClearValues_ )
-    {
-      pClearValues = pClearValues_;
-      return *this;
-    }
-
-    operator const VkRenderPassBeginInfo&() const
-    {
-      return *reinterpret_cast<const VkRenderPassBeginInfo*>(this);
-    }
-
-    bool operator==( RenderPassBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( renderPass == rhs.renderPass )
-          && ( framebuffer == rhs.framebuffer )
-          && ( renderArea == rhs.renderArea )
-          && ( clearValueCount == rhs.clearValueCount )
-          && ( pClearValues == rhs.pClearValues );
-    }
-
-    bool operator!=( RenderPassBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    Framebuffer framebuffer;
-    Rect2D renderArea;
-    uint32_t clearValueCount;
-    const ClearValue* pClearValues;
-  };
-  static_assert( sizeof( RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" );
-
-  struct EventCreateInfo
-  {
-    EventCreateInfo( EventCreateFlags flags_ = EventCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    EventCreateInfo( VkEventCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
-    }
-
-    EventCreateInfo& operator=( VkEventCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( EventCreateInfo ) );
-      return *this;
-    }
-    EventCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    EventCreateInfo& setFlags( EventCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkEventCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkEventCreateInfo*>(this);
-    }
-
-    bool operator==( EventCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( EventCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eEventCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    EventCreateFlags flags;
-  };
-  static_assert( sizeof( EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" );
-
-  struct SemaphoreCreateInfo
-  {
-    SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = SemaphoreCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
-    }
-
-    SemaphoreCreateInfo& operator=( VkSemaphoreCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreCreateInfo ) );
-      return *this;
-    }
-    SemaphoreCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreCreateInfo& setFlags( SemaphoreCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkSemaphoreCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreCreateInfo*>(this);
-    }
-
-    bool operator==( SemaphoreCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SemaphoreCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    SemaphoreCreateFlags flags;
-  };
-  static_assert( sizeof( SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" );
-
-  struct FramebufferCreateInfo
-  {
-    FramebufferCreateInfo( FramebufferCreateFlags flags_ = FramebufferCreateFlags(), RenderPass renderPass_ = RenderPass(), uint32_t attachmentCount_ = 0, const ImageView* pAttachments_ = nullptr, uint32_t width_ = 0, uint32_t height_ = 0, uint32_t layers_ = 0 )
-      : flags( flags_ )
-      , renderPass( renderPass_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-      , width( width_ )
-      , height( height_ )
-      , layers( layers_ )
-    {
-    }
-
-    FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
-    }
-
-    FramebufferCreateInfo& operator=( VkFramebufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FramebufferCreateInfo ) );
-      return *this;
-    }
-    FramebufferCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setFlags( FramebufferCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
-    {
-      attachmentCount = attachmentCount_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setPAttachments( const ImageView* pAttachments_ )
-    {
-      pAttachments = pAttachments_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setWidth( uint32_t width_ )
-    {
-      width = width_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setHeight( uint32_t height_ )
-    {
-      height = height_;
-      return *this;
-    }
-
-    FramebufferCreateInfo& setLayers( uint32_t layers_ )
-    {
-      layers = layers_;
-      return *this;
-    }
-
-    operator const VkFramebufferCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkFramebufferCreateInfo*>(this);
-    }
-
-    bool operator==( FramebufferCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( renderPass == rhs.renderPass )
-          && ( attachmentCount == rhs.attachmentCount )
-          && ( pAttachments == rhs.pAttachments )
-          && ( width == rhs.width )
-          && ( height == rhs.height )
-          && ( layers == rhs.layers );
-    }
-
-    bool operator!=( FramebufferCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFramebufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    FramebufferCreateFlags flags;
-    RenderPass renderPass;
-    uint32_t attachmentCount;
-    const ImageView* pAttachments;
-    uint32_t width;
-    uint32_t height;
-    uint32_t layers;
-  };
-  static_assert( sizeof( FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), "struct and wrapper have different size!" );
-
-  struct DisplayModeCreateInfoKHR
-  {
-    DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = DisplayModeCreateFlagsKHR(), DisplayModeParametersKHR parameters_ = DisplayModeParametersKHR() )
-      : flags( flags_ )
-      , parameters( parameters_ )
-    {
-    }
-
-    DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
-    }
-
-    DisplayModeCreateInfoKHR& operator=( VkDisplayModeCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayModeCreateInfoKHR ) );
-      return *this;
-    }
-    DisplayModeCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayModeCreateInfoKHR& setFlags( DisplayModeCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DisplayModeCreateInfoKHR& setParameters( DisplayModeParametersKHR parameters_ )
-    {
-      parameters = parameters_;
-      return *this;
-    }
-
-    operator const VkDisplayModeCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayModeCreateInfoKHR*>(this);
-    }
-
-    bool operator==( DisplayModeCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( parameters == rhs.parameters );
-    }
-
-    bool operator!=( DisplayModeCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayModeCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayModeCreateFlagsKHR flags;
-    DisplayModeParametersKHR parameters;
-  };
-  static_assert( sizeof( DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct DisplayPresentInfoKHR
-  {
-    DisplayPresentInfoKHR( Rect2D srcRect_ = Rect2D(), Rect2D dstRect_ = Rect2D(), Bool32 persistent_ = 0 )
-      : srcRect( srcRect_ )
-      , dstRect( dstRect_ )
-      , persistent( persistent_ )
-    {
-    }
-
-    DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
-    }
-
-    DisplayPresentInfoKHR& operator=( VkDisplayPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPresentInfoKHR ) );
-      return *this;
-    }
-    DisplayPresentInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setSrcRect( Rect2D srcRect_ )
-    {
-      srcRect = srcRect_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setDstRect( Rect2D dstRect_ )
-    {
-      dstRect = dstRect_;
-      return *this;
-    }
-
-    DisplayPresentInfoKHR& setPersistent( Bool32 persistent_ )
-    {
-      persistent = persistent_;
-      return *this;
-    }
-
-    operator const VkDisplayPresentInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayPresentInfoKHR*>(this);
-    }
-
-    bool operator==( DisplayPresentInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcRect == rhs.srcRect )
-          && ( dstRect == rhs.dstRect )
-          && ( persistent == rhs.persistent );
-    }
-
-    bool operator!=( DisplayPresentInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Rect2D srcRect;
-    Rect2D dstRect;
-    Bool32 persistent;
-  };
-  static_assert( sizeof( DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  struct AndroidSurfaceCreateInfoKHR
-  {
-    AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = AndroidSurfaceCreateFlagsKHR(), ANativeWindow* window_ = nullptr )
-      : flags( flags_ )
-      , window( window_ )
-    {
-    }
-
-    AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
-    }
-
-    AndroidSurfaceCreateInfoKHR& operator=( VkAndroidSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AndroidSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    AndroidSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AndroidSurfaceCreateInfoKHR& setFlags( AndroidSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    AndroidSurfaceCreateInfoKHR& setWindow( ANativeWindow* window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator const VkAndroidSurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( AndroidSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( AndroidSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    AndroidSurfaceCreateFlagsKHR flags;
-    ANativeWindow* window;
-  };
-  static_assert( sizeof( AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  struct MirSurfaceCreateInfoKHR
-  {
-    MirSurfaceCreateInfoKHR( MirSurfaceCreateFlagsKHR flags_ = MirSurfaceCreateFlagsKHR(), MirConnection* connection_ = nullptr, MirSurface* mirSurface_ = nullptr )
-      : flags( flags_ )
-      , connection( connection_ )
-      , mirSurface( mirSurface_ )
-    {
-    }
-
-    MirSurfaceCreateInfoKHR( VkMirSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
-    }
-
-    MirSurfaceCreateInfoKHR& operator=( VkMirSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MirSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    MirSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MirSurfaceCreateInfoKHR& setFlags( MirSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    MirSurfaceCreateInfoKHR& setConnection( MirConnection* connection_ )
-    {
-      connection = connection_;
-      return *this;
-    }
-
-    MirSurfaceCreateInfoKHR& setMirSurface( MirSurface* mirSurface_ )
-    {
-      mirSurface = mirSurface_;
-      return *this;
-    }
-
-    operator const VkMirSurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( MirSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( connection == rhs.connection )
-          && ( mirSurface == rhs.mirSurface );
-    }
-
-    bool operator!=( MirSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMirSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    MirSurfaceCreateFlagsKHR flags;
-    MirConnection* connection;
-    MirSurface* mirSurface;
-  };
-  static_assert( sizeof( MirSurfaceCreateInfoKHR ) == sizeof( VkMirSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  struct ViSurfaceCreateInfoNN
-  {
-    ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = ViSurfaceCreateFlagsNN(), void* window_ = nullptr )
-      : flags( flags_ )
-      , window( window_ )
-    {
-    }
-
-    ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
-    }
-
-    ViSurfaceCreateInfoNN& operator=( VkViSurfaceCreateInfoNN const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViSurfaceCreateInfoNN ) );
-      return *this;
-    }
-    ViSurfaceCreateInfoNN& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ViSurfaceCreateInfoNN& setFlags( ViSurfaceCreateFlagsNN flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ViSurfaceCreateInfoNN& setWindow( void* window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator const VkViSurfaceCreateInfoNN&() const
-    {
-      return *reinterpret_cast<const VkViSurfaceCreateInfoNN*>(this);
-    }
-
-    bool operator==( ViSurfaceCreateInfoNN const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( ViSurfaceCreateInfoNN const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eViSurfaceCreateInfoNN;
-
-  public:
-    const void* pNext = nullptr;
-    ViSurfaceCreateFlagsNN flags;
-    void* window;
-  };
-  static_assert( sizeof( ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  struct WaylandSurfaceCreateInfoKHR
-  {
-    WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = WaylandSurfaceCreateFlagsKHR(), struct wl_display* display_ = nullptr, struct wl_surface* surface_ = nullptr )
-      : flags( flags_ )
-      , display( display_ )
-      , surface( surface_ )
-    {
-    }
-
-    WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
-    }
-
-    WaylandSurfaceCreateInfoKHR& operator=( VkWaylandSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( WaylandSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    WaylandSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setFlags( WaylandSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setDisplay( struct wl_display* display_ )
-    {
-      display = display_;
-      return *this;
-    }
-
-    WaylandSurfaceCreateInfoKHR& setSurface( struct wl_surface* surface_ )
-    {
-      surface = surface_;
-      return *this;
-    }
-
-    operator const VkWaylandSurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( WaylandSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( display == rhs.display )
-          && ( surface == rhs.surface );
-    }
-
-    bool operator!=( WaylandSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    WaylandSurfaceCreateFlagsKHR flags;
-    struct wl_display* display;
-    struct wl_surface* surface;
-  };
-  static_assert( sizeof( WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32SurfaceCreateInfoKHR
-  {
-    Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = Win32SurfaceCreateFlagsKHR(), HINSTANCE hinstance_ = 0, HWND hwnd_ = 0 )
-      : flags( flags_ )
-      , hinstance( hinstance_ )
-      , hwnd( hwnd_ )
-    {
-    }
-
-    Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
-    }
-
-    Win32SurfaceCreateInfoKHR& operator=( VkWin32SurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32SurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    Win32SurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setFlags( Win32SurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setHinstance( HINSTANCE hinstance_ )
-    {
-      hinstance = hinstance_;
-      return *this;
-    }
-
-    Win32SurfaceCreateInfoKHR& setHwnd( HWND hwnd_ )
-    {
-      hwnd = hwnd_;
-      return *this;
-    }
-
-    operator const VkWin32SurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( Win32SurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( hinstance == rhs.hinstance )
-          && ( hwnd == rhs.hwnd );
-    }
-
-    bool operator!=( Win32SurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Win32SurfaceCreateFlagsKHR flags;
-    HINSTANCE hinstance;
-    HWND hwnd;
-  };
-  static_assert( sizeof( Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  struct XlibSurfaceCreateInfoKHR
-  {
-    XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = XlibSurfaceCreateFlagsKHR(), Display* dpy_ = nullptr, Window window_ = 0 )
-      : flags( flags_ )
-      , dpy( dpy_ )
-      , window( window_ )
-    {
-    }
-
-    XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
-    }
-
-    XlibSurfaceCreateInfoKHR& operator=( VkXlibSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XlibSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    XlibSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setFlags( XlibSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setDpy( Display* dpy_ )
-    {
-      dpy = dpy_;
-      return *this;
-    }
-
-    XlibSurfaceCreateInfoKHR& setWindow( Window window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator const VkXlibSurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( XlibSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( dpy == rhs.dpy )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( XlibSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XlibSurfaceCreateFlagsKHR flags;
-    Display* dpy;
-    Window window;
-  };
-  static_assert( sizeof( XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  struct XcbSurfaceCreateInfoKHR
-  {
-    XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = XcbSurfaceCreateFlagsKHR(), xcb_connection_t* connection_ = nullptr, xcb_window_t window_ = 0 )
-      : flags( flags_ )
-      , connection( connection_ )
-      , window( window_ )
-    {
-    }
-
-    XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
-    }
-
-    XcbSurfaceCreateInfoKHR& operator=( VkXcbSurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( XcbSurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    XcbSurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setFlags( XcbSurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setConnection( xcb_connection_t* connection_ )
-    {
-      connection = connection_;
-      return *this;
-    }
-
-    XcbSurfaceCreateInfoKHR& setWindow( xcb_window_t window_ )
-    {
-      window = window_;
-      return *this;
-    }
-
-    operator const VkXcbSurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( XcbSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( connection == rhs.connection )
-          && ( window == rhs.window );
-    }
-
-    bool operator!=( XcbSurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    XcbSurfaceCreateFlagsKHR flags;
-    xcb_connection_t* connection;
-    xcb_window_t window;
-  };
-  static_assert( sizeof( XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-  struct DebugMarkerMarkerInfoEXT
-  {
-    DebugMarkerMarkerInfoEXT( const char* pMarkerName_ = nullptr, std::array<float,4> const& color_ = { { 0, 0, 0, 0 } } )
-      : pMarkerName( pMarkerName_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-    }
-
-    DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
-    }
-
-    DebugMarkerMarkerInfoEXT& operator=( VkDebugMarkerMarkerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerMarkerInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerMarkerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerMarkerInfoEXT& setPMarkerName( const char* pMarkerName_ )
-    {
-      pMarkerName = pMarkerName_;
-      return *this;
-    }
-
-    DebugMarkerMarkerInfoEXT& setColor( std::array<float,4> color_ )
-    {
-      memcpy( &color, color_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    operator const VkDebugMarkerMarkerInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerMarkerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pMarkerName == rhs.pMarkerName )
-          && ( memcmp( color, rhs.color, 4 * sizeof( float ) ) == 0 );
-    }
-
-    bool operator!=( DebugMarkerMarkerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    const char* pMarkerName;
-    float color[4];
-  };
-  static_assert( sizeof( DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationImageCreateInfoNV
-  {
-    DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
-    {
-    }
-
-    DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
-    }
-
-    DedicatedAllocationImageCreateInfoNV& operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationImageCreateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationImageCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationImageCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
-    {
-      dedicatedAllocation = dedicatedAllocation_;
-      return *this;
-    }
-
-    operator const VkDedicatedAllocationImageCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationImageCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dedicatedAllocation == rhs.dedicatedAllocation );
-    }
-
-    bool operator!=( DedicatedAllocationImageCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
-  };
-  static_assert( sizeof( DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationBufferCreateInfoNV
-  {
-    DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = 0 )
-      : dedicatedAllocation( dedicatedAllocation_ )
-    {
-    }
-
-    DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
-    }
-
-    DedicatedAllocationBufferCreateInfoNV& operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationBufferCreateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationBufferCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationBufferCreateInfoNV& setDedicatedAllocation( Bool32 dedicatedAllocation_ )
-    {
-      dedicatedAllocation = dedicatedAllocation_;
-      return *this;
-    }
-
-    operator const VkDedicatedAllocationBufferCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( dedicatedAllocation == rhs.dedicatedAllocation );
-    }
-
-    bool operator!=( DedicatedAllocationBufferCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 dedicatedAllocation;
-  };
-  static_assert( sizeof( DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct DedicatedAllocationMemoryAllocateInfoNV
-  {
-    DedicatedAllocationMemoryAllocateInfoNV( Image image_ = Image(), Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DedicatedAllocationMemoryAllocateInfoNV ) );
-      return *this;
-    }
-    DedicatedAllocationMemoryAllocateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    DedicatedAllocationMemoryAllocateInfoNV& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator const VkDedicatedAllocationMemoryAllocateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV*>(this);
-    }
-
-    bool operator==( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
-  };
-  static_assert( sizeof( DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoNV
-  {
-    ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-    {
-    }
-
-    ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
-    }
-
-    ExportMemoryWin32HandleInfoNV& operator=( VkExportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoNV ) );
-      return *this;
-    }
-    ExportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoNV& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoNV& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    operator const VkExportMemoryWin32HandleInfoNV&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    bool operator==( ExportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess );
-    }
-
-    bool operator!=( ExportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-  };
-  static_assert( sizeof( ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32KeyedMutexAcquireReleaseInfoNV
-  {
-    Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeoutMilliseconds_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeoutMilliseconds( pAcquireTimeoutMilliseconds_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
-    {
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) );
-      return *this;
-    }
-    Win32KeyedMutexAcquireReleaseInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setAcquireCount( uint32_t acquireCount_ )
-    {
-      acquireCount = acquireCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
-    {
-      pAcquireSyncs = pAcquireSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
-    {
-      pAcquireKeys = pAcquireKeys_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPAcquireTimeoutMilliseconds( const uint32_t* pAcquireTimeoutMilliseconds_ )
-    {
-      pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setReleaseCount( uint32_t releaseCount_ )
-    {
-      releaseCount = releaseCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
-    {
-      pReleaseSyncs = pReleaseSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoNV& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
-    {
-      pReleaseKeys = pReleaseKeys_;
-      return *this;
-    }
-
-    operator const VkWin32KeyedMutexAcquireReleaseInfoNV&() const
-    {
-      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV*>(this);
-    }
-
-    bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( acquireCount == rhs.acquireCount )
-          && ( pAcquireSyncs == rhs.pAcquireSyncs )
-          && ( pAcquireKeys == rhs.pAcquireKeys )
-          && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds )
-          && ( releaseCount == rhs.releaseCount )
-          && ( pReleaseSyncs == rhs.pReleaseSyncs )
-          && ( pReleaseKeys == rhs.pReleaseKeys );
-    }
-
-    bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeoutMilliseconds;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
-  };
-  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct DeviceGeneratedCommandsFeaturesNVX
-  {
-    DeviceGeneratedCommandsFeaturesNVX( Bool32 computeBindingPointSupport_ = 0 )
-      : computeBindingPointSupport( computeBindingPointSupport_ )
-    {
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX& operator=( VkDeviceGeneratedCommandsFeaturesNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsFeaturesNVX ) );
-      return *this;
-    }
-    DeviceGeneratedCommandsFeaturesNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsFeaturesNVX& setComputeBindingPointSupport( Bool32 computeBindingPointSupport_ )
-    {
-      computeBindingPointSupport = computeBindingPointSupport_;
-      return *this;
-    }
-
-    operator const VkDeviceGeneratedCommandsFeaturesNVX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGeneratedCommandsFeaturesNVX*>(this);
-    }
-
-    bool operator==( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( computeBindingPointSupport == rhs.computeBindingPointSupport );
-    }
-
-    bool operator!=( DeviceGeneratedCommandsFeaturesNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsFeaturesNVX;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 computeBindingPointSupport;
-  };
-  static_assert( sizeof( DeviceGeneratedCommandsFeaturesNVX ) == sizeof( VkDeviceGeneratedCommandsFeaturesNVX ), "struct and wrapper have different size!" );
-
-  struct DeviceGeneratedCommandsLimitsNVX
-  {
-    DeviceGeneratedCommandsLimitsNVX( uint32_t maxIndirectCommandsLayoutTokenCount_ = 0, uint32_t maxObjectEntryCounts_ = 0, uint32_t minSequenceCountBufferOffsetAlignment_ = 0, uint32_t minSequenceIndexBufferOffsetAlignment_ = 0, uint32_t minCommandsTokenBufferOffsetAlignment_ = 0 )
-      : maxIndirectCommandsLayoutTokenCount( maxIndirectCommandsLayoutTokenCount_ )
-      , maxObjectEntryCounts( maxObjectEntryCounts_ )
-      , minSequenceCountBufferOffsetAlignment( minSequenceCountBufferOffsetAlignment_ )
-      , minSequenceIndexBufferOffsetAlignment( minSequenceIndexBufferOffsetAlignment_ )
-      , minCommandsTokenBufferOffsetAlignment( minCommandsTokenBufferOffsetAlignment_ )
-    {
-    }
-
-    DeviceGeneratedCommandsLimitsNVX( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& operator=( VkDeviceGeneratedCommandsLimitsNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGeneratedCommandsLimitsNVX ) );
-      return *this;
-    }
-    DeviceGeneratedCommandsLimitsNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMaxIndirectCommandsLayoutTokenCount( uint32_t maxIndirectCommandsLayoutTokenCount_ )
-    {
-      maxIndirectCommandsLayoutTokenCount = maxIndirectCommandsLayoutTokenCount_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMaxObjectEntryCounts( uint32_t maxObjectEntryCounts_ )
-    {
-      maxObjectEntryCounts = maxObjectEntryCounts_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinSequenceCountBufferOffsetAlignment( uint32_t minSequenceCountBufferOffsetAlignment_ )
-    {
-      minSequenceCountBufferOffsetAlignment = minSequenceCountBufferOffsetAlignment_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinSequenceIndexBufferOffsetAlignment( uint32_t minSequenceIndexBufferOffsetAlignment_ )
-    {
-      minSequenceIndexBufferOffsetAlignment = minSequenceIndexBufferOffsetAlignment_;
-      return *this;
-    }
-
-    DeviceGeneratedCommandsLimitsNVX& setMinCommandsTokenBufferOffsetAlignment( uint32_t minCommandsTokenBufferOffsetAlignment_ )
-    {
-      minCommandsTokenBufferOffsetAlignment = minCommandsTokenBufferOffsetAlignment_;
-      return *this;
-    }
-
-    operator const VkDeviceGeneratedCommandsLimitsNVX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGeneratedCommandsLimitsNVX*>(this);
-    }
-
-    bool operator==( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount )
-          && ( maxObjectEntryCounts == rhs.maxObjectEntryCounts )
-          && ( minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment )
-          && ( minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment )
-          && ( minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment );
-    }
-
-    bool operator!=( DeviceGeneratedCommandsLimitsNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGeneratedCommandsLimitsNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t maxIndirectCommandsLayoutTokenCount;
-    uint32_t maxObjectEntryCounts;
-    uint32_t minSequenceCountBufferOffsetAlignment;
-    uint32_t minSequenceIndexBufferOffsetAlignment;
-    uint32_t minCommandsTokenBufferOffsetAlignment;
-  };
-  static_assert( sizeof( DeviceGeneratedCommandsLimitsNVX ) == sizeof( VkDeviceGeneratedCommandsLimitsNVX ), "struct and wrapper have different size!" );
-
-  struct CmdReserveSpaceForCommandsInfoNVX
-  {
-    CmdReserveSpaceForCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t maxSequencesCount_ = 0 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , maxSequencesCount( maxSequencesCount_ )
-    {
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& operator=( VkCmdReserveSpaceForCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdReserveSpaceForCommandsInfoNVX ) );
-      return *this;
-    }
-    CmdReserveSpaceForCommandsInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
-    {
-      objectTable = objectTable_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
-    {
-      indirectCommandsLayout = indirectCommandsLayout_;
-      return *this;
-    }
-
-    CmdReserveSpaceForCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
-    {
-      maxSequencesCount = maxSequencesCount_;
-      return *this;
-    }
-
-    operator const VkCmdReserveSpaceForCommandsInfoNVX&() const
-    {
-      return *reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>(this);
-    }
-
-    bool operator==( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectTable == rhs.objectTable )
-          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
-          && ( maxSequencesCount == rhs.maxSequencesCount );
-    }
-
-    bool operator!=( CmdReserveSpaceForCommandsInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCmdReserveSpaceForCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t maxSequencesCount;
-  };
-  static_assert( sizeof( CmdReserveSpaceForCommandsInfoNVX ) == sizeof( VkCmdReserveSpaceForCommandsInfoNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceFeatures2KHR
-  {
-    PhysicalDeviceFeatures2KHR( PhysicalDeviceFeatures features_ = PhysicalDeviceFeatures() )
-      : features( features_ )
-    {
-    }
-
-    PhysicalDeviceFeatures2KHR( VkPhysicalDeviceFeatures2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) );
-    }
-
-    PhysicalDeviceFeatures2KHR& operator=( VkPhysicalDeviceFeatures2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceFeatures2KHR ) );
-      return *this;
-    }
-    PhysicalDeviceFeatures2KHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceFeatures2KHR& setFeatures( PhysicalDeviceFeatures features_ )
-    {
-      features = features_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceFeatures2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceFeatures2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceFeatures2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( features == rhs.features );
-    }
-
-    bool operator!=( PhysicalDeviceFeatures2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceFeatures2KHR;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceFeatures features;
-  };
-  static_assert( sizeof( PhysicalDeviceFeatures2KHR ) == sizeof( VkPhysicalDeviceFeatures2KHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDevicePushDescriptorPropertiesKHR
-  {
-    PhysicalDevicePushDescriptorPropertiesKHR( uint32_t maxPushDescriptors_ = 0 )
-      : maxPushDescriptors( maxPushDescriptors_ )
-    {
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR& operator=( VkPhysicalDevicePushDescriptorPropertiesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) );
-      return *this;
-    }
-    PhysicalDevicePushDescriptorPropertiesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDevicePushDescriptorPropertiesKHR& setMaxPushDescriptors( uint32_t maxPushDescriptors_ )
-    {
-      maxPushDescriptors = maxPushDescriptors_;
-      return *this;
-    }
-
-    operator const VkPhysicalDevicePushDescriptorPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxPushDescriptors == rhs.maxPushDescriptors );
-    }
-
-    bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevicePushDescriptorPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxPushDescriptors;
-  };
-  static_assert( sizeof( PhysicalDevicePushDescriptorPropertiesKHR ) == sizeof( VkPhysicalDevicePushDescriptorPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct PresentRegionsKHR
-  {
-    PresentRegionsKHR( uint32_t swapchainCount_ = 0, const PresentRegionKHR* pRegions_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pRegions( pRegions_ )
-    {
-    }
-
-    PresentRegionsKHR( VkPresentRegionsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
-    }
-
-    PresentRegionsKHR& operator=( VkPresentRegionsKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentRegionsKHR ) );
-      return *this;
-    }
-    PresentRegionsKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentRegionsKHR& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentRegionsKHR& setPRegions( const PresentRegionKHR* pRegions_ )
-    {
-      pRegions = pRegions_;
-      return *this;
-    }
-
-    operator const VkPresentRegionsKHR&() const
-    {
-      return *reinterpret_cast<const VkPresentRegionsKHR*>(this);
-    }
-
-    bool operator==( PresentRegionsKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pRegions == rhs.pRegions );
-    }
-
-    bool operator!=( PresentRegionsKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentRegionsKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentRegionKHR* pRegions;
-  };
-  static_assert( sizeof( PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceVariablePointerFeaturesKHR
-  {
-    PhysicalDeviceVariablePointerFeaturesKHR( Bool32 variablePointersStorageBuffer_ = 0, Bool32 variablePointers_ = 0 )
-      : variablePointersStorageBuffer( variablePointersStorageBuffer_ )
-      , variablePointers( variablePointers_ )
-    {
-    }
-
-    PhysicalDeviceVariablePointerFeaturesKHR( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) );
-    }
-
-    PhysicalDeviceVariablePointerFeaturesKHR& operator=( VkPhysicalDeviceVariablePointerFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) );
-      return *this;
-    }
-    PhysicalDeviceVariablePointerFeaturesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ )
-    {
-      variablePointersStorageBuffer = variablePointersStorageBuffer_;
-      return *this;
-    }
-
-    PhysicalDeviceVariablePointerFeaturesKHR& setVariablePointers( Bool32 variablePointers_ )
-    {
-      variablePointers = variablePointers_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceVariablePointerFeaturesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceVariablePointerFeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer )
-          && ( variablePointers == rhs.variablePointers );
-    }
-
-    bool operator!=( PhysicalDeviceVariablePointerFeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceVariablePointerFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 variablePointersStorageBuffer;
-    Bool32 variablePointers;
-  };
-  static_assert( sizeof( PhysicalDeviceVariablePointerFeaturesKHR ) == sizeof( VkPhysicalDeviceVariablePointerFeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceIDPropertiesKHR
-  {
-    operator const VkPhysicalDeviceIDPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceIDPropertiesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceIDPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memcmp( deviceUUID, rhs.deviceUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( memcmp( driverUUID, rhs.driverUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( memcmp( deviceLUID, rhs.deviceLUID, VK_LUID_SIZE_KHR * sizeof( uint8_t ) ) == 0 )
-          && ( deviceNodeMask == rhs.deviceNodeMask )
-          && ( deviceLUIDValid == rhs.deviceLUIDValid );
-    }
-
-    bool operator!=( PhysicalDeviceIDPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceIdPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint8_t deviceUUID[VK_UUID_SIZE];
-    uint8_t driverUUID[VK_UUID_SIZE];
-    uint8_t deviceLUID[VK_LUID_SIZE_KHR];
-    uint32_t deviceNodeMask;
-    Bool32 deviceLUIDValid;
-  };
-  static_assert( sizeof( PhysicalDeviceIDPropertiesKHR ) == sizeof( VkPhysicalDeviceIDPropertiesKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportMemoryWin32HandleInfoKHR
-  {
-    ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
-    }
-
-    ExportMemoryWin32HandleInfoKHR& operator=( VkExportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkExportMemoryWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryWin32HandlePropertiesKHR
-  {
-    operator const VkMemoryWin32HandlePropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryWin32HandlePropertiesKHR*>(this);
-    }
-
-    bool operator==( MemoryWin32HandlePropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryWin32HandlePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct MemoryFdPropertiesKHR
-  {
-    operator const VkMemoryFdPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryFdPropertiesKHR*>(this);
-    }
-
-    bool operator==( MemoryFdPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryFdPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryFdPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct Win32KeyedMutexAcquireReleaseInfoKHR
-  {
-    Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = 0, const DeviceMemory* pAcquireSyncs_ = nullptr, const uint64_t* pAcquireKeys_ = nullptr, const uint32_t* pAcquireTimeouts_ = nullptr, uint32_t releaseCount_ = 0, const DeviceMemory* pReleaseSyncs_ = nullptr, const uint64_t* pReleaseKeys_ = nullptr )
-      : acquireCount( acquireCount_ )
-      , pAcquireSyncs( pAcquireSyncs_ )
-      , pAcquireKeys( pAcquireKeys_ )
-      , pAcquireTimeouts( pAcquireTimeouts_ )
-      , releaseCount( releaseCount_ )
-      , pReleaseSyncs( pReleaseSyncs_ )
-      , pReleaseKeys( pReleaseKeys_ )
-    {
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) );
-      return *this;
-    }
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setAcquireCount( uint32_t acquireCount_ )
-    {
-      acquireCount = acquireCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireSyncs( const DeviceMemory* pAcquireSyncs_ )
-    {
-      pAcquireSyncs = pAcquireSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireKeys( const uint64_t* pAcquireKeys_ )
-    {
-      pAcquireKeys = pAcquireKeys_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPAcquireTimeouts( const uint32_t* pAcquireTimeouts_ )
-    {
-      pAcquireTimeouts = pAcquireTimeouts_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setReleaseCount( uint32_t releaseCount_ )
-    {
-      releaseCount = releaseCount_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseSyncs( const DeviceMemory* pReleaseSyncs_ )
-    {
-      pReleaseSyncs = pReleaseSyncs_;
-      return *this;
-    }
-
-    Win32KeyedMutexAcquireReleaseInfoKHR& setPReleaseKeys( const uint64_t* pReleaseKeys_ )
-    {
-      pReleaseKeys = pReleaseKeys_;
-      return *this;
-    }
-
-    operator const VkWin32KeyedMutexAcquireReleaseInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR*>(this);
-    }
-
-    bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( acquireCount == rhs.acquireCount )
-          && ( pAcquireSyncs == rhs.pAcquireSyncs )
-          && ( pAcquireKeys == rhs.pAcquireKeys )
-          && ( pAcquireTimeouts == rhs.pAcquireTimeouts )
-          && ( releaseCount == rhs.releaseCount )
-          && ( pReleaseSyncs == rhs.pReleaseSyncs )
-          && ( pReleaseKeys == rhs.pReleaseKeys );
-    }
-
-    bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t acquireCount;
-    const DeviceMemory* pAcquireSyncs;
-    const uint64_t* pAcquireKeys;
-    const uint32_t* pAcquireTimeouts;
-    uint32_t releaseCount;
-    const DeviceMemory* pReleaseSyncs;
-    const uint64_t* pReleaseKeys;
-  };
-  static_assert( sizeof( Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportSemaphoreWin32HandleInfoKHR
-  {
-    ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkExportSemaphoreWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct D3D12FenceSubmitInfoKHR
-  {
-    D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = 0, const uint64_t* pWaitSemaphoreValues_ = nullptr, uint32_t signalSemaphoreValuesCount_ = 0, const uint64_t* pSignalSemaphoreValues_ = nullptr )
-      : waitSemaphoreValuesCount( waitSemaphoreValuesCount_ )
-      , pWaitSemaphoreValues( pWaitSemaphoreValues_ )
-      , signalSemaphoreValuesCount( signalSemaphoreValuesCount_ )
-      , pSignalSemaphoreValues( pSignalSemaphoreValues_ )
-    {
-    }
-
-    D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
-    }
-
-    D3D12FenceSubmitInfoKHR& operator=( VkD3D12FenceSubmitInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( D3D12FenceSubmitInfoKHR ) );
-      return *this;
-    }
-    D3D12FenceSubmitInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ )
-    {
-      waitSemaphoreValuesCount = waitSemaphoreValuesCount_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setPWaitSemaphoreValues( const uint64_t* pWaitSemaphoreValues_ )
-    {
-      pWaitSemaphoreValues = pWaitSemaphoreValues_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ )
-    {
-      signalSemaphoreValuesCount = signalSemaphoreValuesCount_;
-      return *this;
-    }
-
-    D3D12FenceSubmitInfoKHR& setPSignalSemaphoreValues( const uint64_t* pSignalSemaphoreValues_ )
-    {
-      pSignalSemaphoreValues = pSignalSemaphoreValues_;
-      return *this;
-    }
-
-    operator const VkD3D12FenceSubmitInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkD3D12FenceSubmitInfoKHR*>(this);
-    }
-
-    bool operator==( D3D12FenceSubmitInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount )
-          && ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues )
-          && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount )
-          && ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
-    }
-
-    bool operator!=( D3D12FenceSubmitInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreValuesCount;
-    const uint64_t* pWaitSemaphoreValues;
-    uint32_t signalSemaphoreValuesCount;
-    const uint64_t* pSignalSemaphoreValues;
-  };
-  static_assert( sizeof( D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ExportFenceWin32HandleInfoKHR
-  {
-    ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES* pAttributes_ = nullptr, DWORD dwAccess_ = 0, LPCWSTR name_ = 0 )
-      : pAttributes( pAttributes_ )
-      , dwAccess( dwAccess_ )
-      , name( name_ )
-    {
-    }
-
-    ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
-    }
-
-    ExportFenceWin32HandleInfoKHR& operator=( VkExportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ExportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setPAttributes( const SECURITY_ATTRIBUTES* pAttributes_ )
-    {
-      pAttributes = pAttributes_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setDwAccess( DWORD dwAccess_ )
-    {
-      dwAccess = dwAccess_;
-      return *this;
-    }
-
-    ExportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkExportFenceWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ExportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pAttributes == rhs.pAttributes )
-          && ( dwAccess == rhs.dwAccess )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ExportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    const SECURITY_ATTRIBUTES* pAttributes;
-    DWORD dwAccess;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct PhysicalDeviceMultiviewFeaturesKHX
-  {
-    PhysicalDeviceMultiviewFeaturesKHX( Bool32 multiview_ = 0, Bool32 multiviewGeometryShader_ = 0, Bool32 multiviewTessellationShader_ = 0 )
-      : multiview( multiview_ )
-      , multiviewGeometryShader( multiviewGeometryShader_ )
-      , multiviewTessellationShader( multiviewTessellationShader_ )
-    {
-    }
-
-    PhysicalDeviceMultiviewFeaturesKHX( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) );
-    }
-
-    PhysicalDeviceMultiviewFeaturesKHX& operator=( VkPhysicalDeviceMultiviewFeaturesKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceMultiviewFeaturesKHX ) );
-      return *this;
-    }
-    PhysicalDeviceMultiviewFeaturesKHX& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeaturesKHX& setMultiview( Bool32 multiview_ )
-    {
-      multiview = multiview_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeaturesKHX& setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ )
-    {
-      multiviewGeometryShader = multiviewGeometryShader_;
-      return *this;
-    }
-
-    PhysicalDeviceMultiviewFeaturesKHX& setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ )
-    {
-      multiviewTessellationShader = multiviewTessellationShader_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceMultiviewFeaturesKHX&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewFeaturesKHX*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( multiview == rhs.multiview )
-          && ( multiviewGeometryShader == rhs.multiviewGeometryShader )
-          && ( multiviewTessellationShader == rhs.multiviewTessellationShader );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewFeaturesKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewFeaturesKHX;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 multiview;
-    Bool32 multiviewGeometryShader;
-    Bool32 multiviewTessellationShader;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewFeaturesKHX ) == sizeof( VkPhysicalDeviceMultiviewFeaturesKHX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMultiviewPropertiesKHX
-  {
-    operator const VkPhysicalDeviceMultiviewPropertiesKHX&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewPropertiesKHX*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount )
-          && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewPropertiesKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewPropertiesKHX;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxMultiviewViewCount;
-    uint32_t maxMultiviewInstanceIndex;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewPropertiesKHX ) == sizeof( VkPhysicalDeviceMultiviewPropertiesKHX ), "struct and wrapper have different size!" );
-
-  struct RenderPassMultiviewCreateInfoKHX
-  {
-    RenderPassMultiviewCreateInfoKHX( uint32_t subpassCount_ = 0, const uint32_t* pViewMasks_ = nullptr, uint32_t dependencyCount_ = 0, const int32_t* pViewOffsets_ = nullptr, uint32_t correlationMaskCount_ = 0, const uint32_t* pCorrelationMasks_ = nullptr )
-      : subpassCount( subpassCount_ )
-      , pViewMasks( pViewMasks_ )
-      , dependencyCount( dependencyCount_ )
-      , pViewOffsets( pViewOffsets_ )
-      , correlationMaskCount( correlationMaskCount_ )
-      , pCorrelationMasks( pCorrelationMasks_ )
-    {
-    }
-
-    RenderPassMultiviewCreateInfoKHX( VkRenderPassMultiviewCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) );
-    }
-
-    RenderPassMultiviewCreateInfoKHX& operator=( VkRenderPassMultiviewCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassMultiviewCreateInfoKHX ) );
-      return *this;
-    }
-    RenderPassMultiviewCreateInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setSubpassCount( uint32_t subpassCount_ )
-    {
-      subpassCount = subpassCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setPViewMasks( const uint32_t* pViewMasks_ )
-    {
-      pViewMasks = pViewMasks_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setDependencyCount( uint32_t dependencyCount_ )
-    {
-      dependencyCount = dependencyCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setPViewOffsets( const int32_t* pViewOffsets_ )
-    {
-      pViewOffsets = pViewOffsets_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setCorrelationMaskCount( uint32_t correlationMaskCount_ )
-    {
-      correlationMaskCount = correlationMaskCount_;
-      return *this;
-    }
-
-    RenderPassMultiviewCreateInfoKHX& setPCorrelationMasks( const uint32_t* pCorrelationMasks_ )
-    {
-      pCorrelationMasks = pCorrelationMasks_;
-      return *this;
-    }
-
-    operator const VkRenderPassMultiviewCreateInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkRenderPassMultiviewCreateInfoKHX*>(this);
-    }
-
-    bool operator==( RenderPassMultiviewCreateInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( subpassCount == rhs.subpassCount )
-          && ( pViewMasks == rhs.pViewMasks )
-          && ( dependencyCount == rhs.dependencyCount )
-          && ( pViewOffsets == rhs.pViewOffsets )
-          && ( correlationMaskCount == rhs.correlationMaskCount )
-          && ( pCorrelationMasks == rhs.pCorrelationMasks );
-    }
-
-    bool operator!=( RenderPassMultiviewCreateInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassMultiviewCreateInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t subpassCount;
-    const uint32_t* pViewMasks;
-    uint32_t dependencyCount;
-    const int32_t* pViewOffsets;
-    uint32_t correlationMaskCount;
-    const uint32_t* pCorrelationMasks;
-  };
-  static_assert( sizeof( RenderPassMultiviewCreateInfoKHX ) == sizeof( VkRenderPassMultiviewCreateInfoKHX ), "struct and wrapper have different size!" );
-
-  struct BindBufferMemoryInfoKHR
-  {
-    BindBufferMemoryInfoKHR( Buffer buffer_ = Buffer(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
-      : buffer( buffer_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-    {
-    }
-
-    BindBufferMemoryInfoKHR( VkBindBufferMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHR ) );
-    }
-
-    BindBufferMemoryInfoKHR& operator=( VkBindBufferMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryInfoKHR ) );
-      return *this;
-    }
-    BindBufferMemoryInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindBufferMemoryInfoKHR& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    BindBufferMemoryInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    BindBufferMemoryInfoKHR& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    operator const VkBindBufferMemoryInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkBindBufferMemoryInfoKHR*>(this);
-    }
-
-    bool operator==( BindBufferMemoryInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset );
-    }
-
-    bool operator!=( BindBufferMemoryInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindBufferMemoryInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-  };
-  static_assert( sizeof( BindBufferMemoryInfoKHR ) == sizeof( VkBindBufferMemoryInfoKHR ), "struct and wrapper have different size!" );
-
-  struct BindBufferMemoryDeviceGroupInfoKHX
-  {
-    BindBufferMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-    {
-    }
-
-    BindBufferMemoryDeviceGroupInfoKHX( VkBindBufferMemoryDeviceGroupInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfoKHX ) );
-    }
-
-    BindBufferMemoryDeviceGroupInfoKHX& operator=( VkBindBufferMemoryDeviceGroupInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindBufferMemoryDeviceGroupInfoKHX ) );
-      return *this;
-    }
-    BindBufferMemoryDeviceGroupInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindBufferMemoryDeviceGroupInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ )
-    {
-      deviceIndexCount = deviceIndexCount_;
-      return *this;
-    }
-
-    BindBufferMemoryDeviceGroupInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
-    {
-      pDeviceIndices = pDeviceIndices_;
-      return *this;
-    }
-
-    operator const VkBindBufferMemoryDeviceGroupInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfoKHX*>(this);
-    }
-
-    bool operator==( BindBufferMemoryDeviceGroupInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceIndexCount == rhs.deviceIndexCount )
-          && ( pDeviceIndices == rhs.pDeviceIndices );
-    }
-
-    bool operator!=( BindBufferMemoryDeviceGroupInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-  };
-  static_assert( sizeof( BindBufferMemoryDeviceGroupInfoKHX ) == sizeof( VkBindBufferMemoryDeviceGroupInfoKHX ), "struct and wrapper have different size!" );
-
-  struct BindImageMemoryInfoKHR
-  {
-    BindImageMemoryInfoKHR( Image image_ = Image(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0 )
-      : image( image_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-    {
-    }
-
-    BindImageMemoryInfoKHR( VkBindImageMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHR ) );
-    }
-
-    BindImageMemoryInfoKHR& operator=( VkBindImageMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryInfoKHR ) );
-      return *this;
-    }
-    BindImageMemoryInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemoryInfoKHR& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    BindImageMemoryInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    BindImageMemoryInfoKHR& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    operator const VkBindImageMemoryInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemoryInfoKHR*>(this);
-    }
-
-    bool operator==( BindImageMemoryInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset );
-    }
-
-    bool operator!=( BindImageMemoryInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemoryInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-  };
-  static_assert( sizeof( BindImageMemoryInfoKHR ) == sizeof( VkBindImageMemoryInfoKHR ), "struct and wrapper have different size!" );
-
-  struct BindImageMemoryDeviceGroupInfoKHX
-  {
-    BindImageMemoryDeviceGroupInfoKHX( uint32_t deviceIndexCount_ = 0, const uint32_t* pDeviceIndices_ = nullptr, uint32_t SFRRectCount_ = 0, const Rect2D* pSFRRects_ = nullptr )
-      : deviceIndexCount( deviceIndexCount_ )
-      , pDeviceIndices( pDeviceIndices_ )
-      , SFRRectCount( SFRRectCount_ )
-      , pSFRRects( pSFRRects_ )
-    {
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX( VkBindImageMemoryDeviceGroupInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfoKHX ) );
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX& operator=( VkBindImageMemoryDeviceGroupInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemoryDeviceGroupInfoKHX ) );
-      return *this;
-    }
-    BindImageMemoryDeviceGroupInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX& setDeviceIndexCount( uint32_t deviceIndexCount_ )
-    {
-      deviceIndexCount = deviceIndexCount_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX& setPDeviceIndices( const uint32_t* pDeviceIndices_ )
-    {
-      pDeviceIndices = pDeviceIndices_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX& setSFRRectCount( uint32_t SFRRectCount_ )
-    {
-      SFRRectCount = SFRRectCount_;
-      return *this;
-    }
-
-    BindImageMemoryDeviceGroupInfoKHX& setPSFRRects( const Rect2D* pSFRRects_ )
-    {
-      pSFRRects = pSFRRects_;
-      return *this;
-    }
-
-    operator const VkBindImageMemoryDeviceGroupInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemoryDeviceGroupInfoKHX*>(this);
-    }
-
-    bool operator==( BindImageMemoryDeviceGroupInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceIndexCount == rhs.deviceIndexCount )
-          && ( pDeviceIndices == rhs.pDeviceIndices )
-          && ( SFRRectCount == rhs.SFRRectCount )
-          && ( pSFRRects == rhs.pSFRRects );
-    }
-
-    bool operator!=( BindImageMemoryDeviceGroupInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceIndexCount;
-    const uint32_t* pDeviceIndices;
-    uint32_t SFRRectCount;
-    const Rect2D* pSFRRects;
-  };
-  static_assert( sizeof( BindImageMemoryDeviceGroupInfoKHX ) == sizeof( VkBindImageMemoryDeviceGroupInfoKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupRenderPassBeginInfoKHX
-  {
-    DeviceGroupRenderPassBeginInfoKHX( uint32_t deviceMask_ = 0, uint32_t deviceRenderAreaCount_ = 0, const Rect2D* pDeviceRenderAreas_ = nullptr )
-      : deviceMask( deviceMask_ )
-      , deviceRenderAreaCount( deviceRenderAreaCount_ )
-      , pDeviceRenderAreas( pDeviceRenderAreas_ )
-    {
-    }
-
-    DeviceGroupRenderPassBeginInfoKHX( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) );
-    }
-
-    DeviceGroupRenderPassBeginInfoKHX& operator=( VkDeviceGroupRenderPassBeginInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupRenderPassBeginInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupRenderPassBeginInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfoKHX& setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ )
-    {
-      deviceRenderAreaCount = deviceRenderAreaCount_;
-      return *this;
-    }
-
-    DeviceGroupRenderPassBeginInfoKHX& setPDeviceRenderAreas( const Rect2D* pDeviceRenderAreas_ )
-    {
-      pDeviceRenderAreas = pDeviceRenderAreas_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupRenderPassBeginInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupRenderPassBeginInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceMask == rhs.deviceMask )
-          && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount )
-          && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
-    }
-
-    bool operator!=( DeviceGroupRenderPassBeginInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
-    uint32_t deviceRenderAreaCount;
-    const Rect2D* pDeviceRenderAreas;
-  };
-  static_assert( sizeof( DeviceGroupRenderPassBeginInfoKHX ) == sizeof( VkDeviceGroupRenderPassBeginInfoKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupCommandBufferBeginInfoKHX
-  {
-    DeviceGroupCommandBufferBeginInfoKHX( uint32_t deviceMask_ = 0 )
-      : deviceMask( deviceMask_ )
-    {
-    }
-
-    DeviceGroupCommandBufferBeginInfoKHX( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) );
-    }
-
-    DeviceGroupCommandBufferBeginInfoKHX& operator=( VkDeviceGroupCommandBufferBeginInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupCommandBufferBeginInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupCommandBufferBeginInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupCommandBufferBeginInfoKHX& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupCommandBufferBeginInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( DeviceGroupCommandBufferBeginInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( DeviceGroupCommandBufferBeginInfoKHX ) == sizeof( VkDeviceGroupCommandBufferBeginInfoKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupSubmitInfoKHX
-  {
-    DeviceGroupSubmitInfoKHX( uint32_t waitSemaphoreCount_ = 0, const uint32_t* pWaitSemaphoreDeviceIndices_ = nullptr, uint32_t commandBufferCount_ = 0, const uint32_t* pCommandBufferDeviceMasks_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const uint32_t* pSignalSemaphoreDeviceIndices_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphoreDeviceIndices( pWaitSemaphoreDeviceIndices_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBufferDeviceMasks( pCommandBufferDeviceMasks_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphoreDeviceIndices( pSignalSemaphoreDeviceIndices_ )
-    {
-    }
-
-    DeviceGroupSubmitInfoKHX( VkDeviceGroupSubmitInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) );
-    }
-
-    DeviceGroupSubmitInfoKHX& operator=( VkDeviceGroupSubmitInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSubmitInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupSubmitInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setPWaitSemaphoreDeviceIndices( const uint32_t* pWaitSemaphoreDeviceIndices_ )
-    {
-      pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setPCommandBufferDeviceMasks( const uint32_t* pCommandBufferDeviceMasks_ )
-    {
-      pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    DeviceGroupSubmitInfoKHX& setPSignalSemaphoreDeviceIndices( const uint32_t* pSignalSemaphoreDeviceIndices_ )
-    {
-      pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupSubmitInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupSubmitInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupSubmitInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices )
-          && ( commandBufferCount == rhs.commandBufferCount )
-          && ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
-    }
-
-    bool operator!=( DeviceGroupSubmitInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupSubmitInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const uint32_t* pWaitSemaphoreDeviceIndices;
-    uint32_t commandBufferCount;
-    const uint32_t* pCommandBufferDeviceMasks;
-    uint32_t signalSemaphoreCount;
-    const uint32_t* pSignalSemaphoreDeviceIndices;
-  };
-  static_assert( sizeof( DeviceGroupSubmitInfoKHX ) == sizeof( VkDeviceGroupSubmitInfoKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupBindSparseInfoKHX
-  {
-    DeviceGroupBindSparseInfoKHX( uint32_t resourceDeviceIndex_ = 0, uint32_t memoryDeviceIndex_ = 0 )
-      : resourceDeviceIndex( resourceDeviceIndex_ )
-      , memoryDeviceIndex( memoryDeviceIndex_ )
-    {
-    }
-
-    DeviceGroupBindSparseInfoKHX( VkDeviceGroupBindSparseInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) );
-    }
-
-    DeviceGroupBindSparseInfoKHX& operator=( VkDeviceGroupBindSparseInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupBindSparseInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupBindSparseInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupBindSparseInfoKHX& setResourceDeviceIndex( uint32_t resourceDeviceIndex_ )
-    {
-      resourceDeviceIndex = resourceDeviceIndex_;
-      return *this;
-    }
-
-    DeviceGroupBindSparseInfoKHX& setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ )
-    {
-      memoryDeviceIndex = memoryDeviceIndex_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupBindSparseInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupBindSparseInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupBindSparseInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( resourceDeviceIndex == rhs.resourceDeviceIndex )
-          && ( memoryDeviceIndex == rhs.memoryDeviceIndex );
-    }
-
-    bool operator!=( DeviceGroupBindSparseInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupBindSparseInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t resourceDeviceIndex;
-    uint32_t memoryDeviceIndex;
-  };
-  static_assert( sizeof( DeviceGroupBindSparseInfoKHX ) == sizeof( VkDeviceGroupBindSparseInfoKHX ), "struct and wrapper have different size!" );
-
-  struct ImageSwapchainCreateInfoKHX
-  {
-    ImageSwapchainCreateInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR() )
-      : swapchain( swapchain_ )
-    {
-    }
-
-    ImageSwapchainCreateInfoKHX( VkImageSwapchainCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) );
-    }
-
-    ImageSwapchainCreateInfoKHX& operator=( VkImageSwapchainCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSwapchainCreateInfoKHX ) );
-      return *this;
-    }
-    ImageSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageSwapchainCreateInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    operator const VkImageSwapchainCreateInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkImageSwapchainCreateInfoKHX*>(this);
-    }
-
-    bool operator==( ImageSwapchainCreateInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain );
-    }
-
-    bool operator!=( ImageSwapchainCreateInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageSwapchainCreateInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-  };
-  static_assert( sizeof( ImageSwapchainCreateInfoKHX ) == sizeof( VkImageSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
-
-  struct BindImageMemorySwapchainInfoKHX
-  {
-    BindImageMemorySwapchainInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint32_t imageIndex_ = 0 )
-      : swapchain( swapchain_ )
-      , imageIndex( imageIndex_ )
-    {
-    }
-
-    BindImageMemorySwapchainInfoKHX( VkBindImageMemorySwapchainInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) );
-    }
-
-    BindImageMemorySwapchainInfoKHX& operator=( VkBindImageMemorySwapchainInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImageMemorySwapchainInfoKHX ) );
-      return *this;
-    }
-    BindImageMemorySwapchainInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImageMemorySwapchainInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    BindImageMemorySwapchainInfoKHX& setImageIndex( uint32_t imageIndex_ )
-    {
-      imageIndex = imageIndex_;
-      return *this;
-    }
-
-    operator const VkBindImageMemorySwapchainInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkBindImageMemorySwapchainInfoKHX*>(this);
-    }
-
-    bool operator==( BindImageMemorySwapchainInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain )
-          && ( imageIndex == rhs.imageIndex );
-    }
-
-    bool operator!=( BindImageMemorySwapchainInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint32_t imageIndex;
-  };
-  static_assert( sizeof( BindImageMemorySwapchainInfoKHX ) == sizeof( VkBindImageMemorySwapchainInfoKHX ), "struct and wrapper have different size!" );
-
-  struct AcquireNextImageInfoKHX
-  {
-    AcquireNextImageInfoKHX( SwapchainKHR swapchain_ = SwapchainKHR(), uint64_t timeout_ = 0, Semaphore semaphore_ = Semaphore(), Fence fence_ = Fence(), uint32_t deviceMask_ = 0 )
-      : swapchain( swapchain_ )
-      , timeout( timeout_ )
-      , semaphore( semaphore_ )
-      , fence( fence_ )
-      , deviceMask( deviceMask_ )
-    {
-    }
-
-    AcquireNextImageInfoKHX( VkAcquireNextImageInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) );
-    }
-
-    AcquireNextImageInfoKHX& operator=( VkAcquireNextImageInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AcquireNextImageInfoKHX ) );
-      return *this;
-    }
-    AcquireNextImageInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHX& setSwapchain( SwapchainKHR swapchain_ )
-    {
-      swapchain = swapchain_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHX& setTimeout( uint64_t timeout_ )
-    {
-      timeout = timeout_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHX& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHX& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    AcquireNextImageInfoKHX& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator const VkAcquireNextImageInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkAcquireNextImageInfoKHX*>(this);
-    }
-
-    bool operator==( AcquireNextImageInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchain == rhs.swapchain )
-          && ( timeout == rhs.timeout )
-          && ( semaphore == rhs.semaphore )
-          && ( fence == rhs.fence )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( AcquireNextImageInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eAcquireNextImageInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainKHR swapchain;
-    uint64_t timeout;
-    Semaphore semaphore;
-    Fence fence;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( AcquireNextImageInfoKHX ) == sizeof( VkAcquireNextImageInfoKHX ), "struct and wrapper have different size!" );
-
-  struct HdrMetadataEXT
-  {
-    HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = XYColorEXT(), XYColorEXT displayPrimaryGreen_ = XYColorEXT(), XYColorEXT displayPrimaryBlue_ = XYColorEXT(), XYColorEXT whitePoint_ = XYColorEXT(), float maxLuminance_ = 0, float minLuminance_ = 0, float maxContentLightLevel_ = 0, float maxFrameAverageLightLevel_ = 0 )
-      : displayPrimaryRed( displayPrimaryRed_ )
-      , displayPrimaryGreen( displayPrimaryGreen_ )
-      , displayPrimaryBlue( displayPrimaryBlue_ )
-      , whitePoint( whitePoint_ )
-      , maxLuminance( maxLuminance_ )
-      , minLuminance( minLuminance_ )
-      , maxContentLightLevel( maxContentLightLevel_ )
-      , maxFrameAverageLightLevel( maxFrameAverageLightLevel_ )
-    {
-    }
-
-    HdrMetadataEXT( VkHdrMetadataEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
-    }
-
-    HdrMetadataEXT& operator=( VkHdrMetadataEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( HdrMetadataEXT ) );
-      return *this;
-    }
-    HdrMetadataEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setDisplayPrimaryRed( XYColorEXT displayPrimaryRed_ )
-    {
-      displayPrimaryRed = displayPrimaryRed_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setDisplayPrimaryGreen( XYColorEXT displayPrimaryGreen_ )
-    {
-      displayPrimaryGreen = displayPrimaryGreen_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setDisplayPrimaryBlue( XYColorEXT displayPrimaryBlue_ )
-    {
-      displayPrimaryBlue = displayPrimaryBlue_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setWhitePoint( XYColorEXT whitePoint_ )
-    {
-      whitePoint = whitePoint_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setMaxLuminance( float maxLuminance_ )
-    {
-      maxLuminance = maxLuminance_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setMinLuminance( float minLuminance_ )
-    {
-      minLuminance = minLuminance_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setMaxContentLightLevel( float maxContentLightLevel_ )
-    {
-      maxContentLightLevel = maxContentLightLevel_;
-      return *this;
-    }
-
-    HdrMetadataEXT& setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ )
-    {
-      maxFrameAverageLightLevel = maxFrameAverageLightLevel_;
-      return *this;
-    }
-
-    operator const VkHdrMetadataEXT&() const
-    {
-      return *reinterpret_cast<const VkHdrMetadataEXT*>(this);
-    }
-
-    bool operator==( HdrMetadataEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayPrimaryRed == rhs.displayPrimaryRed )
-          && ( displayPrimaryGreen == rhs.displayPrimaryGreen )
-          && ( displayPrimaryBlue == rhs.displayPrimaryBlue )
-          && ( whitePoint == rhs.whitePoint )
-          && ( maxLuminance == rhs.maxLuminance )
-          && ( minLuminance == rhs.minLuminance )
-          && ( maxContentLightLevel == rhs.maxContentLightLevel )
-          && ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel );
-    }
-
-    bool operator!=( HdrMetadataEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eHdrMetadataEXT;
-
-  public:
-    const void* pNext = nullptr;
-    XYColorEXT displayPrimaryRed;
-    XYColorEXT displayPrimaryGreen;
-    XYColorEXT displayPrimaryBlue;
-    XYColorEXT whitePoint;
-    float maxLuminance;
-    float minLuminance;
-    float maxContentLightLevel;
-    float maxFrameAverageLightLevel;
-  };
-  static_assert( sizeof( HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" );
-
-  struct PresentTimesInfoGOOGLE
-  {
-    PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = 0, const PresentTimeGOOGLE* pTimes_ = nullptr )
-      : swapchainCount( swapchainCount_ )
-      , pTimes( pTimes_ )
-    {
-    }
-
-    PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
-    }
-
-    PresentTimesInfoGOOGLE& operator=( VkPresentTimesInfoGOOGLE const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentTimesInfoGOOGLE ) );
-      return *this;
-    }
-    PresentTimesInfoGOOGLE& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentTimesInfoGOOGLE& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentTimesInfoGOOGLE& setPTimes( const PresentTimeGOOGLE* pTimes_ )
-    {
-      pTimes = pTimes_;
-      return *this;
-    }
-
-    operator const VkPresentTimesInfoGOOGLE&() const
-    {
-      return *reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(this);
-    }
-
-    bool operator==( PresentTimesInfoGOOGLE const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pTimes == rhs.pTimes );
-    }
-
-    bool operator!=( PresentTimesInfoGOOGLE const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentTimesInfoGOOGLE;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const PresentTimeGOOGLE* pTimes;
-  };
-  static_assert( sizeof( PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  struct IOSSurfaceCreateInfoMVK
-  {
-    IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = IOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
-      : flags( flags_ )
-      , pView( pView_ )
-    {
-    }
-
-    IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
-    }
-
-    IOSSurfaceCreateInfoMVK& operator=( VkIOSSurfaceCreateInfoMVK const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IOSSurfaceCreateInfoMVK ) );
-      return *this;
-    }
-    IOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    IOSSurfaceCreateInfoMVK& setFlags( IOSSurfaceCreateFlagsMVK flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    IOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
-    {
-      pView = pView_;
-      return *this;
-    }
-
-    operator const VkIOSSurfaceCreateInfoMVK&() const
-    {
-      return *reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>(this);
-    }
-
-    bool operator==( IOSSurfaceCreateInfoMVK const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pView == rhs.pView );
-    }
-
-    bool operator!=( IOSSurfaceCreateInfoMVK const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eIosSurfaceCreateInfoMVK;
-
-  public:
-    const void* pNext = nullptr;
-    IOSSurfaceCreateFlagsMVK flags;
-    const void* pView;
-  };
-  static_assert( sizeof( IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  struct MacOSSurfaceCreateInfoMVK
-  {
-    MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = MacOSSurfaceCreateFlagsMVK(), const void* pView_ = nullptr )
-      : flags( flags_ )
-      , pView( pView_ )
-    {
-    }
-
-    MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
-    }
-
-    MacOSSurfaceCreateInfoMVK& operator=( VkMacOSSurfaceCreateInfoMVK const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MacOSSurfaceCreateInfoMVK ) );
-      return *this;
-    }
-    MacOSSurfaceCreateInfoMVK& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MacOSSurfaceCreateInfoMVK& setFlags( MacOSSurfaceCreateFlagsMVK flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    MacOSSurfaceCreateInfoMVK& setPView( const void* pView_ )
-    {
-      pView = pView_;
-      return *this;
-    }
-
-    operator const VkMacOSSurfaceCreateInfoMVK&() const
-    {
-      return *reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>(this);
-    }
-
-    bool operator==( MacOSSurfaceCreateInfoMVK const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pView == rhs.pView );
-    }
-
-    bool operator!=( MacOSSurfaceCreateInfoMVK const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK;
-
-  public:
-    const void* pNext = nullptr;
-    MacOSSurfaceCreateFlagsMVK flags;
-    const void* pView;
-  };
-  static_assert( sizeof( MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  struct PipelineViewportWScalingStateCreateInfoNV
-  {
-    PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = 0, uint32_t viewportCount_ = 0, const ViewportWScalingNV* pViewportWScalings_ = nullptr )
-      : viewportWScalingEnable( viewportWScalingEnable_ )
-      , viewportCount( viewportCount_ )
-      , pViewportWScalings( pViewportWScalings_ )
-    {
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV& operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportWScalingStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineViewportWScalingStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV& setViewportWScalingEnable( Bool32 viewportWScalingEnable_ )
-    {
-      viewportWScalingEnable = viewportWScalingEnable_;
-      return *this;
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
-    {
-      viewportCount = viewportCount_;
-      return *this;
-    }
-
-    PipelineViewportWScalingStateCreateInfoNV& setPViewportWScalings( const ViewportWScalingNV* pViewportWScalings_ )
-    {
-      pViewportWScalings = pViewportWScalings_;
-      return *this;
-    }
-
-    operator const VkPipelineViewportWScalingStateCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( viewportWScalingEnable == rhs.viewportWScalingEnable )
-          && ( viewportCount == rhs.viewportCount )
-          && ( pViewportWScalings == rhs.pViewportWScalings );
-    }
-
-    bool operator!=( PipelineViewportWScalingStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 viewportWScalingEnable;
-    uint32_t viewportCount;
-    const ViewportWScalingNV* pViewportWScalings;
-  };
-  static_assert( sizeof( PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceDiscardRectanglePropertiesEXT
-  {
-    PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = 0 )
-      : maxDiscardRectangles( maxDiscardRectangles_ )
-    {
-    }
-
-    PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
-    }
-
-    PhysicalDeviceDiscardRectanglePropertiesEXT& operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceDiscardRectanglePropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceDiscardRectanglePropertiesEXT& setMaxDiscardRectangles( uint32_t maxDiscardRectangles_ )
-    {
-      maxDiscardRectangles = maxDiscardRectangles_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceDiscardRectanglePropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
-    }
-
-    bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t maxDiscardRectangles;
-  };
-  static_assert( sizeof( PhysicalDeviceDiscardRectanglePropertiesEXT ) == sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
-  {
-    operator const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
-    }
-
-    bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 perViewPositionAllComponents;
-  };
-  static_assert( sizeof( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSurfaceInfo2KHR
-  {
-    PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = SurfaceKHR() )
-      : surface( surface_ )
-    {
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR& operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSurfaceInfo2KHR ) );
-      return *this;
-    }
-    PhysicalDeviceSurfaceInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceSurfaceInfo2KHR& setSurface( SurfaceKHR surface_ )
-    {
-      surface = surface_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceSurfaceInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surface == rhs.surface );
-    }
-
-    bool operator!=( PhysicalDeviceSurfaceInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    SurfaceKHR surface;
-  };
-  static_assert( sizeof( PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDevice16BitStorageFeaturesKHR
-  {
-    PhysicalDevice16BitStorageFeaturesKHR( Bool32 storageBuffer16BitAccess_ = 0, Bool32 uniformAndStorageBuffer16BitAccess_ = 0, Bool32 storagePushConstant16_ = 0, Bool32 storageInputOutput16_ = 0 )
-      : storageBuffer16BitAccess( storageBuffer16BitAccess_ )
-      , uniformAndStorageBuffer16BitAccess( uniformAndStorageBuffer16BitAccess_ )
-      , storagePushConstant16( storagePushConstant16_ )
-      , storageInputOutput16( storageInputOutput16_ )
-    {
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) );
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR& operator=( VkPhysicalDevice16BitStorageFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDevice16BitStorageFeaturesKHR ) );
-      return *this;
-    }
-    PhysicalDevice16BitStorageFeaturesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR& setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ )
-    {
-      storageBuffer16BitAccess = storageBuffer16BitAccess_;
-      return *this;
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR& setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ )
-    {
-      uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_;
-      return *this;
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR& setStoragePushConstant16( Bool32 storagePushConstant16_ )
-    {
-      storagePushConstant16 = storagePushConstant16_;
-      return *this;
-    }
-
-    PhysicalDevice16BitStorageFeaturesKHR& setStorageInputOutput16( Bool32 storageInputOutput16_ )
-    {
-      storageInputOutput16 = storageInputOutput16_;
-      return *this;
-    }
-
-    operator const VkPhysicalDevice16BitStorageFeaturesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevice16BitStorageFeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess )
-          && ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess )
-          && ( storagePushConstant16 == rhs.storagePushConstant16 )
-          && ( storageInputOutput16 == rhs.storageInputOutput16 );
-    }
-
-    bool operator!=( PhysicalDevice16BitStorageFeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevice16BitStorageFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 storageBuffer16BitAccess;
-    Bool32 uniformAndStorageBuffer16BitAccess;
-    Bool32 storagePushConstant16;
-    Bool32 storageInputOutput16;
-  };
-  static_assert( sizeof( PhysicalDevice16BitStorageFeaturesKHR ) == sizeof( VkPhysicalDevice16BitStorageFeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct BufferMemoryRequirementsInfo2KHR
-  {
-    BufferMemoryRequirementsInfo2KHR( Buffer buffer_ = Buffer() )
-      : buffer( buffer_ )
-    {
-    }
-
-    BufferMemoryRequirementsInfo2KHR( VkBufferMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) );
-    }
-
-    BufferMemoryRequirementsInfo2KHR& operator=( VkBufferMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryRequirementsInfo2KHR ) );
-      return *this;
-    }
-    BufferMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BufferMemoryRequirementsInfo2KHR& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator const VkBufferMemoryRequirementsInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>(this);
-    }
-
-    bool operator==( BufferMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( BufferMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBufferMemoryRequirementsInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    Buffer buffer;
-  };
-  static_assert( sizeof( BufferMemoryRequirementsInfo2KHR ) == sizeof( VkBufferMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
-
-  struct ImageMemoryRequirementsInfo2KHR
-  {
-    ImageMemoryRequirementsInfo2KHR( Image image_ = Image() )
-      : image( image_ )
-    {
-    }
-
-    ImageMemoryRequirementsInfo2KHR( VkImageMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) );
-    }
-
-    ImageMemoryRequirementsInfo2KHR& operator=( VkImageMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryRequirementsInfo2KHR ) );
-      return *this;
-    }
-    ImageMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageMemoryRequirementsInfo2KHR& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    operator const VkImageMemoryRequirementsInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>(this);
-    }
-
-    bool operator==( ImageMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image );
-    }
-
-    bool operator!=( ImageMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageMemoryRequirementsInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-  };
-  static_assert( sizeof( ImageMemoryRequirementsInfo2KHR ) == sizeof( VkImageMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
-
-  struct ImageSparseMemoryRequirementsInfo2KHR
-  {
-    ImageSparseMemoryRequirementsInfo2KHR( Image image_ = Image() )
-      : image( image_ )
-    {
-    }
-
-    ImageSparseMemoryRequirementsInfo2KHR( VkImageSparseMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) );
-    }
-
-    ImageSparseMemoryRequirementsInfo2KHR& operator=( VkImageSparseMemoryRequirementsInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSparseMemoryRequirementsInfo2KHR ) );
-      return *this;
-    }
-    ImageSparseMemoryRequirementsInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageSparseMemoryRequirementsInfo2KHR& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    operator const VkImageSparseMemoryRequirementsInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>(this);
-    }
-
-    bool operator==( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image );
-    }
-
-    bool operator!=( ImageSparseMemoryRequirementsInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-  };
-  static_assert( sizeof( ImageSparseMemoryRequirementsInfo2KHR ) == sizeof( VkImageSparseMemoryRequirementsInfo2KHR ), "struct and wrapper have different size!" );
-
-  struct MemoryRequirements2KHR
-  {
-    operator const VkMemoryRequirements2KHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryRequirements2KHR*>(this);
-    }
-
-    bool operator==( MemoryRequirements2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryRequirements == rhs.memoryRequirements );
-    }
-
-    bool operator!=( MemoryRequirements2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryRequirements2KHR;
-
-  public:
-    void* pNext = nullptr;
-    MemoryRequirements memoryRequirements;
-  };
-  static_assert( sizeof( MemoryRequirements2KHR ) == sizeof( VkMemoryRequirements2KHR ), "struct and wrapper have different size!" );
-
-  struct MemoryDedicatedRequirementsKHR
-  {
-    operator const VkMemoryDedicatedRequirementsKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryDedicatedRequirementsKHR*>(this);
-    }
-
-    bool operator==( MemoryDedicatedRequirementsKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation )
-          && ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
-    }
-
-    bool operator!=( MemoryDedicatedRequirementsKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryDedicatedRequirementsKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 prefersDedicatedAllocation;
-    Bool32 requiresDedicatedAllocation;
-  };
-  static_assert( sizeof( MemoryDedicatedRequirementsKHR ) == sizeof( VkMemoryDedicatedRequirementsKHR ), "struct and wrapper have different size!" );
-
-  struct MemoryDedicatedAllocateInfoKHR
-  {
-    MemoryDedicatedAllocateInfoKHR( Image image_ = Image(), Buffer buffer_ = Buffer() )
-      : image( image_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    MemoryDedicatedAllocateInfoKHR( VkMemoryDedicatedAllocateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) );
-    }
-
-    MemoryDedicatedAllocateInfoKHR& operator=( VkMemoryDedicatedAllocateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryDedicatedAllocateInfoKHR ) );
-      return *this;
-    }
-    MemoryDedicatedAllocateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryDedicatedAllocateInfoKHR& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    MemoryDedicatedAllocateInfoKHR& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator const VkMemoryDedicatedAllocateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryDedicatedAllocateInfoKHR*>(this);
-    }
-
-    bool operator==( MemoryDedicatedAllocateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( image == rhs.image )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( MemoryDedicatedAllocateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryDedicatedAllocateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Image image;
-    Buffer buffer;
-  };
-  static_assert( sizeof( MemoryDedicatedAllocateInfoKHR ) == sizeof( VkMemoryDedicatedAllocateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct SamplerYcbcrConversionInfoKHR
-  {
-    SamplerYcbcrConversionInfoKHR( SamplerYcbcrConversionKHR conversion_ = SamplerYcbcrConversionKHR() )
-      : conversion( conversion_ )
-    {
-    }
-
-    SamplerYcbcrConversionInfoKHR( VkSamplerYcbcrConversionInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfoKHR ) );
-    }
-
-    SamplerYcbcrConversionInfoKHR& operator=( VkSamplerYcbcrConversionInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionInfoKHR ) );
-      return *this;
-    }
-    SamplerYcbcrConversionInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionInfoKHR& setConversion( SamplerYcbcrConversionKHR conversion_ )
-    {
-      conversion = conversion_;
-      return *this;
-    }
-
-    operator const VkSamplerYcbcrConversionInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionInfoKHR*>(this);
-    }
-
-    bool operator==( SamplerYcbcrConversionInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( conversion == rhs.conversion );
-    }
-
-    bool operator!=( SamplerYcbcrConversionInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerYcbcrConversionKHR conversion;
-  };
-  static_assert( sizeof( SamplerYcbcrConversionInfoKHR ) == sizeof( VkSamplerYcbcrConversionInfoKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSamplerYcbcrConversionFeaturesKHR
-  {
-    PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( Bool32 samplerYcbcrConversion_ = 0 )
-      : samplerYcbcrConversion( samplerYcbcrConversion_ )
-    {
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeaturesKHR( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) );
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& operator=( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) );
-      return *this;
-    }
-    PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceSamplerYcbcrConversionFeaturesKHR& setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ )
-    {
-      samplerYcbcrConversion = samplerYcbcrConversion_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
-    }
-
-    bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 samplerYcbcrConversion;
-  };
-  static_assert( sizeof( PhysicalDeviceSamplerYcbcrConversionFeaturesKHR ) == sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ), "struct and wrapper have different size!" );
-
-  struct SamplerYcbcrConversionImageFormatPropertiesKHR
-  {
-    operator const VkSamplerYcbcrConversionImageFormatPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionImageFormatPropertiesKHR*>(this);
-    }
-
-    bool operator==( SamplerYcbcrConversionImageFormatPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
-    }
-
-    bool operator!=( SamplerYcbcrConversionImageFormatPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t combinedImageSamplerDescriptorCount;
-  };
-  static_assert( sizeof( SamplerYcbcrConversionImageFormatPropertiesKHR ) == sizeof( VkSamplerYcbcrConversionImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct TextureLODGatherFormatPropertiesAMD
-  {
-    operator const VkTextureLODGatherFormatPropertiesAMD&() const
-    {
-      return *reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD*>(this);
-    }
-
-    bool operator==( TextureLODGatherFormatPropertiesAMD const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
-    }
-
-    bool operator!=( TextureLODGatherFormatPropertiesAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 supportsTextureGatherLODBiasAMD;
-  };
-  static_assert( sizeof( TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), "struct and wrapper have different size!" );
-
-  struct PipelineCoverageToColorStateCreateInfoNV
-  {
-    PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = PipelineCoverageToColorStateCreateFlagsNV(), Bool32 coverageToColorEnable_ = 0, uint32_t coverageToColorLocation_ = 0 )
-      : flags( flags_ )
-      , coverageToColorEnable( coverageToColorEnable_ )
-      , coverageToColorLocation( coverageToColorLocation_ )
-    {
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageToColorStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineCoverageToColorStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorEnable( Bool32 coverageToColorEnable_ )
-    {
-      coverageToColorEnable = coverageToColorEnable_;
-      return *this;
-    }
-
-    PipelineCoverageToColorStateCreateInfoNV& setCoverageToColorLocation( uint32_t coverageToColorLocation_ )
-    {
-      coverageToColorLocation = coverageToColorLocation_;
-      return *this;
-    }
-
-    operator const VkPipelineCoverageToColorStateCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( coverageToColorEnable == rhs.coverageToColorEnable )
-          && ( coverageToColorLocation == rhs.coverageToColorLocation );
-    }
-
-    bool operator!=( PipelineCoverageToColorStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageToColorStateCreateFlagsNV flags;
-    Bool32 coverageToColorEnable;
-    uint32_t coverageToColorLocation;
-  };
-  static_assert( sizeof( PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSamplerFilterMinmaxPropertiesEXT
-  {
-    operator const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats )
-          && ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
-    }
-
-    bool operator!=( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 filterMinmaxSingleComponentFormats;
-    Bool32 filterMinmaxImageComponentMapping;
-  };
-  static_assert( sizeof( PhysicalDeviceSamplerFilterMinmaxPropertiesEXT ) == sizeof( VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct MultisamplePropertiesEXT
-  {
-    operator const VkMultisamplePropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkMultisamplePropertiesEXT*>(this);
-    }
-
-    bool operator==( MultisamplePropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
-    }
-
-    bool operator!=( MultisamplePropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMultisamplePropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Extent2D maxSampleLocationGridSize;
-  };
-  static_assert( sizeof( MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT
-  {
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = 0 )
-      : advancedBlendCoherentOperations( advancedBlendCoherentOperations_ )
-    {
-    }
-
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
-    }
-
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceBlendOperationAdvancedFeaturesEXT& setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ )
-    {
-      advancedBlendCoherentOperations = advancedBlendCoherentOperations_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations );
-    }
-
-    bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-
-  public:
-    void* pNext = nullptr;
-    Bool32 advancedBlendCoherentOperations;
-  };
-  static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT
-  {
-    operator const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments )
-          && ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend )
-          && ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor )
-          && ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor )
-          && ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap )
-          && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations );
-    }
-
-    bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t advancedBlendMaxColorAttachments;
-    Bool32 advancedBlendIndependentBlend;
-    Bool32 advancedBlendNonPremultipliedSrcColor;
-    Bool32 advancedBlendNonPremultipliedDstColor;
-    Bool32 advancedBlendCorrelatedOverlap;
-    Bool32 advancedBlendAllOperations;
-  };
-  static_assert( sizeof( PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct ImageFormatListCreateInfoKHR
-  {
-    ImageFormatListCreateInfoKHR( uint32_t viewFormatCount_ = 0, const Format* pViewFormats_ = nullptr )
-      : viewFormatCount( viewFormatCount_ )
-      , pViewFormats( pViewFormats_ )
-    {
-    }
-
-    ImageFormatListCreateInfoKHR( VkImageFormatListCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
-    }
-
-    ImageFormatListCreateInfoKHR& operator=( VkImageFormatListCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageFormatListCreateInfoKHR ) );
-      return *this;
-    }
-    ImageFormatListCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageFormatListCreateInfoKHR& setViewFormatCount( uint32_t viewFormatCount_ )
-    {
-      viewFormatCount = viewFormatCount_;
-      return *this;
-    }
-
-    ImageFormatListCreateInfoKHR& setPViewFormats( const Format* pViewFormats_ )
-    {
-      pViewFormats = pViewFormats_;
-      return *this;
-    }
-
-    operator const VkImageFormatListCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImageFormatListCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ImageFormatListCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( viewFormatCount == rhs.viewFormatCount )
-          && ( pViewFormats == rhs.pViewFormats );
-    }
-
-    bool operator!=( ImageFormatListCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageFormatListCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t viewFormatCount;
-    const Format* pViewFormats;
-  };
-  static_assert( sizeof( ImageFormatListCreateInfoKHR ) == sizeof( VkImageFormatListCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ValidationCacheCreateInfoEXT
-  {
-    ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = ValidationCacheCreateFlagsEXT(), size_t initialDataSize_ = 0, const void* pInitialData_ = nullptr )
-      : flags( flags_ )
-      , initialDataSize( initialDataSize_ )
-      , pInitialData( pInitialData_ )
-    {
-    }
-
-    ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
-    }
-
-    ValidationCacheCreateInfoEXT& operator=( VkValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationCacheCreateInfoEXT ) );
-      return *this;
-    }
-    ValidationCacheCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setFlags( ValidationCacheCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setInitialDataSize( size_t initialDataSize_ )
-    {
-      initialDataSize = initialDataSize_;
-      return *this;
-    }
-
-    ValidationCacheCreateInfoEXT& setPInitialData( const void* pInitialData_ )
-    {
-      pInitialData = pInitialData_;
-      return *this;
-    }
-
-    operator const VkValidationCacheCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkValidationCacheCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( initialDataSize == rhs.initialDataSize )
-          && ( pInitialData == rhs.pInitialData );
-    }
-
-    bool operator!=( ValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheCreateFlagsEXT flags;
-    size_t initialDataSize;
-    const void* pInitialData;
-  };
-  static_assert( sizeof( ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct ShaderModuleValidationCacheCreateInfoEXT
-  {
-    ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = ValidationCacheEXT() )
-      : validationCache( validationCache_ )
-    {
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT& operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ShaderModuleValidationCacheCreateInfoEXT ) );
-      return *this;
-    }
-    ShaderModuleValidationCacheCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ShaderModuleValidationCacheCreateInfoEXT& setValidationCache( ValidationCacheEXT validationCache_ )
-    {
-      validationCache = validationCache_;
-      return *this;
-    }
-
-    operator const VkShaderModuleValidationCacheCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT*>(this);
-    }
-
-    bool operator==( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( validationCache == rhs.validationCache );
-    }
-
-    bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ValidationCacheEXT validationCache;
-  };
-  static_assert( sizeof( ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct MemoryHostPointerPropertiesEXT
-  {
-    MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = 0 )
-      : memoryTypeBits( memoryTypeBits_ )
-    {
-    }
-
-    MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
-    }
-
-    MemoryHostPointerPropertiesEXT& operator=( VkMemoryHostPointerPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryHostPointerPropertiesEXT ) );
-      return *this;
-    }
-    MemoryHostPointerPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryHostPointerPropertiesEXT& setMemoryTypeBits( uint32_t memoryTypeBits_ )
-    {
-      memoryTypeBits = memoryTypeBits_;
-      return *this;
-    }
-
-    operator const VkMemoryHostPointerPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkMemoryHostPointerPropertiesEXT*>(this);
-    }
-
-    bool operator==( MemoryHostPointerPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryTypeBits == rhs.memoryTypeBits );
-    }
-
-    bool operator!=( MemoryHostPointerPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t memoryTypeBits;
-  };
-  static_assert( sizeof( MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceExternalMemoryHostPropertiesEXT
-  {
-    PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = 0 )
-      : minImportedHostPointerAlignment( minImportedHostPointerAlignment_ )
-    {
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalMemoryHostPropertiesEXT& setMinImportedHostPointerAlignment( DeviceSize minImportedHostPointerAlignment_ )
-    {
-      minImportedHostPointerAlignment = minImportedHostPointerAlignment_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceExternalMemoryHostPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
-    }
-
-    bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    DeviceSize minImportedHostPointerAlignment;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalMemoryHostPropertiesEXT ) == sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceConservativeRasterizationPropertiesEXT
-  {
-    PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = 0, float maxExtraPrimitiveOverestimationSize_ = 0, float extraPrimitiveOverestimationSizeGranularity_ = 0, Bool32 primitiveUnderestimation_ = 0, Bool32 conservativePointAndLineRasterization_ = 0, Bool32 degenerateTrianglesRasterized_ = 0, Bool32 degenerateLinesRasterized_ = 0, Bool32 fullyCoveredFragmentShaderInputVariable_ = 0, Bool32 conservativeRasterizationPostDepthCoverage_ = 0 )
-      : primitiveOverestimationSize( primitiveOverestimationSize_ )
-      , maxExtraPrimitiveOverestimationSize( maxExtraPrimitiveOverestimationSize_ )
-      , extraPrimitiveOverestimationSizeGranularity( extraPrimitiveOverestimationSizeGranularity_ )
-      , primitiveUnderestimation( primitiveUnderestimation_ )
-      , conservativePointAndLineRasterization( conservativePointAndLineRasterization_ )
-      , degenerateTrianglesRasterized( degenerateTrianglesRasterized_ )
-      , degenerateLinesRasterized( degenerateLinesRasterized_ )
-      , fullyCoveredFragmentShaderInputVariable( fullyCoveredFragmentShaderInputVariable_ )
-      , conservativeRasterizationPostDepthCoverage( conservativeRasterizationPostDepthCoverage_ )
-    {
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) );
-      return *this;
-    }
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveOverestimationSize( float primitiveOverestimationSize_ )
-    {
-      primitiveOverestimationSize = primitiveOverestimationSize_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setMaxExtraPrimitiveOverestimationSize( float maxExtraPrimitiveOverestimationSize_ )
-    {
-      maxExtraPrimitiveOverestimationSize = maxExtraPrimitiveOverestimationSize_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setExtraPrimitiveOverestimationSizeGranularity( float extraPrimitiveOverestimationSizeGranularity_ )
-    {
-      extraPrimitiveOverestimationSizeGranularity = extraPrimitiveOverestimationSizeGranularity_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setPrimitiveUnderestimation( Bool32 primitiveUnderestimation_ )
-    {
-      primitiveUnderestimation = primitiveUnderestimation_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativePointAndLineRasterization( Bool32 conservativePointAndLineRasterization_ )
-    {
-      conservativePointAndLineRasterization = conservativePointAndLineRasterization_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateTrianglesRasterized( Bool32 degenerateTrianglesRasterized_ )
-    {
-      degenerateTrianglesRasterized = degenerateTrianglesRasterized_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setDegenerateLinesRasterized( Bool32 degenerateLinesRasterized_ )
-    {
-      degenerateLinesRasterized = degenerateLinesRasterized_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setFullyCoveredFragmentShaderInputVariable( Bool32 fullyCoveredFragmentShaderInputVariable_ )
-    {
-      fullyCoveredFragmentShaderInputVariable = fullyCoveredFragmentShaderInputVariable_;
-      return *this;
-    }
-
-    PhysicalDeviceConservativeRasterizationPropertiesEXT& setConservativeRasterizationPostDepthCoverage( Bool32 conservativeRasterizationPostDepthCoverage_ )
-    {
-      conservativeRasterizationPostDepthCoverage = conservativeRasterizationPostDepthCoverage_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceConservativeRasterizationPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize )
-          && ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize )
-          && ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity )
-          && ( primitiveUnderestimation == rhs.primitiveUnderestimation )
-          && ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization )
-          && ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized )
-          && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized )
-          && ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable )
-          && ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage );
-    }
-
-    bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    float primitiveOverestimationSize;
-    float maxExtraPrimitiveOverestimationSize;
-    float extraPrimitiveOverestimationSizeGranularity;
-    Bool32 primitiveUnderestimation;
-    Bool32 conservativePointAndLineRasterization;
-    Bool32 degenerateTrianglesRasterized;
-    Bool32 degenerateLinesRasterized;
-    Bool32 fullyCoveredFragmentShaderInputVariable;
-    Bool32 conservativeRasterizationPostDepthCoverage;
-  };
-  static_assert( sizeof( PhysicalDeviceConservativeRasterizationPropertiesEXT ) == sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), "struct and wrapper have different size!" );
-
-  enum class SubpassContents
-  {
-    eInline = VK_SUBPASS_CONTENTS_INLINE,
-    eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS
-  };
-
-  struct PresentInfoKHR
-  {
-    PresentInfoKHR( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t swapchainCount_ = 0, const SwapchainKHR* pSwapchains_ = nullptr, const uint32_t* pImageIndices_ = nullptr, Result* pResults_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , swapchainCount( swapchainCount_ )
-      , pSwapchains( pSwapchains_ )
-      , pImageIndices( pImageIndices_ )
-      , pResults( pResults_ )
-    {
-    }
-
-    PresentInfoKHR( VkPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
-    }
-
-    PresentInfoKHR& operator=( VkPresentInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PresentInfoKHR ) );
-      return *this;
-    }
-    PresentInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PresentInfoKHR& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    PresentInfoKHR& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPSwapchains( const SwapchainKHR* pSwapchains_ )
-    {
-      pSwapchains = pSwapchains_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPImageIndices( const uint32_t* pImageIndices_ )
-    {
-      pImageIndices = pImageIndices_;
-      return *this;
-    }
-
-    PresentInfoKHR& setPResults( Result* pResults_ )
-    {
-      pResults = pResults_;
-      return *this;
-    }
-
-    operator const VkPresentInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPresentInfoKHR*>(this);
-    }
-
-    bool operator==( PresentInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pSwapchains == rhs.pSwapchains )
-          && ( pImageIndices == rhs.pImageIndices )
-          && ( pResults == rhs.pResults );
-    }
-
-    bool operator!=( PresentInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePresentInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t swapchainCount;
-    const SwapchainKHR* pSwapchains;
-    const uint32_t* pImageIndices;
-    Result* pResults;
-  };
-  static_assert( sizeof( PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class DynamicState
-  {
-    eViewport = VK_DYNAMIC_STATE_VIEWPORT,
-    eScissor = VK_DYNAMIC_STATE_SCISSOR,
-    eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH,
-    eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS,
-    eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-    eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS,
-    eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-    eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-    eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-    eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV,
-    eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT,
-    eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT
-  };
-
-  struct PipelineDynamicStateCreateInfo
-  {
-    PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = PipelineDynamicStateCreateFlags(), uint32_t dynamicStateCount_ = 0, const DynamicState* pDynamicStates_ = nullptr )
-      : flags( flags_ )
-      , dynamicStateCount( dynamicStateCount_ )
-      , pDynamicStates( pDynamicStates_ )
-    {
-    }
-
-    PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
-    }
-
-    PipelineDynamicStateCreateInfo& operator=( VkPipelineDynamicStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDynamicStateCreateInfo ) );
-      return *this;
-    }
-    PipelineDynamicStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setFlags( PipelineDynamicStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setDynamicStateCount( uint32_t dynamicStateCount_ )
-    {
-      dynamicStateCount = dynamicStateCount_;
-      return *this;
-    }
-
-    PipelineDynamicStateCreateInfo& setPDynamicStates( const DynamicState* pDynamicStates_ )
-    {
-      pDynamicStates = pDynamicStates_;
-      return *this;
-    }
-
-    operator const VkPipelineDynamicStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineDynamicStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineDynamicStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( dynamicStateCount == rhs.dynamicStateCount )
-          && ( pDynamicStates == rhs.pDynamicStates );
-    }
-
-    bool operator!=( PipelineDynamicStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineDynamicStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDynamicStateCreateFlags flags;
-    uint32_t dynamicStateCount;
-    const DynamicState* pDynamicStates;
-  };
-  static_assert( sizeof( PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class DescriptorUpdateTemplateTypeKHR
-  {
-    eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
-    ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR
-  };
-
-  struct DescriptorUpdateTemplateCreateInfoKHR
-  {
-    DescriptorUpdateTemplateCreateInfoKHR( DescriptorUpdateTemplateCreateFlagsKHR flags_ = DescriptorUpdateTemplateCreateFlagsKHR(), uint32_t descriptorUpdateEntryCount_ = 0, const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ = nullptr, DescriptorUpdateTemplateTypeKHR templateType_ = DescriptorUpdateTemplateTypeKHR::eDescriptorSet, DescriptorSetLayout descriptorSetLayout_ = DescriptorSetLayout(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, PipelineLayout pipelineLayout_ = PipelineLayout(), uint32_t set_ = 0 )
-      : flags( flags_ )
-      , descriptorUpdateEntryCount( descriptorUpdateEntryCount_ )
-      , pDescriptorUpdateEntries( pDescriptorUpdateEntries_ )
-      , templateType( templateType_ )
-      , descriptorSetLayout( descriptorSetLayout_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , pipelineLayout( pipelineLayout_ )
-      , set( set_ )
-    {
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) );
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& operator=( VkDescriptorUpdateTemplateCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorUpdateTemplateCreateInfoKHR ) );
-      return *this;
-    }
-    DescriptorUpdateTemplateCreateInfoKHR& setPNext( void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setFlags( DescriptorUpdateTemplateCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ )
-    {
-      descriptorUpdateEntryCount = descriptorUpdateEntryCount_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries_ )
-    {
-      pDescriptorUpdateEntries = pDescriptorUpdateEntries_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setTemplateType( DescriptorUpdateTemplateTypeKHR templateType_ )
-    {
-      templateType = templateType_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ )
-    {
-      descriptorSetLayout = descriptorSetLayout_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
-    {
-      pipelineBindPoint = pipelineBindPoint_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    DescriptorUpdateTemplateCreateInfoKHR& setSet( uint32_t set_ )
-    {
-      set = set_;
-      return *this;
-    }
-
-    operator const VkDescriptorUpdateTemplateCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>(this);
-    }
-
-    bool operator==( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount )
-          && ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries )
-          && ( templateType == rhs.templateType )
-          && ( descriptorSetLayout == rhs.descriptorSetLayout )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( set == rhs.set );
-    }
-
-    bool operator!=( DescriptorUpdateTemplateCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfoKHR;
-
-  public:
-    void* pNext = nullptr;
-    DescriptorUpdateTemplateCreateFlagsKHR flags;
-    uint32_t descriptorUpdateEntryCount;
-    const DescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
-    DescriptorUpdateTemplateTypeKHR templateType;
-    DescriptorSetLayout descriptorSetLayout;
-    PipelineBindPoint pipelineBindPoint;
-    PipelineLayout pipelineLayout;
-    uint32_t set;
-  };
-  static_assert( sizeof( DescriptorUpdateTemplateCreateInfoKHR ) == sizeof( VkDescriptorUpdateTemplateCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ObjectType
-  {
-    eUnknown = VK_OBJECT_TYPE_UNKNOWN,
-    eInstance = VK_OBJECT_TYPE_INSTANCE,
-    ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE,
-    eDevice = VK_OBJECT_TYPE_DEVICE,
-    eQueue = VK_OBJECT_TYPE_QUEUE,
-    eSemaphore = VK_OBJECT_TYPE_SEMAPHORE,
-    eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER,
-    eFence = VK_OBJECT_TYPE_FENCE,
-    eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY,
-    eBuffer = VK_OBJECT_TYPE_BUFFER,
-    eImage = VK_OBJECT_TYPE_IMAGE,
-    eEvent = VK_OBJECT_TYPE_EVENT,
-    eQueryPool = VK_OBJECT_TYPE_QUERY_POOL,
-    eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW,
-    eImageView = VK_OBJECT_TYPE_IMAGE_VIEW,
-    eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE,
-    ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE,
-    ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT,
-    eRenderPass = VK_OBJECT_TYPE_RENDER_PASS,
-    ePipeline = VK_OBJECT_TYPE_PIPELINE,
-    eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT,
-    eSampler = VK_OBJECT_TYPE_SAMPLER,
-    eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL,
-    eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET,
-    eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER,
-    eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL,
-    eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR,
-    eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-    eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR,
-    eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR,
-    eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT,
-    eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR,
-    eObjectTableNVX = VK_OBJECT_TYPE_OBJECT_TABLE_NVX,
-    eIndirectCommandsLayoutNVX = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX,
-    eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR,
-    eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT
-  };
-
-  enum class QueueFlagBits
-  {
-    eGraphics = VK_QUEUE_GRAPHICS_BIT,
-    eCompute = VK_QUEUE_COMPUTE_BIT,
-    eTransfer = VK_QUEUE_TRANSFER_BIT,
-    eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT
-  };
-
-  using QueueFlags = Flags<QueueFlagBits, VkQueueFlags>;
-
-  VULKAN_HPP_INLINE QueueFlags operator|( QueueFlagBits bit0, QueueFlagBits bit1 )
-  {
-    return QueueFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueueFlags operator~( QueueFlagBits bits )
-  {
-    return ~( QueueFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueueFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueueFlagBits::eGraphics) | VkFlags(QueueFlagBits::eCompute) | VkFlags(QueueFlagBits::eTransfer) | VkFlags(QueueFlagBits::eSparseBinding)
-    };
-  };
-
-  struct QueueFamilyProperties
-  {
-    operator const VkQueueFamilyProperties&() const
-    {
-      return *reinterpret_cast<const VkQueueFamilyProperties*>(this);
-    }
-
-    bool operator==( QueueFamilyProperties const& rhs ) const
-    {
-      return ( queueFlags == rhs.queueFlags )
-          && ( queueCount == rhs.queueCount )
-          && ( timestampValidBits == rhs.timestampValidBits )
-          && ( minImageTransferGranularity == rhs.minImageTransferGranularity );
-    }
-
-    bool operator!=( QueueFamilyProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    QueueFlags queueFlags;
-    uint32_t queueCount;
-    uint32_t timestampValidBits;
-    Extent3D minImageTransferGranularity;
-  };
-  static_assert( sizeof( QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), "struct and wrapper have different size!" );
-
-  struct QueueFamilyProperties2KHR
-  {
-    operator const VkQueueFamilyProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkQueueFamilyProperties2KHR*>(this);
-    }
-
-    bool operator==( QueueFamilyProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( queueFamilyProperties == rhs.queueFamilyProperties );
-    }
-
-    bool operator!=( QueueFamilyProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eQueueFamilyProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    QueueFamilyProperties queueFamilyProperties;
-  };
-  static_assert( sizeof( QueueFamilyProperties2KHR ) == sizeof( VkQueueFamilyProperties2KHR ), "struct and wrapper have different size!" );
-
-  enum class MemoryPropertyFlagBits
-  {
-    eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-    eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-    eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
-    eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
-    eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT
-  };
-
-  using MemoryPropertyFlags = Flags<MemoryPropertyFlagBits, VkMemoryPropertyFlags>;
-
-  VULKAN_HPP_INLINE MemoryPropertyFlags operator|( MemoryPropertyFlagBits bit0, MemoryPropertyFlagBits bit1 )
-  {
-    return MemoryPropertyFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryPropertyFlags operator~( MemoryPropertyFlagBits bits )
-  {
-    return ~( MemoryPropertyFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryPropertyFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryPropertyFlagBits::eDeviceLocal) | VkFlags(MemoryPropertyFlagBits::eHostVisible) | VkFlags(MemoryPropertyFlagBits::eHostCoherent) | VkFlags(MemoryPropertyFlagBits::eHostCached) | VkFlags(MemoryPropertyFlagBits::eLazilyAllocated)
-    };
-  };
-
-  struct MemoryType
-  {
-    operator const VkMemoryType&() const
-    {
-      return *reinterpret_cast<const VkMemoryType*>(this);
-    }
-
-    bool operator==( MemoryType const& rhs ) const
-    {
-      return ( propertyFlags == rhs.propertyFlags )
-          && ( heapIndex == rhs.heapIndex );
-    }
-
-    bool operator!=( MemoryType const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    MemoryPropertyFlags propertyFlags;
-    uint32_t heapIndex;
-  };
-  static_assert( sizeof( MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" );
-
-  enum class MemoryHeapFlagBits
-  {
-    eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
-    eMultiInstanceKHX = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX
-  };
-
-  using MemoryHeapFlags = Flags<MemoryHeapFlagBits, VkMemoryHeapFlags>;
-
-  VULKAN_HPP_INLINE MemoryHeapFlags operator|( MemoryHeapFlagBits bit0, MemoryHeapFlagBits bit1 )
-  {
-    return MemoryHeapFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryHeapFlags operator~( MemoryHeapFlagBits bits )
-  {
-    return ~( MemoryHeapFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryHeapFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryHeapFlagBits::eDeviceLocal) | VkFlags(MemoryHeapFlagBits::eMultiInstanceKHX)
-    };
-  };
-
-  struct MemoryHeap
-  {
-    operator const VkMemoryHeap&() const
-    {
-      return *reinterpret_cast<const VkMemoryHeap*>(this);
-    }
-
-    bool operator==( MemoryHeap const& rhs ) const
-    {
-      return ( size == rhs.size )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( MemoryHeap const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize size;
-    MemoryHeapFlags flags;
-  };
-  static_assert( sizeof( MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMemoryProperties
-  {
-    operator const VkPhysicalDeviceMemoryProperties&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMemoryProperties const& rhs ) const
-    {
-      return ( memoryTypeCount == rhs.memoryTypeCount )
-          && ( memcmp( memoryTypes, rhs.memoryTypes, VK_MAX_MEMORY_TYPES * sizeof( MemoryType ) ) == 0 )
-          && ( memoryHeapCount == rhs.memoryHeapCount )
-          && ( memcmp( memoryHeaps, rhs.memoryHeaps, VK_MAX_MEMORY_HEAPS * sizeof( MemoryHeap ) ) == 0 );
-    }
-
-    bool operator!=( PhysicalDeviceMemoryProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t memoryTypeCount;
-    MemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
-    uint32_t memoryHeapCount;
-    MemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
-  };
-  static_assert( sizeof( PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceMemoryProperties2KHR
-  {
-    operator const VkPhysicalDeviceMemoryProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceMemoryProperties2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryProperties == rhs.memoryProperties );
-    }
-
-    bool operator!=( PhysicalDeviceMemoryProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceMemoryProperties memoryProperties;
-  };
-  static_assert( sizeof( PhysicalDeviceMemoryProperties2KHR ) == sizeof( VkPhysicalDeviceMemoryProperties2KHR ), "struct and wrapper have different size!" );
-
-  enum class AccessFlagBits
-  {
-    eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
-    eIndexRead = VK_ACCESS_INDEX_READ_BIT,
-    eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
-    eUniformRead = VK_ACCESS_UNIFORM_READ_BIT,
-    eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT,
-    eShaderRead = VK_ACCESS_SHADER_READ_BIT,
-    eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT,
-    eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
-    eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
-    eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
-    eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-    eTransferRead = VK_ACCESS_TRANSFER_READ_BIT,
-    eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT,
-    eHostRead = VK_ACCESS_HOST_READ_BIT,
-    eHostWrite = VK_ACCESS_HOST_WRITE_BIT,
-    eMemoryRead = VK_ACCESS_MEMORY_READ_BIT,
-    eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT,
-    eCommandProcessReadNVX = VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX,
-    eCommandProcessWriteNVX = VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX,
-    eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT
-  };
-
-  using AccessFlags = Flags<AccessFlagBits, VkAccessFlags>;
-
-  VULKAN_HPP_INLINE AccessFlags operator|( AccessFlagBits bit0, AccessFlagBits bit1 )
-  {
-    return AccessFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE AccessFlags operator~( AccessFlagBits bits )
-  {
-    return ~( AccessFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<AccessFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(AccessFlagBits::eIndirectCommandRead) | VkFlags(AccessFlagBits::eIndexRead) | VkFlags(AccessFlagBits::eVertexAttributeRead) | VkFlags(AccessFlagBits::eUniformRead) | VkFlags(AccessFlagBits::eInputAttachmentRead) | VkFlags(AccessFlagBits::eShaderRead) | VkFlags(AccessFlagBits::eShaderWrite) | VkFlags(AccessFlagBits::eColorAttachmentRead) | VkFlags(AccessFlagBits::eColorAttachmentWrite) | VkFlags(AccessFlagBits::eDepthStencilAttachmentRead) | VkFlags(AccessFlagBits::eDepthStencilAttachmentWrite) | VkFlags(AccessFlagBits::eTransferRead) | VkFlags(AccessFlagBits::eTransferWrite) | VkFlags(AccessFlagBits::eHostRead) | VkFlags(AccessFlagBits::eHostWrite) | VkFlags(AccessFlagBits::eMemoryRead) | VkFlags(AccessFlagBits::eMemoryWrite) | VkFlags(AccessFlagBits::eCommandProcessReadNVX) | VkFlags(AccessFlagBits::eCommandProcessWriteNVX) | VkFlags(AccessFlagBits::eColorAttachmentReadNoncoherentEXT)
-    };
-  };
-
-  struct MemoryBarrier
-  {
-    MemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-    {
-    }
-
-    MemoryBarrier( VkMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
-    }
-
-    MemoryBarrier& operator=( VkMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryBarrier ) );
-      return *this;
-    }
-    MemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    MemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    operator const VkMemoryBarrier&() const
-    {
-      return *reinterpret_cast<const VkMemoryBarrier*>(this);
-    }
-
-    bool operator==( MemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask );
-    }
-
-    bool operator!=( MemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-  };
-  static_assert( sizeof( MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" );
-
-  struct BufferMemoryBarrier
-  {
-    BufferMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0, DeviceSize size_ = 0 )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
-    }
-
-    BufferMemoryBarrier& operator=( VkBufferMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferMemoryBarrier ) );
-      return *this;
-    }
-    BufferMemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
-    {
-      srcQueueFamilyIndex = srcQueueFamilyIndex_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
-    {
-      dstQueueFamilyIndex = dstQueueFamilyIndex_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    BufferMemoryBarrier& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator const VkBufferMemoryBarrier&() const
-    {
-      return *reinterpret_cast<const VkBufferMemoryBarrier*>(this);
-    }
-
-    bool operator==( BufferMemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
-          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
-          && ( buffer == rhs.buffer )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( BufferMemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBufferMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Buffer buffer;
-    DeviceSize offset;
-    DeviceSize size;
-  };
-  static_assert( sizeof( BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" );
-
-  enum class BufferUsageFlagBits
-  {
-    eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
-    eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-    eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT,
-    eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT,
-    eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
-    eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT,
-    eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
-    eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
-    eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT
-  };
-
-  using BufferUsageFlags = Flags<BufferUsageFlagBits, VkBufferUsageFlags>;
-
-  VULKAN_HPP_INLINE BufferUsageFlags operator|( BufferUsageFlagBits bit0, BufferUsageFlagBits bit1 )
-  {
-    return BufferUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE BufferUsageFlags operator~( BufferUsageFlagBits bits )
-  {
-    return ~( BufferUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<BufferUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(BufferUsageFlagBits::eTransferSrc) | VkFlags(BufferUsageFlagBits::eTransferDst) | VkFlags(BufferUsageFlagBits::eUniformTexelBuffer) | VkFlags(BufferUsageFlagBits::eStorageTexelBuffer) | VkFlags(BufferUsageFlagBits::eUniformBuffer) | VkFlags(BufferUsageFlagBits::eStorageBuffer) | VkFlags(BufferUsageFlagBits::eIndexBuffer) | VkFlags(BufferUsageFlagBits::eVertexBuffer) | VkFlags(BufferUsageFlagBits::eIndirectBuffer)
-    };
-  };
-
-  enum class BufferCreateFlagBits
-  {
-    eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT,
-    eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,
-    eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT
-  };
-
-  using BufferCreateFlags = Flags<BufferCreateFlagBits, VkBufferCreateFlags>;
-
-  VULKAN_HPP_INLINE BufferCreateFlags operator|( BufferCreateFlagBits bit0, BufferCreateFlagBits bit1 )
-  {
-    return BufferCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE BufferCreateFlags operator~( BufferCreateFlagBits bits )
-  {
-    return ~( BufferCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<BufferCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(BufferCreateFlagBits::eSparseBinding) | VkFlags(BufferCreateFlagBits::eSparseResidency) | VkFlags(BufferCreateFlagBits::eSparseAliased)
-    };
-  };
-
-  struct BufferCreateInfo
-  {
-    BufferCreateInfo( BufferCreateFlags flags_ = BufferCreateFlags(), DeviceSize size_ = 0, BufferUsageFlags usage_ = BufferUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr )
-      : flags( flags_ )
-      , size( size_ )
-      , usage( usage_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-    {
-    }
-
-    BufferCreateInfo( VkBufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
-    }
-
-    BufferCreateInfo& operator=( VkBufferCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferCreateInfo ) );
-      return *this;
-    }
-    BufferCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BufferCreateInfo& setFlags( BufferCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    BufferCreateInfo& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    BufferCreateInfo& setUsage( BufferUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    BufferCreateInfo& setSharingMode( SharingMode sharingMode_ )
-    {
-      sharingMode = sharingMode_;
-      return *this;
-    }
-
-    BufferCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
-    {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
-    }
-
-    BufferCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    operator const VkBufferCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkBufferCreateInfo*>(this);
-    }
-
-    bool operator==( BufferCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( size == rhs.size )
-          && ( usage == rhs.usage )
-          && ( sharingMode == rhs.sharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
-    }
-
-    bool operator!=( BufferCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBufferCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    DeviceSize size;
-    BufferUsageFlags usage;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-  };
-  static_assert( sizeof( BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ShaderStageFlagBits
-  {
-    eVertex = VK_SHADER_STAGE_VERTEX_BIT,
-    eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
-    eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
-    eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT,
-    eFragment = VK_SHADER_STAGE_FRAGMENT_BIT,
-    eCompute = VK_SHADER_STAGE_COMPUTE_BIT,
-    eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS,
-    eAll = VK_SHADER_STAGE_ALL
-  };
-
-  using ShaderStageFlags = Flags<ShaderStageFlagBits, VkShaderStageFlags>;
-
-  VULKAN_HPP_INLINE ShaderStageFlags operator|( ShaderStageFlagBits bit0, ShaderStageFlagBits bit1 )
-  {
-    return ShaderStageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ShaderStageFlags operator~( ShaderStageFlagBits bits )
-  {
-    return ~( ShaderStageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ShaderStageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ShaderStageFlagBits::eVertex) | VkFlags(ShaderStageFlagBits::eTessellationControl) | VkFlags(ShaderStageFlagBits::eTessellationEvaluation) | VkFlags(ShaderStageFlagBits::eGeometry) | VkFlags(ShaderStageFlagBits::eFragment) | VkFlags(ShaderStageFlagBits::eCompute) | VkFlags(ShaderStageFlagBits::eAllGraphics) | VkFlags(ShaderStageFlagBits::eAll)
-    };
-  };
-
-  struct DescriptorSetLayoutBinding
-  {
-    DescriptorSetLayoutBinding( uint32_t binding_ = 0, DescriptorType descriptorType_ = DescriptorType::eSampler, uint32_t descriptorCount_ = 0, ShaderStageFlags stageFlags_ = ShaderStageFlags(), const Sampler* pImmutableSamplers_ = nullptr )
-      : binding( binding_ )
-      , descriptorType( descriptorType_ )
-      , descriptorCount( descriptorCount_ )
-      , stageFlags( stageFlags_ )
-      , pImmutableSamplers( pImmutableSamplers_ )
-    {
-    }
-
-    DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
-    }
-
-    DescriptorSetLayoutBinding& operator=( VkDescriptorSetLayoutBinding const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutBinding ) );
-      return *this;
-    }
-    DescriptorSetLayoutBinding& setBinding( uint32_t binding_ )
-    {
-      binding = binding_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setDescriptorType( DescriptorType descriptorType_ )
-    {
-      descriptorType = descriptorType_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setDescriptorCount( uint32_t descriptorCount_ )
-    {
-      descriptorCount = descriptorCount_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    DescriptorSetLayoutBinding& setPImmutableSamplers( const Sampler* pImmutableSamplers_ )
-    {
-      pImmutableSamplers = pImmutableSamplers_;
-      return *this;
-    }
-
-    operator const VkDescriptorSetLayoutBinding&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutBinding*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutBinding const& rhs ) const
-    {
-      return ( binding == rhs.binding )
-          && ( descriptorType == rhs.descriptorType )
-          && ( descriptorCount == rhs.descriptorCount )
-          && ( stageFlags == rhs.stageFlags )
-          && ( pImmutableSamplers == rhs.pImmutableSamplers );
-    }
-
-    bool operator!=( DescriptorSetLayoutBinding const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t binding;
-    DescriptorType descriptorType;
-    uint32_t descriptorCount;
-    ShaderStageFlags stageFlags;
-    const Sampler* pImmutableSamplers;
-  };
-  static_assert( sizeof( DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), "struct and wrapper have different size!" );
-
-  struct PipelineShaderStageCreateInfo
-  {
-    PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = PipelineShaderStageCreateFlags(), ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, ShaderModule module_ = ShaderModule(), const char* pName_ = nullptr, const SpecializationInfo* pSpecializationInfo_ = nullptr )
-      : flags( flags_ )
-      , stage( stage_ )
-      , module( module_ )
-      , pName( pName_ )
-      , pSpecializationInfo( pSpecializationInfo_ )
-    {
-    }
-
-    PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
-    }
-
-    PipelineShaderStageCreateInfo& operator=( VkPipelineShaderStageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineShaderStageCreateInfo ) );
-      return *this;
-    }
-    PipelineShaderStageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setFlags( PipelineShaderStageCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setStage( ShaderStageFlagBits stage_ )
-    {
-      stage = stage_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setModule( ShaderModule module_ )
-    {
-      module = module_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setPName( const char* pName_ )
-    {
-      pName = pName_;
-      return *this;
-    }
-
-    PipelineShaderStageCreateInfo& setPSpecializationInfo( const SpecializationInfo* pSpecializationInfo_ )
-    {
-      pSpecializationInfo = pSpecializationInfo_;
-      return *this;
-    }
-
-    operator const VkPipelineShaderStageCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineShaderStageCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineShaderStageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stage == rhs.stage )
-          && ( module == rhs.module )
-          && ( pName == rhs.pName )
-          && ( pSpecializationInfo == rhs.pSpecializationInfo );
-    }
-
-    bool operator!=( PipelineShaderStageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineShaderStageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineShaderStageCreateFlags flags;
-    ShaderStageFlagBits stage;
-    ShaderModule module;
-    const char* pName;
-    const SpecializationInfo* pSpecializationInfo;
-  };
-  static_assert( sizeof( PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PushConstantRange
-  {
-    PushConstantRange( ShaderStageFlags stageFlags_ = ShaderStageFlags(), uint32_t offset_ = 0, uint32_t size_ = 0 )
-      : stageFlags( stageFlags_ )
-      , offset( offset_ )
-      , size( size_ )
-    {
-    }
-
-    PushConstantRange( VkPushConstantRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PushConstantRange ) );
-    }
-
-    PushConstantRange& operator=( VkPushConstantRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PushConstantRange ) );
-      return *this;
-    }
-    PushConstantRange& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    PushConstantRange& setOffset( uint32_t offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    PushConstantRange& setSize( uint32_t size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    operator const VkPushConstantRange&() const
-    {
-      return *reinterpret_cast<const VkPushConstantRange*>(this);
-    }
-
-    bool operator==( PushConstantRange const& rhs ) const
-    {
-      return ( stageFlags == rhs.stageFlags )
-          && ( offset == rhs.offset )
-          && ( size == rhs.size );
-    }
-
-    bool operator!=( PushConstantRange const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ShaderStageFlags stageFlags;
-    uint32_t offset;
-    uint32_t size;
-  };
-  static_assert( sizeof( PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" );
-
-  struct PipelineLayoutCreateInfo
-  {
-    PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = PipelineLayoutCreateFlags(), uint32_t setLayoutCount_ = 0, const DescriptorSetLayout* pSetLayouts_ = nullptr, uint32_t pushConstantRangeCount_ = 0, const PushConstantRange* pPushConstantRanges_ = nullptr )
-      : flags( flags_ )
-      , setLayoutCount( setLayoutCount_ )
-      , pSetLayouts( pSetLayouts_ )
-      , pushConstantRangeCount( pushConstantRangeCount_ )
-      , pPushConstantRanges( pPushConstantRanges_ )
-    {
-    }
-
-    PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
-    }
-
-    PipelineLayoutCreateInfo& operator=( VkPipelineLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineLayoutCreateInfo ) );
-      return *this;
-    }
-    PipelineLayoutCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setFlags( PipelineLayoutCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setSetLayoutCount( uint32_t setLayoutCount_ )
-    {
-      setLayoutCount = setLayoutCount_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPSetLayouts( const DescriptorSetLayout* pSetLayouts_ )
-    {
-      pSetLayouts = pSetLayouts_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPushConstantRangeCount( uint32_t pushConstantRangeCount_ )
-    {
-      pushConstantRangeCount = pushConstantRangeCount_;
-      return *this;
-    }
-
-    PipelineLayoutCreateInfo& setPPushConstantRanges( const PushConstantRange* pPushConstantRanges_ )
-    {
-      pPushConstantRanges = pPushConstantRanges_;
-      return *this;
-    }
-
-    operator const VkPipelineLayoutCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineLayoutCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineLayoutCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( setLayoutCount == rhs.setLayoutCount )
-          && ( pSetLayouts == rhs.pSetLayouts )
-          && ( pushConstantRangeCount == rhs.pushConstantRangeCount )
-          && ( pPushConstantRanges == rhs.pPushConstantRanges );
-    }
-
-    bool operator!=( PipelineLayoutCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineLayoutCreateFlags flags;
-    uint32_t setLayoutCount;
-    const DescriptorSetLayout* pSetLayouts;
-    uint32_t pushConstantRangeCount;
-    const PushConstantRange* pPushConstantRanges;
-  };
-  static_assert( sizeof( PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), "struct and wrapper have different size!" );
-
-  struct ShaderStatisticsInfoAMD
-  {
-    operator const VkShaderStatisticsInfoAMD&() const
-    {
-      return *reinterpret_cast<const VkShaderStatisticsInfoAMD*>(this);
-    }
-
-    bool operator==( ShaderStatisticsInfoAMD const& rhs ) const
-    {
-      return ( shaderStageMask == rhs.shaderStageMask )
-          && ( resourceUsage == rhs.resourceUsage )
-          && ( numPhysicalVgprs == rhs.numPhysicalVgprs )
-          && ( numPhysicalSgprs == rhs.numPhysicalSgprs )
-          && ( numAvailableVgprs == rhs.numAvailableVgprs )
-          && ( numAvailableSgprs == rhs.numAvailableSgprs )
-          && ( memcmp( computeWorkGroupSize, rhs.computeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 );
-    }
-
-    bool operator!=( ShaderStatisticsInfoAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ShaderStageFlags shaderStageMask;
-    ShaderResourceUsageAMD resourceUsage;
-    uint32_t numPhysicalVgprs;
-    uint32_t numPhysicalSgprs;
-    uint32_t numAvailableVgprs;
-    uint32_t numAvailableSgprs;
-    uint32_t computeWorkGroupSize[3];
-  };
-  static_assert( sizeof( ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), "struct and wrapper have different size!" );
-
-  enum class ImageUsageFlagBits
-  {
-    eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
-    eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
-    eSampled = VK_IMAGE_USAGE_SAMPLED_BIT,
-    eStorage = VK_IMAGE_USAGE_STORAGE_BIT,
-    eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-    eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
-    eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
-    eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
-  };
-
-  using ImageUsageFlags = Flags<ImageUsageFlagBits, VkImageUsageFlags>;
-
-  VULKAN_HPP_INLINE ImageUsageFlags operator|( ImageUsageFlagBits bit0, ImageUsageFlagBits bit1 )
-  {
-    return ImageUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageUsageFlags operator~( ImageUsageFlagBits bits )
-  {
-    return ~( ImageUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageUsageFlagBits::eTransferSrc) | VkFlags(ImageUsageFlagBits::eTransferDst) | VkFlags(ImageUsageFlagBits::eSampled) | VkFlags(ImageUsageFlagBits::eStorage) | VkFlags(ImageUsageFlagBits::eColorAttachment) | VkFlags(ImageUsageFlagBits::eDepthStencilAttachment) | VkFlags(ImageUsageFlagBits::eTransientAttachment) | VkFlags(ImageUsageFlagBits::eInputAttachment)
-    };
-  };
-
-  struct SharedPresentSurfaceCapabilitiesKHR
-  {
-    operator const VkSharedPresentSurfaceCapabilitiesKHR&() const
-    {
-      return *reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
-    }
-
-    bool operator!=( SharedPresentSurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ImageUsageFlags sharedPresentSupportedUsageFlags;
-  };
-  static_assert( sizeof( SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct ImageViewUsageCreateInfoKHR
-  {
-    ImageViewUsageCreateInfoKHR( ImageUsageFlags usage_ = ImageUsageFlags() )
-      : usage( usage_ )
-    {
-    }
-
-    ImageViewUsageCreateInfoKHR( VkImageViewUsageCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfoKHR ) );
-    }
-
-    ImageViewUsageCreateInfoKHR& operator=( VkImageViewUsageCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewUsageCreateInfoKHR ) );
-      return *this;
-    }
-    ImageViewUsageCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageViewUsageCreateInfoKHR& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    operator const VkImageViewUsageCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImageViewUsageCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ImageViewUsageCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( usage == rhs.usage );
-    }
-
-    bool operator!=( ImageViewUsageCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageViewUsageCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ImageUsageFlags usage;
-  };
-  static_assert( sizeof( ImageViewUsageCreateInfoKHR ) == sizeof( VkImageViewUsageCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ImageCreateFlagBits
-  {
-    eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT,
-    eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,
-    eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
-    eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
-    eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
-    eBindSfrKHX = VK_IMAGE_CREATE_BIND_SFR_BIT_KHX,
-    e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,
-    eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR,
-    eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
-    eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT,
-    eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR,
-    eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR
-  };
-
-  using ImageCreateFlags = Flags<ImageCreateFlagBits, VkImageCreateFlags>;
-
-  VULKAN_HPP_INLINE ImageCreateFlags operator|( ImageCreateFlagBits bit0, ImageCreateFlagBits bit1 )
-  {
-    return ImageCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageCreateFlags operator~( ImageCreateFlagBits bits )
-  {
-    return ~( ImageCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageCreateFlagBits::eSparseBinding) | VkFlags(ImageCreateFlagBits::eSparseResidency) | VkFlags(ImageCreateFlagBits::eSparseAliased) | VkFlags(ImageCreateFlagBits::eMutableFormat) | VkFlags(ImageCreateFlagBits::eCubeCompatible) | VkFlags(ImageCreateFlagBits::eBindSfrKHX) | VkFlags(ImageCreateFlagBits::e2DArrayCompatibleKHR) | VkFlags(ImageCreateFlagBits::eBlockTexelViewCompatibleKHR) | VkFlags(ImageCreateFlagBits::eExtendedUsageKHR) | VkFlags(ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) | VkFlags(ImageCreateFlagBits::eDisjointKHR) | VkFlags(ImageCreateFlagBits::eAliasKHR)
-    };
-  };
-
-  struct PhysicalDeviceImageFormatInfo2KHR
-  {
-    PhysicalDeviceImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), ImageCreateFlags flags_ = ImageCreateFlags() )
-      : format( format_ )
-      , type( type_ )
-      , tiling( tiling_ )
-      , usage( usage_ )
-      , flags( flags_ )
-    {
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) );
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& operator=( VkPhysicalDeviceImageFormatInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceImageFormatInfo2KHR ) );
-      return *this;
-    }
-    PhysicalDeviceImageFormatInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& setType( ImageType type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
-    {
-      tiling = tiling_;
-      return *this;
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    PhysicalDeviceImageFormatInfo2KHR& setFlags( ImageCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceImageFormatInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( format == rhs.format )
-          && ( type == rhs.type )
-          && ( tiling == rhs.tiling )
-          && ( usage == rhs.usage )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( PhysicalDeviceImageFormatInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    ImageType type;
-    ImageTiling tiling;
-    ImageUsageFlags usage;
-    ImageCreateFlags flags;
-  };
-  static_assert( sizeof( PhysicalDeviceImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceImageFormatInfo2KHR ), "struct and wrapper have different size!" );
-
-  enum class PipelineCreateFlagBits
-  {
-    eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,
-    eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,
-    eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT,
-    eViewIndexFromDeviceIndexKHX = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX,
-    eDispatchBaseKHX = VK_PIPELINE_CREATE_DISPATCH_BASE_KHX
-  };
-
-  using PipelineCreateFlags = Flags<PipelineCreateFlagBits, VkPipelineCreateFlags>;
-
-  VULKAN_HPP_INLINE PipelineCreateFlags operator|( PipelineCreateFlagBits bit0, PipelineCreateFlagBits bit1 )
-  {
-    return PipelineCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PipelineCreateFlags operator~( PipelineCreateFlagBits bits )
-  {
-    return ~( PipelineCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<PipelineCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(PipelineCreateFlagBits::eDisableOptimization) | VkFlags(PipelineCreateFlagBits::eAllowDerivatives) | VkFlags(PipelineCreateFlagBits::eDerivative) | VkFlags(PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) | VkFlags(PipelineCreateFlagBits::eDispatchBaseKHX)
-    };
-  };
-
-  struct ComputePipelineCreateInfo
-  {
-    ComputePipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), PipelineShaderStageCreateInfo stage_ = PipelineShaderStageCreateInfo(), PipelineLayout layout_ = PipelineLayout(), Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stage( stage_ )
-      , layout( layout_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
-    {
-    }
-
-    ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
-    }
-
-    ComputePipelineCreateInfo& operator=( VkComputePipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ComputePipelineCreateInfo ) );
-      return *this;
-    }
-    ComputePipelineCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setStage( PipelineShaderStageCreateInfo stage_ )
-    {
-      stage = stage_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setLayout( PipelineLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
-    {
-      basePipelineHandle = basePipelineHandle_;
-      return *this;
-    }
-
-    ComputePipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
-    {
-      basePipelineIndex = basePipelineIndex_;
-      return *this;
-    }
-
-    operator const VkComputePipelineCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkComputePipelineCreateInfo*>(this);
-    }
-
-    bool operator==( ComputePipelineCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stage == rhs.stage )
-          && ( layout == rhs.layout )
-          && ( basePipelineHandle == rhs.basePipelineHandle )
-          && ( basePipelineIndex == rhs.basePipelineIndex );
-    }
-
-    bool operator!=( ComputePipelineCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eComputePipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    PipelineShaderStageCreateInfo stage;
-    PipelineLayout layout;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
-  };
-  static_assert( sizeof( ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ColorComponentFlagBits
-  {
-    eR = VK_COLOR_COMPONENT_R_BIT,
-    eG = VK_COLOR_COMPONENT_G_BIT,
-    eB = VK_COLOR_COMPONENT_B_BIT,
-    eA = VK_COLOR_COMPONENT_A_BIT
-  };
-
-  using ColorComponentFlags = Flags<ColorComponentFlagBits, VkColorComponentFlags>;
-
-  VULKAN_HPP_INLINE ColorComponentFlags operator|( ColorComponentFlagBits bit0, ColorComponentFlagBits bit1 )
-  {
-    return ColorComponentFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ColorComponentFlags operator~( ColorComponentFlagBits bits )
-  {
-    return ~( ColorComponentFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ColorComponentFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ColorComponentFlagBits::eR) | VkFlags(ColorComponentFlagBits::eG) | VkFlags(ColorComponentFlagBits::eB) | VkFlags(ColorComponentFlagBits::eA)
-    };
-  };
-
-  struct PipelineColorBlendAttachmentState
-  {
-    PipelineColorBlendAttachmentState( Bool32 blendEnable_ = 0, BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, BlendOp colorBlendOp_ = BlendOp::eAdd, BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, BlendOp alphaBlendOp_ = BlendOp::eAdd, ColorComponentFlags colorWriteMask_ = ColorComponentFlags() )
-      : blendEnable( blendEnable_ )
-      , srcColorBlendFactor( srcColorBlendFactor_ )
-      , dstColorBlendFactor( dstColorBlendFactor_ )
-      , colorBlendOp( colorBlendOp_ )
-      , srcAlphaBlendFactor( srcAlphaBlendFactor_ )
-      , dstAlphaBlendFactor( dstAlphaBlendFactor_ )
-      , alphaBlendOp( alphaBlendOp_ )
-      , colorWriteMask( colorWriteMask_ )
-    {
-    }
-
-    PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
-    }
-
-    PipelineColorBlendAttachmentState& operator=( VkPipelineColorBlendAttachmentState const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAttachmentState ) );
-      return *this;
-    }
-    PipelineColorBlendAttachmentState& setBlendEnable( Bool32 blendEnable_ )
-    {
-      blendEnable = blendEnable_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ )
-    {
-      srcColorBlendFactor = srcColorBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ )
-    {
-      dstColorBlendFactor = dstColorBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setColorBlendOp( BlendOp colorBlendOp_ )
-    {
-      colorBlendOp = colorBlendOp_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ )
-    {
-      srcAlphaBlendFactor = srcAlphaBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ )
-    {
-      dstAlphaBlendFactor = dstAlphaBlendFactor_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setAlphaBlendOp( BlendOp alphaBlendOp_ )
-    {
-      alphaBlendOp = alphaBlendOp_;
-      return *this;
-    }
-
-    PipelineColorBlendAttachmentState& setColorWriteMask( ColorComponentFlags colorWriteMask_ )
-    {
-      colorWriteMask = colorWriteMask_;
-      return *this;
-    }
-
-    operator const VkPipelineColorBlendAttachmentState&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendAttachmentState*>(this);
-    }
-
-    bool operator==( PipelineColorBlendAttachmentState const& rhs ) const
-    {
-      return ( blendEnable == rhs.blendEnable )
-          && ( srcColorBlendFactor == rhs.srcColorBlendFactor )
-          && ( dstColorBlendFactor == rhs.dstColorBlendFactor )
-          && ( colorBlendOp == rhs.colorBlendOp )
-          && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor )
-          && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor )
-          && ( alphaBlendOp == rhs.alphaBlendOp )
-          && ( colorWriteMask == rhs.colorWriteMask );
-    }
-
-    bool operator!=( PipelineColorBlendAttachmentState const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Bool32 blendEnable;
-    BlendFactor srcColorBlendFactor;
-    BlendFactor dstColorBlendFactor;
-    BlendOp colorBlendOp;
-    BlendFactor srcAlphaBlendFactor;
-    BlendFactor dstAlphaBlendFactor;
-    BlendOp alphaBlendOp;
-    ColorComponentFlags colorWriteMask;
-  };
-  static_assert( sizeof( PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), "struct and wrapper have different size!" );
-
-  struct PipelineColorBlendStateCreateInfo
-  {
-    PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = PipelineColorBlendStateCreateFlags(), Bool32 logicOpEnable_ = 0, LogicOp logicOp_ = LogicOp::eClear, uint32_t attachmentCount_ = 0, const PipelineColorBlendAttachmentState* pAttachments_ = nullptr, std::array<float,4> const& blendConstants_ = { { 0, 0, 0, 0 } } )
-      : flags( flags_ )
-      , logicOpEnable( logicOpEnable_ )
-      , logicOp( logicOp_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-    {
-      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
-    }
-
-    PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
-    }
-
-    PipelineColorBlendStateCreateInfo& operator=( VkPipelineColorBlendStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendStateCreateInfo ) );
-      return *this;
-    }
-    PipelineColorBlendStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setFlags( PipelineColorBlendStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setLogicOpEnable( Bool32 logicOpEnable_ )
-    {
-      logicOpEnable = logicOpEnable_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setLogicOp( LogicOp logicOp_ )
-    {
-      logicOp = logicOp_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
-    {
-      attachmentCount = attachmentCount_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setPAttachments( const PipelineColorBlendAttachmentState* pAttachments_ )
-    {
-      pAttachments = pAttachments_;
-      return *this;
-    }
-
-    PipelineColorBlendStateCreateInfo& setBlendConstants( std::array<float,4> blendConstants_ )
-    {
-      memcpy( &blendConstants, blendConstants_.data(), 4 * sizeof( float ) );
-      return *this;
-    }
-
-    operator const VkPipelineColorBlendStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineColorBlendStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( logicOpEnable == rhs.logicOpEnable )
-          && ( logicOp == rhs.logicOp )
-          && ( attachmentCount == rhs.attachmentCount )
-          && ( pAttachments == rhs.pAttachments )
-          && ( memcmp( blendConstants, rhs.blendConstants, 4 * sizeof( float ) ) == 0 );
-    }
-
-    bool operator!=( PipelineColorBlendStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineColorBlendStateCreateFlags flags;
-    Bool32 logicOpEnable;
-    LogicOp logicOp;
-    uint32_t attachmentCount;
-    const PipelineColorBlendAttachmentState* pAttachments;
-    float blendConstants[4];
-  };
-  static_assert( sizeof( PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class FenceCreateFlagBits
-  {
-    eSignaled = VK_FENCE_CREATE_SIGNALED_BIT
-  };
-
-  using FenceCreateFlags = Flags<FenceCreateFlagBits, VkFenceCreateFlags>;
-
-  VULKAN_HPP_INLINE FenceCreateFlags operator|( FenceCreateFlagBits bit0, FenceCreateFlagBits bit1 )
-  {
-    return FenceCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FenceCreateFlags operator~( FenceCreateFlagBits bits )
-  {
-    return ~( FenceCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<FenceCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(FenceCreateFlagBits::eSignaled)
-    };
-  };
-
-  struct FenceCreateInfo
-  {
-    FenceCreateInfo( FenceCreateFlags flags_ = FenceCreateFlags() )
-      : flags( flags_ )
-    {
-    }
-
-    FenceCreateInfo( VkFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
-    }
-
-    FenceCreateInfo& operator=( VkFenceCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceCreateInfo ) );
-      return *this;
-    }
-    FenceCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceCreateInfo& setFlags( FenceCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkFenceCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkFenceCreateInfo*>(this);
-    }
-
-    bool operator==( FenceCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( FenceCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    FenceCreateFlags flags;
-  };
-  static_assert( sizeof( FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class FormatFeatureFlagBits
-  {
-    eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
-    eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,
-    eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,
-    eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,
-    eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,
-    eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,
-    eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,
-    eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,
-    eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,
-    eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,
-    eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT,
-    eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT,
-    eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,
-    eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,
-    eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR,
-    eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR,
-    eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT,
-    eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR,
-    eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR,
-    eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR,
-    eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR,
-    eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR,
-    eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR,
-    eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR
-  };
-
-  using FormatFeatureFlags = Flags<FormatFeatureFlagBits, VkFormatFeatureFlags>;
-
-  VULKAN_HPP_INLINE FormatFeatureFlags operator|( FormatFeatureFlagBits bit0, FormatFeatureFlagBits bit1 )
-  {
-    return FormatFeatureFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FormatFeatureFlags operator~( FormatFeatureFlagBits bits )
-  {
-    return ~( FormatFeatureFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<FormatFeatureFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(FormatFeatureFlagBits::eSampledImage) | VkFlags(FormatFeatureFlagBits::eStorageImage) | VkFlags(FormatFeatureFlagBits::eStorageImageAtomic) | VkFlags(FormatFeatureFlagBits::eUniformTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBuffer) | VkFlags(FormatFeatureFlagBits::eStorageTexelBufferAtomic) | VkFlags(FormatFeatureFlagBits::eVertexBuffer) | VkFlags(FormatFeatureFlagBits::eColorAttachment) | VkFlags(FormatFeatureFlagBits::eColorAttachmentBlend) | VkFlags(FormatFeatureFlagBits::eDepthStencilAttachment) | VkFlags(FormatFeatureFlagBits::eBlitSrc) | VkFlags(FormatFeatureFlagBits::eBlitDst) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterLinear) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterCubicIMG) | VkFlags(FormatFeatureFlagBits::eTransferSrcKHR) | VkFlags(FormatFeatureFlagBits::eTransferDstKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) | VkFlags(FormatFeatureFlagBits::eMidpointChromaSamplesKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR) | VkFlags(FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR) | VkFlags(FormatFeatureFlagBits::eDisjointKHR) | VkFlags(FormatFeatureFlagBits::eCositedChromaSamplesKHR)
-    };
-  };
-
-  struct FormatProperties
-  {
-    operator const VkFormatProperties&() const
-    {
-      return *reinterpret_cast<const VkFormatProperties*>(this);
-    }
-
-    bool operator==( FormatProperties const& rhs ) const
-    {
-      return ( linearTilingFeatures == rhs.linearTilingFeatures )
-          && ( optimalTilingFeatures == rhs.optimalTilingFeatures )
-          && ( bufferFeatures == rhs.bufferFeatures );
-    }
-
-    bool operator!=( FormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    FormatFeatureFlags linearTilingFeatures;
-    FormatFeatureFlags optimalTilingFeatures;
-    FormatFeatureFlags bufferFeatures;
-  };
-  static_assert( sizeof( FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" );
-
-  struct FormatProperties2KHR
-  {
-    operator const VkFormatProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkFormatProperties2KHR*>(this);
-    }
-
-    bool operator==( FormatProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( formatProperties == rhs.formatProperties );
-    }
-
-    bool operator!=( FormatProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFormatProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    FormatProperties formatProperties;
-  };
-  static_assert( sizeof( FormatProperties2KHR ) == sizeof( VkFormatProperties2KHR ), "struct and wrapper have different size!" );
-
-  enum class QueryControlFlagBits
-  {
-    ePrecise = VK_QUERY_CONTROL_PRECISE_BIT
-  };
-
-  using QueryControlFlags = Flags<QueryControlFlagBits, VkQueryControlFlags>;
-
-  VULKAN_HPP_INLINE QueryControlFlags operator|( QueryControlFlagBits bit0, QueryControlFlagBits bit1 )
-  {
-    return QueryControlFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryControlFlags operator~( QueryControlFlagBits bits )
-  {
-    return ~( QueryControlFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryControlFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryControlFlagBits::ePrecise)
-    };
-  };
-
-  enum class QueryResultFlagBits
-  {
-    e64 = VK_QUERY_RESULT_64_BIT,
-    eWait = VK_QUERY_RESULT_WAIT_BIT,
-    eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT,
-    ePartial = VK_QUERY_RESULT_PARTIAL_BIT
-  };
-
-  using QueryResultFlags = Flags<QueryResultFlagBits, VkQueryResultFlags>;
-
-  VULKAN_HPP_INLINE QueryResultFlags operator|( QueryResultFlagBits bit0, QueryResultFlagBits bit1 )
-  {
-    return QueryResultFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryResultFlags operator~( QueryResultFlagBits bits )
-  {
-    return ~( QueryResultFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryResultFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryResultFlagBits::e64) | VkFlags(QueryResultFlagBits::eWait) | VkFlags(QueryResultFlagBits::eWithAvailability) | VkFlags(QueryResultFlagBits::ePartial)
-    };
-  };
-
-  enum class CommandBufferUsageFlagBits
-  {
-    eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
-    eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT,
-    eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
-  };
-
-  using CommandBufferUsageFlags = Flags<CommandBufferUsageFlagBits, VkCommandBufferUsageFlags>;
-
-  VULKAN_HPP_INLINE CommandBufferUsageFlags operator|( CommandBufferUsageFlagBits bit0, CommandBufferUsageFlagBits bit1 )
-  {
-    return CommandBufferUsageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandBufferUsageFlags operator~( CommandBufferUsageFlagBits bits )
-  {
-    return ~( CommandBufferUsageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandBufferUsageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandBufferUsageFlagBits::eOneTimeSubmit) | VkFlags(CommandBufferUsageFlagBits::eRenderPassContinue) | VkFlags(CommandBufferUsageFlagBits::eSimultaneousUse)
-    };
-  };
-
-  enum class QueryPipelineStatisticFlagBits
-  {
-    eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT,
-    eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT,
-    eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT,
-    eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT,
-    eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT,
-    eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT,
-    eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT,
-    eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT,
-    eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT,
-    eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT,
-    eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT
-  };
-
-  using QueryPipelineStatisticFlags = Flags<QueryPipelineStatisticFlagBits, VkQueryPipelineStatisticFlags>;
-
-  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator|( QueryPipelineStatisticFlagBits bit0, QueryPipelineStatisticFlagBits bit1 )
-  {
-    return QueryPipelineStatisticFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE QueryPipelineStatisticFlags operator~( QueryPipelineStatisticFlagBits bits )
-  {
-    return ~( QueryPipelineStatisticFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<QueryPipelineStatisticFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyVertices) | VkFlags(QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eVertexShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eClippingInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eClippingPrimitives) | VkFlags(QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) | VkFlags(QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) | VkFlags(QueryPipelineStatisticFlagBits::eComputeShaderInvocations)
-    };
-  };
-
-  struct CommandBufferInheritanceInfo
-  {
-    CommandBufferInheritanceInfo( RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Framebuffer framebuffer_ = Framebuffer(), Bool32 occlusionQueryEnable_ = 0, QueryControlFlags queryFlags_ = QueryControlFlags(), QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , framebuffer( framebuffer_ )
-      , occlusionQueryEnable( occlusionQueryEnable_ )
-      , queryFlags( queryFlags_ )
-      , pipelineStatistics( pipelineStatistics_ )
-    {
-    }
-
-    CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
-    }
-
-    CommandBufferInheritanceInfo& operator=( VkCommandBufferInheritanceInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferInheritanceInfo ) );
-      return *this;
-    }
-    CommandBufferInheritanceInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setFramebuffer( Framebuffer framebuffer_ )
-    {
-      framebuffer = framebuffer_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ )
-    {
-      occlusionQueryEnable = occlusionQueryEnable_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setQueryFlags( QueryControlFlags queryFlags_ )
-    {
-      queryFlags = queryFlags_;
-      return *this;
-    }
-
-    CommandBufferInheritanceInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
-    {
-      pipelineStatistics = pipelineStatistics_;
-      return *this;
-    }
-
-    operator const VkCommandBufferInheritanceInfo&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferInheritanceInfo*>(this);
-    }
-
-    bool operator==( CommandBufferInheritanceInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( renderPass == rhs.renderPass )
-          && ( subpass == rhs.subpass )
-          && ( framebuffer == rhs.framebuffer )
-          && ( occlusionQueryEnable == rhs.occlusionQueryEnable )
-          && ( queryFlags == rhs.queryFlags )
-          && ( pipelineStatistics == rhs.pipelineStatistics );
-    }
-
-    bool operator!=( CommandBufferInheritanceInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferInheritanceInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Framebuffer framebuffer;
-    Bool32 occlusionQueryEnable;
-    QueryControlFlags queryFlags;
-    QueryPipelineStatisticFlags pipelineStatistics;
-  };
-  static_assert( sizeof( CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), "struct and wrapper have different size!" );
-
-  struct CommandBufferBeginInfo
-  {
-    CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = CommandBufferUsageFlags(), const CommandBufferInheritanceInfo* pInheritanceInfo_ = nullptr )
-      : flags( flags_ )
-      , pInheritanceInfo( pInheritanceInfo_ )
-    {
-    }
-
-    CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
-    }
-
-    CommandBufferBeginInfo& operator=( VkCommandBufferBeginInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandBufferBeginInfo ) );
-      return *this;
-    }
-    CommandBufferBeginInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandBufferBeginInfo& setFlags( CommandBufferUsageFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    CommandBufferBeginInfo& setPInheritanceInfo( const CommandBufferInheritanceInfo* pInheritanceInfo_ )
-    {
-      pInheritanceInfo = pInheritanceInfo_;
-      return *this;
-    }
-
-    operator const VkCommandBufferBeginInfo&() const
-    {
-      return *reinterpret_cast<const VkCommandBufferBeginInfo*>(this);
-    }
-
-    bool operator==( CommandBufferBeginInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pInheritanceInfo == rhs.pInheritanceInfo );
-    }
-
-    bool operator!=( CommandBufferBeginInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandBufferBeginInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandBufferUsageFlags flags;
-    const CommandBufferInheritanceInfo* pInheritanceInfo;
-  };
-  static_assert( sizeof( CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), "struct and wrapper have different size!" );
-
-  struct QueryPoolCreateInfo
-  {
-    QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = QueryPoolCreateFlags(), QueryType queryType_ = QueryType::eOcclusion, uint32_t queryCount_ = 0, QueryPipelineStatisticFlags pipelineStatistics_ = QueryPipelineStatisticFlags() )
-      : flags( flags_ )
-      , queryType( queryType_ )
-      , queryCount( queryCount_ )
-      , pipelineStatistics( pipelineStatistics_ )
-    {
-    }
-
-    QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
-    }
-
-    QueryPoolCreateInfo& operator=( VkQueryPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( QueryPoolCreateInfo ) );
-      return *this;
-    }
-    QueryPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setFlags( QueryPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setQueryType( QueryType queryType_ )
-    {
-      queryType = queryType_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setQueryCount( uint32_t queryCount_ )
-    {
-      queryCount = queryCount_;
-      return *this;
-    }
-
-    QueryPoolCreateInfo& setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ )
-    {
-      pipelineStatistics = pipelineStatistics_;
-      return *this;
-    }
-
-    operator const VkQueryPoolCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkQueryPoolCreateInfo*>(this);
-    }
-
-    bool operator==( QueryPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queryType == rhs.queryType )
-          && ( queryCount == rhs.queryCount )
-          && ( pipelineStatistics == rhs.pipelineStatistics );
-    }
-
-    bool operator!=( QueryPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eQueryPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    QueryPoolCreateFlags flags;
-    QueryType queryType;
-    uint32_t queryCount;
-    QueryPipelineStatisticFlags pipelineStatistics;
-  };
-  static_assert( sizeof( QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ImageAspectFlagBits
-  {
-    eColor = VK_IMAGE_ASPECT_COLOR_BIT,
-    eDepth = VK_IMAGE_ASPECT_DEPTH_BIT,
-    eStencil = VK_IMAGE_ASPECT_STENCIL_BIT,
-    eMetadata = VK_IMAGE_ASPECT_METADATA_BIT,
-    ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR,
-    ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR,
-    ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR
-  };
-
-  using ImageAspectFlags = Flags<ImageAspectFlagBits, VkImageAspectFlags>;
-
-  VULKAN_HPP_INLINE ImageAspectFlags operator|( ImageAspectFlagBits bit0, ImageAspectFlagBits bit1 )
-  {
-    return ImageAspectFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ImageAspectFlags operator~( ImageAspectFlagBits bits )
-  {
-    return ~( ImageAspectFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<ImageAspectFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(ImageAspectFlagBits::eColor) | VkFlags(ImageAspectFlagBits::eDepth) | VkFlags(ImageAspectFlagBits::eStencil) | VkFlags(ImageAspectFlagBits::eMetadata) | VkFlags(ImageAspectFlagBits::ePlane0KHR) | VkFlags(ImageAspectFlagBits::ePlane1KHR) | VkFlags(ImageAspectFlagBits::ePlane2KHR)
-    };
-  };
-
-  struct ImageSubresource
-  {
-    ImageSubresource( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t arrayLayer_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , arrayLayer( arrayLayer_ )
-    {
-    }
-
-    ImageSubresource( VkImageSubresource const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresource ) );
-    }
-
-    ImageSubresource& operator=( VkImageSubresource const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresource ) );
-      return *this;
-    }
-    ImageSubresource& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresource& setMipLevel( uint32_t mipLevel_ )
-    {
-      mipLevel = mipLevel_;
-      return *this;
-    }
-
-    ImageSubresource& setArrayLayer( uint32_t arrayLayer_ )
-    {
-      arrayLayer = arrayLayer_;
-      return *this;
-    }
-
-    operator const VkImageSubresource&() const
-    {
-      return *reinterpret_cast<const VkImageSubresource*>(this);
-    }
-
-    bool operator==( ImageSubresource const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( mipLevel == rhs.mipLevel )
-          && ( arrayLayer == rhs.arrayLayer );
-    }
-
-    bool operator!=( ImageSubresource const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t mipLevel;
-    uint32_t arrayLayer;
-  };
-  static_assert( sizeof( ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" );
-
-  struct ImageSubresourceLayers
-  {
-    ImageSubresourceLayers( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t mipLevel_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , mipLevel( mipLevel_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ImageSubresourceLayers( VkImageSubresourceLayers const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
-    }
-
-    ImageSubresourceLayers& operator=( VkImageSubresourceLayers const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceLayers ) );
-      return *this;
-    }
-    ImageSubresourceLayers& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setMipLevel( uint32_t mipLevel_ )
-    {
-      mipLevel = mipLevel_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ImageSubresourceLayers& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator const VkImageSubresourceLayers&() const
-    {
-      return *reinterpret_cast<const VkImageSubresourceLayers*>(this);
-    }
-
-    bool operator==( ImageSubresourceLayers const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( mipLevel == rhs.mipLevel )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ImageSubresourceLayers const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t mipLevel;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), "struct and wrapper have different size!" );
-
-  struct ImageSubresourceRange
-  {
-    ImageSubresourceRange( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t baseMipLevel_ = 0, uint32_t levelCount_ = 0, uint32_t baseArrayLayer_ = 0, uint32_t layerCount_ = 0 )
-      : aspectMask( aspectMask_ )
-      , baseMipLevel( baseMipLevel_ )
-      , levelCount( levelCount_ )
-      , baseArrayLayer( baseArrayLayer_ )
-      , layerCount( layerCount_ )
-    {
-    }
-
-    ImageSubresourceRange( VkImageSubresourceRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
-    }
-
-    ImageSubresourceRange& operator=( VkImageSubresourceRange const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageSubresourceRange ) );
-      return *this;
-    }
-    ImageSubresourceRange& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setBaseMipLevel( uint32_t baseMipLevel_ )
-    {
-      baseMipLevel = baseMipLevel_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setLevelCount( uint32_t levelCount_ )
-    {
-      levelCount = levelCount_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setBaseArrayLayer( uint32_t baseArrayLayer_ )
-    {
-      baseArrayLayer = baseArrayLayer_;
-      return *this;
-    }
-
-    ImageSubresourceRange& setLayerCount( uint32_t layerCount_ )
-    {
-      layerCount = layerCount_;
-      return *this;
-    }
-
-    operator const VkImageSubresourceRange&() const
-    {
-      return *reinterpret_cast<const VkImageSubresourceRange*>(this);
-    }
-
-    bool operator==( ImageSubresourceRange const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( baseMipLevel == rhs.baseMipLevel )
-          && ( levelCount == rhs.levelCount )
-          && ( baseArrayLayer == rhs.baseArrayLayer )
-          && ( layerCount == rhs.layerCount );
-    }
-
-    bool operator!=( ImageSubresourceRange const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t baseMipLevel;
-    uint32_t levelCount;
-    uint32_t baseArrayLayer;
-    uint32_t layerCount;
-  };
-  static_assert( sizeof( ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), "struct and wrapper have different size!" );
-
-  struct ImageMemoryBarrier
-  {
-    ImageMemoryBarrier( AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), ImageLayout oldLayout_ = ImageLayout::eUndefined, ImageLayout newLayout_ = ImageLayout::eUndefined, uint32_t srcQueueFamilyIndex_ = 0, uint32_t dstQueueFamilyIndex_ = 0, Image image_ = Image(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , oldLayout( oldLayout_ )
-      , newLayout( newLayout_ )
-      , srcQueueFamilyIndex( srcQueueFamilyIndex_ )
-      , dstQueueFamilyIndex( dstQueueFamilyIndex_ )
-      , image( image_ )
-      , subresourceRange( subresourceRange_ )
-    {
-    }
-
-    ImageMemoryBarrier( VkImageMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
-    }
-
-    ImageMemoryBarrier& operator=( VkImageMemoryBarrier const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageMemoryBarrier ) );
-      return *this;
-    }
-    ImageMemoryBarrier& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setOldLayout( ImageLayout oldLayout_ )
-    {
-      oldLayout = oldLayout_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setNewLayout( ImageLayout newLayout_ )
-    {
-      newLayout = newLayout_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ )
-    {
-      srcQueueFamilyIndex = srcQueueFamilyIndex_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ )
-    {
-      dstQueueFamilyIndex = dstQueueFamilyIndex_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    ImageMemoryBarrier& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
-    {
-      subresourceRange = subresourceRange_;
-      return *this;
-    }
-
-    operator const VkImageMemoryBarrier&() const
-    {
-      return *reinterpret_cast<const VkImageMemoryBarrier*>(this);
-    }
-
-    bool operator==( ImageMemoryBarrier const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( oldLayout == rhs.oldLayout )
-          && ( newLayout == rhs.newLayout )
-          && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex )
-          && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex )
-          && ( image == rhs.image )
-          && ( subresourceRange == rhs.subresourceRange );
-    }
-
-    bool operator!=( ImageMemoryBarrier const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageMemoryBarrier;
-
-  public:
-    const void* pNext = nullptr;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    ImageLayout oldLayout;
-    ImageLayout newLayout;
-    uint32_t srcQueueFamilyIndex;
-    uint32_t dstQueueFamilyIndex;
-    Image image;
-    ImageSubresourceRange subresourceRange;
-  };
-  static_assert( sizeof( ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" );
-
-  struct ImageViewCreateInfo
-  {
-    ImageViewCreateInfo( ImageViewCreateFlags flags_ = ImageViewCreateFlags(), Image image_ = Image(), ImageViewType viewType_ = ImageViewType::e1D, Format format_ = Format::eUndefined, ComponentMapping components_ = ComponentMapping(), ImageSubresourceRange subresourceRange_ = ImageSubresourceRange() )
-      : flags( flags_ )
-      , image( image_ )
-      , viewType( viewType_ )
-      , format( format_ )
-      , components( components_ )
-      , subresourceRange( subresourceRange_ )
-    {
-    }
-
-    ImageViewCreateInfo( VkImageViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
-    }
-
-    ImageViewCreateInfo& operator=( VkImageViewCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageViewCreateInfo ) );
-      return *this;
-    }
-    ImageViewCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setFlags( ImageViewCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setViewType( ImageViewType viewType_ )
-    {
-      viewType = viewType_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setComponents( ComponentMapping components_ )
-    {
-      components = components_;
-      return *this;
-    }
-
-    ImageViewCreateInfo& setSubresourceRange( ImageSubresourceRange subresourceRange_ )
-    {
-      subresourceRange = subresourceRange_;
-      return *this;
-    }
-
-    operator const VkImageViewCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkImageViewCreateInfo*>(this);
-    }
-
-    bool operator==( ImageViewCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( image == rhs.image )
-          && ( viewType == rhs.viewType )
-          && ( format == rhs.format )
-          && ( components == rhs.components )
-          && ( subresourceRange == rhs.subresourceRange );
-    }
-
-    bool operator!=( ImageViewCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageViewCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageViewCreateFlags flags;
-    Image image;
-    ImageViewType viewType;
-    Format format;
-    ComponentMapping components;
-    ImageSubresourceRange subresourceRange;
-  };
-  static_assert( sizeof( ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" );
-
-  struct ImageCopy
-  {
-    ImageCopy( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
-    {
-    }
-
-    ImageCopy( VkImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCopy ) );
-    }
-
-    ImageCopy& operator=( VkImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCopy ) );
-      return *this;
-    }
-    ImageCopy& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageCopy& setSrcOffset( Offset3D srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    ImageCopy& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageCopy& setDstOffset( Offset3D dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    ImageCopy& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator const VkImageCopy&() const
-    {
-      return *reinterpret_cast<const VkImageCopy*>(this);
-    }
-
-    bool operator==( ImageCopy const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( srcOffset == rhs.srcOffset )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( dstOffset == rhs.dstOffset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( ImageCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
-  };
-  static_assert( sizeof( ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" );
-
-  struct ImageBlit
-  {
-    ImageBlit( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& srcOffsets_ = { { Offset3D(), Offset3D() } }, ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), std::array<Offset3D,2> const& dstOffsets_ = { { Offset3D(), Offset3D() } } )
-      : srcSubresource( srcSubresource_ )
-      , dstSubresource( dstSubresource_ )
-    {
-      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
-      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
-    }
-
-    ImageBlit( VkImageBlit const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageBlit ) );
-    }
-
-    ImageBlit& operator=( VkImageBlit const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageBlit ) );
-      return *this;
-    }
-    ImageBlit& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageBlit& setSrcOffsets( std::array<Offset3D,2> srcOffsets_ )
-    {
-      memcpy( &srcOffsets, srcOffsets_.data(), 2 * sizeof( Offset3D ) );
-      return *this;
-    }
-
-    ImageBlit& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageBlit& setDstOffsets( std::array<Offset3D,2> dstOffsets_ )
-    {
-      memcpy( &dstOffsets, dstOffsets_.data(), 2 * sizeof( Offset3D ) );
-      return *this;
-    }
-
-    operator const VkImageBlit&() const
-    {
-      return *reinterpret_cast<const VkImageBlit*>(this);
-    }
-
-    bool operator==( ImageBlit const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( memcmp( srcOffsets, rhs.srcOffsets, 2 * sizeof( Offset3D ) ) == 0 )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( memcmp( dstOffsets, rhs.dstOffsets, 2 * sizeof( Offset3D ) ) == 0 );
-    }
-
-    bool operator!=( ImageBlit const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffsets[2];
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffsets[2];
-  };
-  static_assert( sizeof( ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" );
-
-  struct BufferImageCopy
-  {
-    BufferImageCopy( DeviceSize bufferOffset_ = 0, uint32_t bufferRowLength_ = 0, uint32_t bufferImageHeight_ = 0, ImageSubresourceLayers imageSubresource_ = ImageSubresourceLayers(), Offset3D imageOffset_ = Offset3D(), Extent3D imageExtent_ = Extent3D() )
-      : bufferOffset( bufferOffset_ )
-      , bufferRowLength( bufferRowLength_ )
-      , bufferImageHeight( bufferImageHeight_ )
-      , imageSubresource( imageSubresource_ )
-      , imageOffset( imageOffset_ )
-      , imageExtent( imageExtent_ )
-    {
-    }
-
-    BufferImageCopy( VkBufferImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
-    }
-
-    BufferImageCopy& operator=( VkBufferImageCopy const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BufferImageCopy ) );
-      return *this;
-    }
-    BufferImageCopy& setBufferOffset( DeviceSize bufferOffset_ )
-    {
-      bufferOffset = bufferOffset_;
-      return *this;
-    }
-
-    BufferImageCopy& setBufferRowLength( uint32_t bufferRowLength_ )
-    {
-      bufferRowLength = bufferRowLength_;
-      return *this;
-    }
-
-    BufferImageCopy& setBufferImageHeight( uint32_t bufferImageHeight_ )
-    {
-      bufferImageHeight = bufferImageHeight_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageSubresource( ImageSubresourceLayers imageSubresource_ )
-    {
-      imageSubresource = imageSubresource_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageOffset( Offset3D imageOffset_ )
-    {
-      imageOffset = imageOffset_;
-      return *this;
-    }
-
-    BufferImageCopy& setImageExtent( Extent3D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    operator const VkBufferImageCopy&() const
-    {
-      return *reinterpret_cast<const VkBufferImageCopy*>(this);
-    }
-
-    bool operator==( BufferImageCopy const& rhs ) const
-    {
-      return ( bufferOffset == rhs.bufferOffset )
-          && ( bufferRowLength == rhs.bufferRowLength )
-          && ( bufferImageHeight == rhs.bufferImageHeight )
-          && ( imageSubresource == rhs.imageSubresource )
-          && ( imageOffset == rhs.imageOffset )
-          && ( imageExtent == rhs.imageExtent );
-    }
-
-    bool operator!=( BufferImageCopy const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize bufferOffset;
-    uint32_t bufferRowLength;
-    uint32_t bufferImageHeight;
-    ImageSubresourceLayers imageSubresource;
-    Offset3D imageOffset;
-    Extent3D imageExtent;
-  };
-  static_assert( sizeof( BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" );
-
-  struct ImageResolve
-  {
-    ImageResolve( ImageSubresourceLayers srcSubresource_ = ImageSubresourceLayers(), Offset3D srcOffset_ = Offset3D(), ImageSubresourceLayers dstSubresource_ = ImageSubresourceLayers(), Offset3D dstOffset_ = Offset3D(), Extent3D extent_ = Extent3D() )
-      : srcSubresource( srcSubresource_ )
-      , srcOffset( srcOffset_ )
-      , dstSubresource( dstSubresource_ )
-      , dstOffset( dstOffset_ )
-      , extent( extent_ )
-    {
-    }
-
-    ImageResolve( VkImageResolve const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageResolve ) );
-    }
-
-    ImageResolve& operator=( VkImageResolve const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageResolve ) );
-      return *this;
-    }
-    ImageResolve& setSrcSubresource( ImageSubresourceLayers srcSubresource_ )
-    {
-      srcSubresource = srcSubresource_;
-      return *this;
-    }
-
-    ImageResolve& setSrcOffset( Offset3D srcOffset_ )
-    {
-      srcOffset = srcOffset_;
-      return *this;
-    }
-
-    ImageResolve& setDstSubresource( ImageSubresourceLayers dstSubresource_ )
-    {
-      dstSubresource = dstSubresource_;
-      return *this;
-    }
-
-    ImageResolve& setDstOffset( Offset3D dstOffset_ )
-    {
-      dstOffset = dstOffset_;
-      return *this;
-    }
-
-    ImageResolve& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    operator const VkImageResolve&() const
-    {
-      return *reinterpret_cast<const VkImageResolve*>(this);
-    }
-
-    bool operator==( ImageResolve const& rhs ) const
-    {
-      return ( srcSubresource == rhs.srcSubresource )
-          && ( srcOffset == rhs.srcOffset )
-          && ( dstSubresource == rhs.dstSubresource )
-          && ( dstOffset == rhs.dstOffset )
-          && ( extent == rhs.extent );
-    }
-
-    bool operator!=( ImageResolve const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresourceLayers srcSubresource;
-    Offset3D srcOffset;
-    ImageSubresourceLayers dstSubresource;
-    Offset3D dstOffset;
-    Extent3D extent;
-  };
-  static_assert( sizeof( ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" );
-
-  struct ClearAttachment
-  {
-    ClearAttachment( ImageAspectFlags aspectMask_ = ImageAspectFlags(), uint32_t colorAttachment_ = 0, ClearValue clearValue_ = ClearValue() )
-      : aspectMask( aspectMask_ )
-      , colorAttachment( colorAttachment_ )
-      , clearValue( clearValue_ )
-    {
-    }
-
-    ClearAttachment( VkClearAttachment const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearAttachment ) );
-    }
-
-    ClearAttachment& operator=( VkClearAttachment const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ClearAttachment ) );
-      return *this;
-    }
-    ClearAttachment& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    ClearAttachment& setColorAttachment( uint32_t colorAttachment_ )
-    {
-      colorAttachment = colorAttachment_;
-      return *this;
-    }
-
-    ClearAttachment& setClearValue( ClearValue clearValue_ )
-    {
-      clearValue = clearValue_;
-      return *this;
-    }
-
-    operator const VkClearAttachment&() const
-    {
-      return *reinterpret_cast<const VkClearAttachment*>(this);
-    }
-
-    ImageAspectFlags aspectMask;
-    uint32_t colorAttachment;
-    ClearValue clearValue;
-  };
-  static_assert( sizeof( ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" );
-
-  struct InputAttachmentAspectReferenceKHR
-  {
-    InputAttachmentAspectReferenceKHR( uint32_t subpass_ = 0, uint32_t inputAttachmentIndex_ = 0, ImageAspectFlags aspectMask_ = ImageAspectFlags() )
-      : subpass( subpass_ )
-      , inputAttachmentIndex( inputAttachmentIndex_ )
-      , aspectMask( aspectMask_ )
-    {
-    }
-
-    InputAttachmentAspectReferenceKHR( VkInputAttachmentAspectReferenceKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InputAttachmentAspectReferenceKHR ) );
-    }
-
-    InputAttachmentAspectReferenceKHR& operator=( VkInputAttachmentAspectReferenceKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( InputAttachmentAspectReferenceKHR ) );
-      return *this;
-    }
-    InputAttachmentAspectReferenceKHR& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    InputAttachmentAspectReferenceKHR& setInputAttachmentIndex( uint32_t inputAttachmentIndex_ )
-    {
-      inputAttachmentIndex = inputAttachmentIndex_;
-      return *this;
-    }
-
-    InputAttachmentAspectReferenceKHR& setAspectMask( ImageAspectFlags aspectMask_ )
-    {
-      aspectMask = aspectMask_;
-      return *this;
-    }
-
-    operator const VkInputAttachmentAspectReferenceKHR&() const
-    {
-      return *reinterpret_cast<const VkInputAttachmentAspectReferenceKHR*>(this);
-    }
-
-    bool operator==( InputAttachmentAspectReferenceKHR const& rhs ) const
-    {
-      return ( subpass == rhs.subpass )
-          && ( inputAttachmentIndex == rhs.inputAttachmentIndex )
-          && ( aspectMask == rhs.aspectMask );
-    }
-
-    bool operator!=( InputAttachmentAspectReferenceKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t subpass;
-    uint32_t inputAttachmentIndex;
-    ImageAspectFlags aspectMask;
-  };
-  static_assert( sizeof( InputAttachmentAspectReferenceKHR ) == sizeof( VkInputAttachmentAspectReferenceKHR ), "struct and wrapper have different size!" );
-
-  struct RenderPassInputAttachmentAspectCreateInfoKHR
-  {
-    RenderPassInputAttachmentAspectCreateInfoKHR( uint32_t aspectReferenceCount_ = 0, const InputAttachmentAspectReferenceKHR* pAspectReferences_ = nullptr )
-      : aspectReferenceCount( aspectReferenceCount_ )
-      , pAspectReferences( pAspectReferences_ )
-    {
-    }
-
-    RenderPassInputAttachmentAspectCreateInfoKHR( VkRenderPassInputAttachmentAspectCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) );
-    }
-
-    RenderPassInputAttachmentAspectCreateInfoKHR& operator=( VkRenderPassInputAttachmentAspectCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) );
-      return *this;
-    }
-    RenderPassInputAttachmentAspectCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassInputAttachmentAspectCreateInfoKHR& setAspectReferenceCount( uint32_t aspectReferenceCount_ )
-    {
-      aspectReferenceCount = aspectReferenceCount_;
-      return *this;
-    }
-
-    RenderPassInputAttachmentAspectCreateInfoKHR& setPAspectReferences( const InputAttachmentAspectReferenceKHR* pAspectReferences_ )
-    {
-      pAspectReferences = pAspectReferences_;
-      return *this;
-    }
-
-    operator const VkRenderPassInputAttachmentAspectCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfoKHR*>(this);
-    }
-
-    bool operator==( RenderPassInputAttachmentAspectCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( aspectReferenceCount == rhs.aspectReferenceCount )
-          && ( pAspectReferences == rhs.pAspectReferences );
-    }
-
-    bool operator!=( RenderPassInputAttachmentAspectCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t aspectReferenceCount;
-    const InputAttachmentAspectReferenceKHR* pAspectReferences;
-  };
-  static_assert( sizeof( RenderPassInputAttachmentAspectCreateInfoKHR ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct BindImagePlaneMemoryInfoKHR
-  {
-    BindImagePlaneMemoryInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
-    {
-    }
-
-    BindImagePlaneMemoryInfoKHR( VkBindImagePlaneMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfoKHR ) );
-    }
-
-    BindImagePlaneMemoryInfoKHR& operator=( VkBindImagePlaneMemoryInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindImagePlaneMemoryInfoKHR ) );
-      return *this;
-    }
-    BindImagePlaneMemoryInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindImagePlaneMemoryInfoKHR& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
-    {
-      planeAspect = planeAspect_;
-      return *this;
-    }
-
-    operator const VkBindImagePlaneMemoryInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkBindImagePlaneMemoryInfoKHR*>(this);
-    }
-
-    bool operator==( BindImagePlaneMemoryInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( planeAspect == rhs.planeAspect );
-    }
-
-    bool operator!=( BindImagePlaneMemoryInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindImagePlaneMemoryInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
-  };
-  static_assert( sizeof( BindImagePlaneMemoryInfoKHR ) == sizeof( VkBindImagePlaneMemoryInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ImagePlaneMemoryRequirementsInfoKHR
-  {
-    ImagePlaneMemoryRequirementsInfoKHR( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor )
-      : planeAspect( planeAspect_ )
-    {
-    }
-
-    ImagePlaneMemoryRequirementsInfoKHR( VkImagePlaneMemoryRequirementsInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfoKHR ) );
-    }
-
-    ImagePlaneMemoryRequirementsInfoKHR& operator=( VkImagePlaneMemoryRequirementsInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImagePlaneMemoryRequirementsInfoKHR ) );
-      return *this;
-    }
-    ImagePlaneMemoryRequirementsInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImagePlaneMemoryRequirementsInfoKHR& setPlaneAspect( ImageAspectFlagBits planeAspect_ )
-    {
-      planeAspect = planeAspect_;
-      return *this;
-    }
-
-    operator const VkImagePlaneMemoryRequirementsInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImagePlaneMemoryRequirementsInfoKHR*>(this);
-    }
-
-    bool operator==( ImagePlaneMemoryRequirementsInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( planeAspect == rhs.planeAspect );
-    }
-
-    bool operator!=( ImagePlaneMemoryRequirementsInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ImageAspectFlagBits planeAspect;
-  };
-  static_assert( sizeof( ImagePlaneMemoryRequirementsInfoKHR ) == sizeof( VkImagePlaneMemoryRequirementsInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class SparseImageFormatFlagBits
-  {
-    eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT,
-    eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT,
-    eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT
-  };
-
-  using SparseImageFormatFlags = Flags<SparseImageFormatFlagBits, VkSparseImageFormatFlags>;
-
-  VULKAN_HPP_INLINE SparseImageFormatFlags operator|( SparseImageFormatFlagBits bit0, SparseImageFormatFlagBits bit1 )
-  {
-    return SparseImageFormatFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SparseImageFormatFlags operator~( SparseImageFormatFlagBits bits )
-  {
-    return ~( SparseImageFormatFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SparseImageFormatFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SparseImageFormatFlagBits::eSingleMiptail) | VkFlags(SparseImageFormatFlagBits::eAlignedMipSize) | VkFlags(SparseImageFormatFlagBits::eNonstandardBlockSize)
-    };
-  };
-
-  struct SparseImageFormatProperties
-  {
-    operator const VkSparseImageFormatProperties&() const
-    {
-      return *reinterpret_cast<const VkSparseImageFormatProperties*>(this);
-    }
-
-    bool operator==( SparseImageFormatProperties const& rhs ) const
-    {
-      return ( aspectMask == rhs.aspectMask )
-          && ( imageGranularity == rhs.imageGranularity )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageAspectFlags aspectMask;
-    Extent3D imageGranularity;
-    SparseImageFormatFlags flags;
-  };
-  static_assert( sizeof( SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryRequirements
-  {
-    operator const VkSparseImageMemoryRequirements&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryRequirements*>(this);
-    }
-
-    bool operator==( SparseImageMemoryRequirements const& rhs ) const
-    {
-      return ( formatProperties == rhs.formatProperties )
-          && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod )
-          && ( imageMipTailSize == rhs.imageMipTailSize )
-          && ( imageMipTailOffset == rhs.imageMipTailOffset )
-          && ( imageMipTailStride == rhs.imageMipTailStride );
-    }
-
-    bool operator!=( SparseImageMemoryRequirements const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    SparseImageFormatProperties formatProperties;
-    uint32_t imageMipTailFirstLod;
-    DeviceSize imageMipTailSize;
-    DeviceSize imageMipTailOffset;
-    DeviceSize imageMipTailStride;
-  };
-  static_assert( sizeof( SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), "struct and wrapper have different size!" );
-
-  struct SparseImageFormatProperties2KHR
-  {
-    operator const VkSparseImageFormatProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkSparseImageFormatProperties2KHR*>(this);
-    }
-
-    bool operator==( SparseImageFormatProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( properties == rhs.properties );
-    }
-
-    bool operator!=( SparseImageFormatProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSparseImageFormatProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageFormatProperties properties;
-  };
-  static_assert( sizeof( SparseImageFormatProperties2KHR ) == sizeof( VkSparseImageFormatProperties2KHR ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryRequirements2KHR
-  {
-    operator const VkSparseImageMemoryRequirements2KHR&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryRequirements2KHR*>(this);
-    }
-
-    bool operator==( SparseImageMemoryRequirements2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memoryRequirements == rhs.memoryRequirements );
-    }
-
-    bool operator!=( SparseImageMemoryRequirements2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSparseImageMemoryRequirements2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SparseImageMemoryRequirements memoryRequirements;
-  };
-  static_assert( sizeof( SparseImageMemoryRequirements2KHR ) == sizeof( VkSparseImageMemoryRequirements2KHR ), "struct and wrapper have different size!" );
-
-  enum class SparseMemoryBindFlagBits
-  {
-    eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT
-  };
-
-  using SparseMemoryBindFlags = Flags<SparseMemoryBindFlagBits, VkSparseMemoryBindFlags>;
-
-  VULKAN_HPP_INLINE SparseMemoryBindFlags operator|( SparseMemoryBindFlagBits bit0, SparseMemoryBindFlagBits bit1 )
-  {
-    return SparseMemoryBindFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SparseMemoryBindFlags operator~( SparseMemoryBindFlagBits bits )
-  {
-    return ~( SparseMemoryBindFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SparseMemoryBindFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SparseMemoryBindFlagBits::eMetadata)
-    };
-  };
-
-  struct SparseMemoryBind
-  {
-    SparseMemoryBind( DeviceSize resourceOffset_ = 0, DeviceSize size_ = 0, DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : resourceOffset( resourceOffset_ )
-      , size( size_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
-    {
-    }
-
-    SparseMemoryBind( VkSparseMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
-    }
-
-    SparseMemoryBind& operator=( VkSparseMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseMemoryBind ) );
-      return *this;
-    }
-    SparseMemoryBind& setResourceOffset( DeviceSize resourceOffset_ )
-    {
-      resourceOffset = resourceOffset_;
-      return *this;
-    }
-
-    SparseMemoryBind& setSize( DeviceSize size_ )
-    {
-      size = size_;
-      return *this;
-    }
-
-    SparseMemoryBind& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    SparseMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    SparseMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkSparseMemoryBind&() const
-    {
-      return *reinterpret_cast<const VkSparseMemoryBind*>(this);
-    }
-
-    bool operator==( SparseMemoryBind const& rhs ) const
-    {
-      return ( resourceOffset == rhs.resourceOffset )
-          && ( size == rhs.size )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseMemoryBind const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DeviceSize resourceOffset;
-    DeviceSize size;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
-  };
-  static_assert( sizeof( SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryBind
-  {
-    SparseImageMemoryBind( ImageSubresource subresource_ = ImageSubresource(), Offset3D offset_ = Offset3D(), Extent3D extent_ = Extent3D(), DeviceMemory memory_ = DeviceMemory(), DeviceSize memoryOffset_ = 0, SparseMemoryBindFlags flags_ = SparseMemoryBindFlags() )
-      : subresource( subresource_ )
-      , offset( offset_ )
-      , extent( extent_ )
-      , memory( memory_ )
-      , memoryOffset( memoryOffset_ )
-      , flags( flags_ )
-    {
-    }
-
-    SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
-    }
-
-    SparseImageMemoryBind& operator=( VkSparseImageMemoryBind const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBind ) );
-      return *this;
-    }
-    SparseImageMemoryBind& setSubresource( ImageSubresource subresource_ )
-    {
-      subresource = subresource_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setOffset( Offset3D offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setMemoryOffset( DeviceSize memoryOffset_ )
-    {
-      memoryOffset = memoryOffset_;
-      return *this;
-    }
-
-    SparseImageMemoryBind& setFlags( SparseMemoryBindFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkSparseImageMemoryBind&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryBind*>(this);
-    }
-
-    bool operator==( SparseImageMemoryBind const& rhs ) const
-    {
-      return ( subresource == rhs.subresource )
-          && ( offset == rhs.offset )
-          && ( extent == rhs.extent )
-          && ( memory == rhs.memory )
-          && ( memoryOffset == rhs.memoryOffset )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( SparseImageMemoryBind const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageSubresource subresource;
-    Offset3D offset;
-    Extent3D extent;
-    DeviceMemory memory;
-    DeviceSize memoryOffset;
-    SparseMemoryBindFlags flags;
-  };
-  static_assert( sizeof( SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), "struct and wrapper have different size!" );
-
-  struct SparseBufferMemoryBindInfo
-  {
-    SparseBufferMemoryBindInfo( Buffer buffer_ = Buffer(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
-      : buffer( buffer_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
-    }
-
-    SparseBufferMemoryBindInfo& operator=( VkSparseBufferMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseBufferMemoryBindInfo ) );
-      return *this;
-    }
-    SparseBufferMemoryBindInfo& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    SparseBufferMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseBufferMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator const VkSparseBufferMemoryBindInfo&() const
-    {
-      return *reinterpret_cast<const VkSparseBufferMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseBufferMemoryBindInfo const& rhs ) const
-    {
-      return ( buffer == rhs.buffer )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseBufferMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Buffer buffer;
-    uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  struct SparseImageOpaqueMemoryBindInfo
-  {
-    SparseImageOpaqueMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
-    }
-
-    SparseImageOpaqueMemoryBindInfo& operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageOpaqueMemoryBindInfo ) );
-      return *this;
-    }
-    SparseImageOpaqueMemoryBindInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    SparseImageOpaqueMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseImageOpaqueMemoryBindInfo& setPBinds( const SparseMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator const VkSparseImageOpaqueMemoryBindInfo&() const
-    {
-      return *reinterpret_cast<const VkSparseImageOpaqueMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseImageOpaqueMemoryBindInfo const& rhs ) const
-    {
-      return ( image == rhs.image )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseImageOpaqueMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Image image;
-    uint32_t bindCount;
-    const SparseMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  struct SparseImageMemoryBindInfo
-  {
-    SparseImageMemoryBindInfo( Image image_ = Image(), uint32_t bindCount_ = 0, const SparseImageMemoryBind* pBinds_ = nullptr )
-      : image( image_ )
-      , bindCount( bindCount_ )
-      , pBinds( pBinds_ )
-    {
-    }
-
-    SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
-    }
-
-    SparseImageMemoryBindInfo& operator=( VkSparseImageMemoryBindInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SparseImageMemoryBindInfo ) );
-      return *this;
-    }
-    SparseImageMemoryBindInfo& setImage( Image image_ )
-    {
-      image = image_;
-      return *this;
-    }
-
-    SparseImageMemoryBindInfo& setBindCount( uint32_t bindCount_ )
-    {
-      bindCount = bindCount_;
-      return *this;
-    }
-
-    SparseImageMemoryBindInfo& setPBinds( const SparseImageMemoryBind* pBinds_ )
-    {
-      pBinds = pBinds_;
-      return *this;
-    }
-
-    operator const VkSparseImageMemoryBindInfo&() const
-    {
-      return *reinterpret_cast<const VkSparseImageMemoryBindInfo*>(this);
-    }
-
-    bool operator==( SparseImageMemoryBindInfo const& rhs ) const
-    {
-      return ( image == rhs.image )
-          && ( bindCount == rhs.bindCount )
-          && ( pBinds == rhs.pBinds );
-    }
-
-    bool operator!=( SparseImageMemoryBindInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Image image;
-    uint32_t bindCount;
-    const SparseImageMemoryBind* pBinds;
-  };
-  static_assert( sizeof( SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), "struct and wrapper have different size!" );
-
-  struct BindSparseInfo
-  {
-    BindSparseInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, uint32_t bufferBindCount_ = 0, const SparseBufferMemoryBindInfo* pBufferBinds_ = nullptr, uint32_t imageOpaqueBindCount_ = 0, const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ = nullptr, uint32_t imageBindCount_ = 0, const SparseImageMemoryBindInfo* pImageBinds_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , bufferBindCount( bufferBindCount_ )
-      , pBufferBinds( pBufferBinds_ )
-      , imageOpaqueBindCount( imageOpaqueBindCount_ )
-      , pImageOpaqueBinds( pImageOpaqueBinds_ )
-      , imageBindCount( imageBindCount_ )
-      , pImageBinds( pImageBinds_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
-    {
-    }
-
-    BindSparseInfo( VkBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
-    }
-
-    BindSparseInfo& operator=( VkBindSparseInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( BindSparseInfo ) );
-      return *this;
-    }
-    BindSparseInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    BindSparseInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    BindSparseInfo& setBufferBindCount( uint32_t bufferBindCount_ )
-    {
-      bufferBindCount = bufferBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPBufferBinds( const SparseBufferMemoryBindInfo* pBufferBinds_ )
-    {
-      pBufferBinds = pBufferBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ )
-    {
-      imageOpaqueBindCount = imageOpaqueBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds_ )
-    {
-      pImageOpaqueBinds = pImageOpaqueBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setImageBindCount( uint32_t imageBindCount_ )
-    {
-      imageBindCount = imageBindCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPImageBinds( const SparseImageMemoryBindInfo* pImageBinds_ )
-    {
-      pImageBinds = pImageBinds_;
-      return *this;
-    }
-
-    BindSparseInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    BindSparseInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
-    {
-      pSignalSemaphores = pSignalSemaphores_;
-      return *this;
-    }
-
-    operator const VkBindSparseInfo&() const
-    {
-      return *reinterpret_cast<const VkBindSparseInfo*>(this);
-    }
-
-    bool operator==( BindSparseInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( bufferBindCount == rhs.bufferBindCount )
-          && ( pBufferBinds == rhs.pBufferBinds )
-          && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount )
-          && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds )
-          && ( imageBindCount == rhs.imageBindCount )
-          && ( pImageBinds == rhs.pImageBinds )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphores == rhs.pSignalSemaphores );
-    }
-
-    bool operator!=( BindSparseInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eBindSparseInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    uint32_t bufferBindCount;
-    const SparseBufferMemoryBindInfo* pBufferBinds;
-    uint32_t imageOpaqueBindCount;
-    const SparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
-    uint32_t imageBindCount;
-    const SparseImageMemoryBindInfo* pImageBinds;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
-  };
-  static_assert( sizeof( BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" );
-
-  enum class PipelineStageFlagBits
-  {
-    eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-    eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT,
-    eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT,
-    eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
-    eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT,
-    eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT,
-    eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT,
-    eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
-    eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-    eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
-    eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-    eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-    eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT,
-    eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
-    eHost = VK_PIPELINE_STAGE_HOST_BIT,
-    eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
-    eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-    eCommandProcessNVX = VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX
-  };
-
-  using PipelineStageFlags = Flags<PipelineStageFlagBits, VkPipelineStageFlags>;
-
-  VULKAN_HPP_INLINE PipelineStageFlags operator|( PipelineStageFlagBits bit0, PipelineStageFlagBits bit1 )
-  {
-    return PipelineStageFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PipelineStageFlags operator~( PipelineStageFlagBits bits )
-  {
-    return ~( PipelineStageFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<PipelineStageFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(PipelineStageFlagBits::eTopOfPipe) | VkFlags(PipelineStageFlagBits::eDrawIndirect) | VkFlags(PipelineStageFlagBits::eVertexInput) | VkFlags(PipelineStageFlagBits::eVertexShader) | VkFlags(PipelineStageFlagBits::eTessellationControlShader) | VkFlags(PipelineStageFlagBits::eTessellationEvaluationShader) | VkFlags(PipelineStageFlagBits::eGeometryShader) | VkFlags(PipelineStageFlagBits::eFragmentShader) | VkFlags(PipelineStageFlagBits::eEarlyFragmentTests) | VkFlags(PipelineStageFlagBits::eLateFragmentTests) | VkFlags(PipelineStageFlagBits::eColorAttachmentOutput) | VkFlags(PipelineStageFlagBits::eComputeShader) | VkFlags(PipelineStageFlagBits::eTransfer) | VkFlags(PipelineStageFlagBits::eBottomOfPipe) | VkFlags(PipelineStageFlagBits::eHost) | VkFlags(PipelineStageFlagBits::eAllGraphics) | VkFlags(PipelineStageFlagBits::eAllCommands) | VkFlags(PipelineStageFlagBits::eCommandProcessNVX)
-    };
-  };
-
-  enum class CommandPoolCreateFlagBits
-  {
-    eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,
-    eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
-  };
-
-  using CommandPoolCreateFlags = Flags<CommandPoolCreateFlagBits, VkCommandPoolCreateFlags>;
-
-  VULKAN_HPP_INLINE CommandPoolCreateFlags operator|( CommandPoolCreateFlagBits bit0, CommandPoolCreateFlagBits bit1 )
-  {
-    return CommandPoolCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandPoolCreateFlags operator~( CommandPoolCreateFlagBits bits )
-  {
-    return ~( CommandPoolCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandPoolCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandPoolCreateFlagBits::eTransient) | VkFlags(CommandPoolCreateFlagBits::eResetCommandBuffer)
-    };
-  };
-
-  struct CommandPoolCreateInfo
-  {
-    CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = CommandPoolCreateFlags(), uint32_t queueFamilyIndex_ = 0 )
-      : flags( flags_ )
-      , queueFamilyIndex( queueFamilyIndex_ )
-    {
-    }
-
-    CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
-    }
-
-    CommandPoolCreateInfo& operator=( VkCommandPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CommandPoolCreateInfo ) );
-      return *this;
-    }
-    CommandPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CommandPoolCreateInfo& setFlags( CommandPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    CommandPoolCreateInfo& setQueueFamilyIndex( uint32_t queueFamilyIndex_ )
-    {
-      queueFamilyIndex = queueFamilyIndex_;
-      return *this;
-    }
-
-    operator const VkCommandPoolCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkCommandPoolCreateInfo*>(this);
-    }
-
-    bool operator==( CommandPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( queueFamilyIndex == rhs.queueFamilyIndex );
-    }
-
-    bool operator!=( CommandPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCommandPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    CommandPoolCreateFlags flags;
-    uint32_t queueFamilyIndex;
-  };
-  static_assert( sizeof( CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class CommandPoolResetFlagBits
-  {
-    eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT
-  };
-
-  using CommandPoolResetFlags = Flags<CommandPoolResetFlagBits, VkCommandPoolResetFlags>;
-
-  VULKAN_HPP_INLINE CommandPoolResetFlags operator|( CommandPoolResetFlagBits bit0, CommandPoolResetFlagBits bit1 )
-  {
-    return CommandPoolResetFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandPoolResetFlags operator~( CommandPoolResetFlagBits bits )
-  {
-    return ~( CommandPoolResetFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandPoolResetFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandPoolResetFlagBits::eReleaseResources)
-    };
-  };
-
-  enum class CommandBufferResetFlagBits
-  {
-    eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT
-  };
-
-  using CommandBufferResetFlags = Flags<CommandBufferResetFlagBits, VkCommandBufferResetFlags>;
-
-  VULKAN_HPP_INLINE CommandBufferResetFlags operator|( CommandBufferResetFlagBits bit0, CommandBufferResetFlagBits bit1 )
-  {
-    return CommandBufferResetFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CommandBufferResetFlags operator~( CommandBufferResetFlagBits bits )
-  {
-    return ~( CommandBufferResetFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<CommandBufferResetFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(CommandBufferResetFlagBits::eReleaseResources)
-    };
-  };
-
-  enum class SampleCountFlagBits
-  {
-    e1 = VK_SAMPLE_COUNT_1_BIT,
-    e2 = VK_SAMPLE_COUNT_2_BIT,
-    e4 = VK_SAMPLE_COUNT_4_BIT,
-    e8 = VK_SAMPLE_COUNT_8_BIT,
-    e16 = VK_SAMPLE_COUNT_16_BIT,
-    e32 = VK_SAMPLE_COUNT_32_BIT,
-    e64 = VK_SAMPLE_COUNT_64_BIT
-  };
-
-  using SampleCountFlags = Flags<SampleCountFlagBits, VkSampleCountFlags>;
-
-  VULKAN_HPP_INLINE SampleCountFlags operator|( SampleCountFlagBits bit0, SampleCountFlagBits bit1 )
-  {
-    return SampleCountFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SampleCountFlags operator~( SampleCountFlagBits bits )
-  {
-    return ~( SampleCountFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SampleCountFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SampleCountFlagBits::e1) | VkFlags(SampleCountFlagBits::e2) | VkFlags(SampleCountFlagBits::e4) | VkFlags(SampleCountFlagBits::e8) | VkFlags(SampleCountFlagBits::e16) | VkFlags(SampleCountFlagBits::e32) | VkFlags(SampleCountFlagBits::e64)
-    };
-  };
-
-  struct ImageFormatProperties
-  {
-    operator const VkImageFormatProperties&() const
-    {
-      return *reinterpret_cast<const VkImageFormatProperties*>(this);
-    }
-
-    bool operator==( ImageFormatProperties const& rhs ) const
-    {
-      return ( maxExtent == rhs.maxExtent )
-          && ( maxMipLevels == rhs.maxMipLevels )
-          && ( maxArrayLayers == rhs.maxArrayLayers )
-          && ( sampleCounts == rhs.sampleCounts )
-          && ( maxResourceSize == rhs.maxResourceSize );
-    }
-
-    bool operator!=( ImageFormatProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Extent3D maxExtent;
-    uint32_t maxMipLevels;
-    uint32_t maxArrayLayers;
-    SampleCountFlags sampleCounts;
-    DeviceSize maxResourceSize;
-  };
-  static_assert( sizeof( ImageFormatProperties ) == sizeof( VkImageFormatProperties ), "struct and wrapper have different size!" );
-
-  struct ImageCreateInfo
-  {
-    ImageCreateInfo( ImageCreateFlags flags_ = ImageCreateFlags(), ImageType imageType_ = ImageType::e1D, Format format_ = Format::eUndefined, Extent3D extent_ = Extent3D(), uint32_t mipLevels_ = 0, uint32_t arrayLayers_ = 0, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageTiling tiling_ = ImageTiling::eOptimal, ImageUsageFlags usage_ = ImageUsageFlags(), SharingMode sharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, ImageLayout initialLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , imageType( imageType_ )
-      , format( format_ )
-      , extent( extent_ )
-      , mipLevels( mipLevels_ )
-      , arrayLayers( arrayLayers_ )
-      , samples( samples_ )
-      , tiling( tiling_ )
-      , usage( usage_ )
-      , sharingMode( sharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , initialLayout( initialLayout_ )
-    {
-    }
-
-    ImageCreateInfo( VkImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
-    }
-
-    ImageCreateInfo& operator=( VkImageCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImageCreateInfo ) );
-      return *this;
-    }
-    ImageCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImageCreateInfo& setFlags( ImageCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImageCreateInfo& setImageType( ImageType imageType_ )
-    {
-      imageType = imageType_;
-      return *this;
-    }
-
-    ImageCreateInfo& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    ImageCreateInfo& setExtent( Extent3D extent_ )
-    {
-      extent = extent_;
-      return *this;
-    }
-
-    ImageCreateInfo& setMipLevels( uint32_t mipLevels_ )
-    {
-      mipLevels = mipLevels_;
-      return *this;
-    }
-
-    ImageCreateInfo& setArrayLayers( uint32_t arrayLayers_ )
-    {
-      arrayLayers = arrayLayers_;
-      return *this;
-    }
-
-    ImageCreateInfo& setSamples( SampleCountFlagBits samples_ )
-    {
-      samples = samples_;
-      return *this;
-    }
-
-    ImageCreateInfo& setTiling( ImageTiling tiling_ )
-    {
-      tiling = tiling_;
-      return *this;
-    }
-
-    ImageCreateInfo& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    ImageCreateInfo& setSharingMode( SharingMode sharingMode_ )
-    {
-      sharingMode = sharingMode_;
-      return *this;
-    }
-
-    ImageCreateInfo& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
-    {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
-    }
-
-    ImageCreateInfo& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    ImageCreateInfo& setInitialLayout( ImageLayout initialLayout_ )
-    {
-      initialLayout = initialLayout_;
-      return *this;
-    }
-
-    operator const VkImageCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkImageCreateInfo*>(this);
-    }
-
-    bool operator==( ImageCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( imageType == rhs.imageType )
-          && ( format == rhs.format )
-          && ( extent == rhs.extent )
-          && ( mipLevels == rhs.mipLevels )
-          && ( arrayLayers == rhs.arrayLayers )
-          && ( samples == rhs.samples )
-          && ( tiling == rhs.tiling )
-          && ( usage == rhs.usage )
-          && ( sharingMode == rhs.sharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
-          && ( initialLayout == rhs.initialLayout );
-    }
-
-    bool operator!=( ImageCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    ImageCreateFlags flags;
-    ImageType imageType;
-    Format format;
-    Extent3D extent;
-    uint32_t mipLevels;
-    uint32_t arrayLayers;
-    SampleCountFlagBits samples;
-    ImageTiling tiling;
-    ImageUsageFlags usage;
-    SharingMode sharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    ImageLayout initialLayout;
-  };
-  static_assert( sizeof( ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PipelineMultisampleStateCreateInfo
-  {
-    PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = PipelineMultisampleStateCreateFlags(), SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, Bool32 sampleShadingEnable_ = 0, float minSampleShading_ = 0, const SampleMask* pSampleMask_ = nullptr, Bool32 alphaToCoverageEnable_ = 0, Bool32 alphaToOneEnable_ = 0 )
-      : flags( flags_ )
-      , rasterizationSamples( rasterizationSamples_ )
-      , sampleShadingEnable( sampleShadingEnable_ )
-      , minSampleShading( minSampleShading_ )
-      , pSampleMask( pSampleMask_ )
-      , alphaToCoverageEnable( alphaToCoverageEnable_ )
-      , alphaToOneEnable( alphaToOneEnable_ )
-    {
-    }
-
-    PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
-    }
-
-    PipelineMultisampleStateCreateInfo& operator=( VkPipelineMultisampleStateCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineMultisampleStateCreateInfo ) );
-      return *this;
-    }
-    PipelineMultisampleStateCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setFlags( PipelineMultisampleStateCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ )
-    {
-      rasterizationSamples = rasterizationSamples_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setSampleShadingEnable( Bool32 sampleShadingEnable_ )
-    {
-      sampleShadingEnable = sampleShadingEnable_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setMinSampleShading( float minSampleShading_ )
-    {
-      minSampleShading = minSampleShading_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setPSampleMask( const SampleMask* pSampleMask_ )
-    {
-      pSampleMask = pSampleMask_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ )
-    {
-      alphaToCoverageEnable = alphaToCoverageEnable_;
-      return *this;
-    }
-
-    PipelineMultisampleStateCreateInfo& setAlphaToOneEnable( Bool32 alphaToOneEnable_ )
-    {
-      alphaToOneEnable = alphaToOneEnable_;
-      return *this;
-    }
-
-    operator const VkPipelineMultisampleStateCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkPipelineMultisampleStateCreateInfo*>(this);
-    }
-
-    bool operator==( PipelineMultisampleStateCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( rasterizationSamples == rhs.rasterizationSamples )
-          && ( sampleShadingEnable == rhs.sampleShadingEnable )
-          && ( minSampleShading == rhs.minSampleShading )
-          && ( pSampleMask == rhs.pSampleMask )
-          && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable )
-          && ( alphaToOneEnable == rhs.alphaToOneEnable );
-    }
-
-    bool operator!=( PipelineMultisampleStateCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineMultisampleStateCreateFlags flags;
-    SampleCountFlagBits rasterizationSamples;
-    Bool32 sampleShadingEnable;
-    float minSampleShading;
-    const SampleMask* pSampleMask;
-    Bool32 alphaToCoverageEnable;
-    Bool32 alphaToOneEnable;
-  };
-  static_assert( sizeof( PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), "struct and wrapper have different size!" );
-
-  struct GraphicsPipelineCreateInfo
-  {
-    GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = PipelineCreateFlags(), uint32_t stageCount_ = 0, const PipelineShaderStageCreateInfo* pStages_ = nullptr, const PipelineVertexInputStateCreateInfo* pVertexInputState_ = nullptr, const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ = nullptr, const PipelineTessellationStateCreateInfo* pTessellationState_ = nullptr, const PipelineViewportStateCreateInfo* pViewportState_ = nullptr, const PipelineRasterizationStateCreateInfo* pRasterizationState_ = nullptr, const PipelineMultisampleStateCreateInfo* pMultisampleState_ = nullptr, const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ = nullptr, const PipelineColorBlendStateCreateInfo* pColorBlendState_ = nullptr, const PipelineDynamicStateCreateInfo* pDynamicState_ = nullptr, PipelineLayout layout_ = PipelineLayout(), RenderPass renderPass_ = RenderPass(), uint32_t subpass_ = 0, Pipeline basePipelineHandle_ = Pipeline(), int32_t basePipelineIndex_ = 0 )
-      : flags( flags_ )
-      , stageCount( stageCount_ )
-      , pStages( pStages_ )
-      , pVertexInputState( pVertexInputState_ )
-      , pInputAssemblyState( pInputAssemblyState_ )
-      , pTessellationState( pTessellationState_ )
-      , pViewportState( pViewportState_ )
-      , pRasterizationState( pRasterizationState_ )
-      , pMultisampleState( pMultisampleState_ )
-      , pDepthStencilState( pDepthStencilState_ )
-      , pColorBlendState( pColorBlendState_ )
-      , pDynamicState( pDynamicState_ )
-      , layout( layout_ )
-      , renderPass( renderPass_ )
-      , subpass( subpass_ )
-      , basePipelineHandle( basePipelineHandle_ )
-      , basePipelineIndex( basePipelineIndex_ )
-    {
-    }
-
-    GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
-    }
-
-    GraphicsPipelineCreateInfo& operator=( VkGraphicsPipelineCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( GraphicsPipelineCreateInfo ) );
-      return *this;
-    }
-    GraphicsPipelineCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setFlags( PipelineCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setStageCount( uint32_t stageCount_ )
-    {
-      stageCount = stageCount_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPStages( const PipelineShaderStageCreateInfo* pStages_ )
-    {
-      pStages = pStages_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPVertexInputState( const PipelineVertexInputStateCreateInfo* pVertexInputState_ )
-    {
-      pVertexInputState = pVertexInputState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState_ )
-    {
-      pInputAssemblyState = pInputAssemblyState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPTessellationState( const PipelineTessellationStateCreateInfo* pTessellationState_ )
-    {
-      pTessellationState = pTessellationState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPViewportState( const PipelineViewportStateCreateInfo* pViewportState_ )
-    {
-      pViewportState = pViewportState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPRasterizationState( const PipelineRasterizationStateCreateInfo* pRasterizationState_ )
-    {
-      pRasterizationState = pRasterizationState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPMultisampleState( const PipelineMultisampleStateCreateInfo* pMultisampleState_ )
-    {
-      pMultisampleState = pMultisampleState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPDepthStencilState( const PipelineDepthStencilStateCreateInfo* pDepthStencilState_ )
-    {
-      pDepthStencilState = pDepthStencilState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPColorBlendState( const PipelineColorBlendStateCreateInfo* pColorBlendState_ )
-    {
-      pColorBlendState = pColorBlendState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setPDynamicState( const PipelineDynamicStateCreateInfo* pDynamicState_ )
-    {
-      pDynamicState = pDynamicState_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setLayout( PipelineLayout layout_ )
-    {
-      layout = layout_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setRenderPass( RenderPass renderPass_ )
-    {
-      renderPass = renderPass_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setSubpass( uint32_t subpass_ )
-    {
-      subpass = subpass_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setBasePipelineHandle( Pipeline basePipelineHandle_ )
-    {
-      basePipelineHandle = basePipelineHandle_;
-      return *this;
-    }
-
-    GraphicsPipelineCreateInfo& setBasePipelineIndex( int32_t basePipelineIndex_ )
-    {
-      basePipelineIndex = basePipelineIndex_;
-      return *this;
-    }
-
-    operator const VkGraphicsPipelineCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkGraphicsPipelineCreateInfo*>(this);
-    }
-
-    bool operator==( GraphicsPipelineCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( stageCount == rhs.stageCount )
-          && ( pStages == rhs.pStages )
-          && ( pVertexInputState == rhs.pVertexInputState )
-          && ( pInputAssemblyState == rhs.pInputAssemblyState )
-          && ( pTessellationState == rhs.pTessellationState )
-          && ( pViewportState == rhs.pViewportState )
-          && ( pRasterizationState == rhs.pRasterizationState )
-          && ( pMultisampleState == rhs.pMultisampleState )
-          && ( pDepthStencilState == rhs.pDepthStencilState )
-          && ( pColorBlendState == rhs.pColorBlendState )
-          && ( pDynamicState == rhs.pDynamicState )
-          && ( layout == rhs.layout )
-          && ( renderPass == rhs.renderPass )
-          && ( subpass == rhs.subpass )
-          && ( basePipelineHandle == rhs.basePipelineHandle )
-          && ( basePipelineIndex == rhs.basePipelineIndex );
-    }
-
-    bool operator!=( GraphicsPipelineCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eGraphicsPipelineCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCreateFlags flags;
-    uint32_t stageCount;
-    const PipelineShaderStageCreateInfo* pStages;
-    const PipelineVertexInputStateCreateInfo* pVertexInputState;
-    const PipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
-    const PipelineTessellationStateCreateInfo* pTessellationState;
-    const PipelineViewportStateCreateInfo* pViewportState;
-    const PipelineRasterizationStateCreateInfo* pRasterizationState;
-    const PipelineMultisampleStateCreateInfo* pMultisampleState;
-    const PipelineDepthStencilStateCreateInfo* pDepthStencilState;
-    const PipelineColorBlendStateCreateInfo* pColorBlendState;
-    const PipelineDynamicStateCreateInfo* pDynamicState;
-    PipelineLayout layout;
-    RenderPass renderPass;
-    uint32_t subpass;
-    Pipeline basePipelineHandle;
-    int32_t basePipelineIndex;
-  };
-  static_assert( sizeof( GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceLimits
-  {
-    operator const VkPhysicalDeviceLimits&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceLimits*>(this);
-    }
-
-    bool operator==( PhysicalDeviceLimits const& rhs ) const
-    {
-      return ( maxImageDimension1D == rhs.maxImageDimension1D )
-          && ( maxImageDimension2D == rhs.maxImageDimension2D )
-          && ( maxImageDimension3D == rhs.maxImageDimension3D )
-          && ( maxImageDimensionCube == rhs.maxImageDimensionCube )
-          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
-          && ( maxTexelBufferElements == rhs.maxTexelBufferElements )
-          && ( maxUniformBufferRange == rhs.maxUniformBufferRange )
-          && ( maxStorageBufferRange == rhs.maxStorageBufferRange )
-          && ( maxPushConstantsSize == rhs.maxPushConstantsSize )
-          && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount )
-          && ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount )
-          && ( bufferImageGranularity == rhs.bufferImageGranularity )
-          && ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize )
-          && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets )
-          && ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers )
-          && ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers )
-          && ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers )
-          && ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages )
-          && ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages )
-          && ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments )
-          && ( maxPerStageResources == rhs.maxPerStageResources )
-          && ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers )
-          && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers )
-          && ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic )
-          && ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers )
-          && ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic )
-          && ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages )
-          && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages )
-          && ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments )
-          && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes )
-          && ( maxVertexInputBindings == rhs.maxVertexInputBindings )
-          && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset )
-          && ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride )
-          && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents )
-          && ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel )
-          && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize )
-          && ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents )
-          && ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents )
-          && ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents )
-          && ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents )
-          && ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents )
-          && ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents )
-          && ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations )
-          && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents )
-          && ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents )
-          && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices )
-          && ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents )
-          && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents )
-          && ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments )
-          && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments )
-          && ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources )
-          && ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize )
-          && ( memcmp( maxComputeWorkGroupCount, rhs.maxComputeWorkGroupCount, 3 * sizeof( uint32_t ) ) == 0 )
-          && ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations )
-          && ( memcmp( maxComputeWorkGroupSize, rhs.maxComputeWorkGroupSize, 3 * sizeof( uint32_t ) ) == 0 )
-          && ( subPixelPrecisionBits == rhs.subPixelPrecisionBits )
-          && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits )
-          && ( mipmapPrecisionBits == rhs.mipmapPrecisionBits )
-          && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue )
-          && ( maxDrawIndirectCount == rhs.maxDrawIndirectCount )
-          && ( maxSamplerLodBias == rhs.maxSamplerLodBias )
-          && ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy )
-          && ( maxViewports == rhs.maxViewports )
-          && ( memcmp( maxViewportDimensions, rhs.maxViewportDimensions, 2 * sizeof( uint32_t ) ) == 0 )
-          && ( memcmp( viewportBoundsRange, rhs.viewportBoundsRange, 2 * sizeof( float ) ) == 0 )
-          && ( viewportSubPixelBits == rhs.viewportSubPixelBits )
-          && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment )
-          && ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment )
-          && ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment )
-          && ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment )
-          && ( minTexelOffset == rhs.minTexelOffset )
-          && ( maxTexelOffset == rhs.maxTexelOffset )
-          && ( minTexelGatherOffset == rhs.minTexelGatherOffset )
-          && ( maxTexelGatherOffset == rhs.maxTexelGatherOffset )
-          && ( minInterpolationOffset == rhs.minInterpolationOffset )
-          && ( maxInterpolationOffset == rhs.maxInterpolationOffset )
-          && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits )
-          && ( maxFramebufferWidth == rhs.maxFramebufferWidth )
-          && ( maxFramebufferHeight == rhs.maxFramebufferHeight )
-          && ( maxFramebufferLayers == rhs.maxFramebufferLayers )
-          && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts )
-          && ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts )
-          && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts )
-          && ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts )
-          && ( maxColorAttachments == rhs.maxColorAttachments )
-          && ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts )
-          && ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts )
-          && ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts )
-          && ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts )
-          && ( storageImageSampleCounts == rhs.storageImageSampleCounts )
-          && ( maxSampleMaskWords == rhs.maxSampleMaskWords )
-          && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics )
-          && ( timestampPeriod == rhs.timestampPeriod )
-          && ( maxClipDistances == rhs.maxClipDistances )
-          && ( maxCullDistances == rhs.maxCullDistances )
-          && ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances )
-          && ( discreteQueuePriorities == rhs.discreteQueuePriorities )
-          && ( memcmp( pointSizeRange, rhs.pointSizeRange, 2 * sizeof( float ) ) == 0 )
-          && ( memcmp( lineWidthRange, rhs.lineWidthRange, 2 * sizeof( float ) ) == 0 )
-          && ( pointSizeGranularity == rhs.pointSizeGranularity )
-          && ( lineWidthGranularity == rhs.lineWidthGranularity )
-          && ( strictLines == rhs.strictLines )
-          && ( standardSampleLocations == rhs.standardSampleLocations )
-          && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment )
-          && ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment )
-          && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
-    }
-
-    bool operator!=( PhysicalDeviceLimits const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t maxImageDimension1D;
-    uint32_t maxImageDimension2D;
-    uint32_t maxImageDimension3D;
-    uint32_t maxImageDimensionCube;
-    uint32_t maxImageArrayLayers;
-    uint32_t maxTexelBufferElements;
-    uint32_t maxUniformBufferRange;
-    uint32_t maxStorageBufferRange;
-    uint32_t maxPushConstantsSize;
-    uint32_t maxMemoryAllocationCount;
-    uint32_t maxSamplerAllocationCount;
-    DeviceSize bufferImageGranularity;
-    DeviceSize sparseAddressSpaceSize;
-    uint32_t maxBoundDescriptorSets;
-    uint32_t maxPerStageDescriptorSamplers;
-    uint32_t maxPerStageDescriptorUniformBuffers;
-    uint32_t maxPerStageDescriptorStorageBuffers;
-    uint32_t maxPerStageDescriptorSampledImages;
-    uint32_t maxPerStageDescriptorStorageImages;
-    uint32_t maxPerStageDescriptorInputAttachments;
-    uint32_t maxPerStageResources;
-    uint32_t maxDescriptorSetSamplers;
-    uint32_t maxDescriptorSetUniformBuffers;
-    uint32_t maxDescriptorSetUniformBuffersDynamic;
-    uint32_t maxDescriptorSetStorageBuffers;
-    uint32_t maxDescriptorSetStorageBuffersDynamic;
-    uint32_t maxDescriptorSetSampledImages;
-    uint32_t maxDescriptorSetStorageImages;
-    uint32_t maxDescriptorSetInputAttachments;
-    uint32_t maxVertexInputAttributes;
-    uint32_t maxVertexInputBindings;
-    uint32_t maxVertexInputAttributeOffset;
-    uint32_t maxVertexInputBindingStride;
-    uint32_t maxVertexOutputComponents;
-    uint32_t maxTessellationGenerationLevel;
-    uint32_t maxTessellationPatchSize;
-    uint32_t maxTessellationControlPerVertexInputComponents;
-    uint32_t maxTessellationControlPerVertexOutputComponents;
-    uint32_t maxTessellationControlPerPatchOutputComponents;
-    uint32_t maxTessellationControlTotalOutputComponents;
-    uint32_t maxTessellationEvaluationInputComponents;
-    uint32_t maxTessellationEvaluationOutputComponents;
-    uint32_t maxGeometryShaderInvocations;
-    uint32_t maxGeometryInputComponents;
-    uint32_t maxGeometryOutputComponents;
-    uint32_t maxGeometryOutputVertices;
-    uint32_t maxGeometryTotalOutputComponents;
-    uint32_t maxFragmentInputComponents;
-    uint32_t maxFragmentOutputAttachments;
-    uint32_t maxFragmentDualSrcAttachments;
-    uint32_t maxFragmentCombinedOutputResources;
-    uint32_t maxComputeSharedMemorySize;
-    uint32_t maxComputeWorkGroupCount[3];
-    uint32_t maxComputeWorkGroupInvocations;
-    uint32_t maxComputeWorkGroupSize[3];
-    uint32_t subPixelPrecisionBits;
-    uint32_t subTexelPrecisionBits;
-    uint32_t mipmapPrecisionBits;
-    uint32_t maxDrawIndexedIndexValue;
-    uint32_t maxDrawIndirectCount;
-    float maxSamplerLodBias;
-    float maxSamplerAnisotropy;
-    uint32_t maxViewports;
-    uint32_t maxViewportDimensions[2];
-    float viewportBoundsRange[2];
-    uint32_t viewportSubPixelBits;
-    size_t minMemoryMapAlignment;
-    DeviceSize minTexelBufferOffsetAlignment;
-    DeviceSize minUniformBufferOffsetAlignment;
-    DeviceSize minStorageBufferOffsetAlignment;
-    int32_t minTexelOffset;
-    uint32_t maxTexelOffset;
-    int32_t minTexelGatherOffset;
-    uint32_t maxTexelGatherOffset;
-    float minInterpolationOffset;
-    float maxInterpolationOffset;
-    uint32_t subPixelInterpolationOffsetBits;
-    uint32_t maxFramebufferWidth;
-    uint32_t maxFramebufferHeight;
-    uint32_t maxFramebufferLayers;
-    SampleCountFlags framebufferColorSampleCounts;
-    SampleCountFlags framebufferDepthSampleCounts;
-    SampleCountFlags framebufferStencilSampleCounts;
-    SampleCountFlags framebufferNoAttachmentsSampleCounts;
-    uint32_t maxColorAttachments;
-    SampleCountFlags sampledImageColorSampleCounts;
-    SampleCountFlags sampledImageIntegerSampleCounts;
-    SampleCountFlags sampledImageDepthSampleCounts;
-    SampleCountFlags sampledImageStencilSampleCounts;
-    SampleCountFlags storageImageSampleCounts;
-    uint32_t maxSampleMaskWords;
-    Bool32 timestampComputeAndGraphics;
-    float timestampPeriod;
-    uint32_t maxClipDistances;
-    uint32_t maxCullDistances;
-    uint32_t maxCombinedClipAndCullDistances;
-    uint32_t discreteQueuePriorities;
-    float pointSizeRange[2];
-    float lineWidthRange[2];
-    float pointSizeGranularity;
-    float lineWidthGranularity;
-    Bool32 strictLines;
-    Bool32 standardSampleLocations;
-    DeviceSize optimalBufferCopyOffsetAlignment;
-    DeviceSize optimalBufferCopyRowPitchAlignment;
-    DeviceSize nonCoherentAtomSize;
-  };
-  static_assert( sizeof( PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceProperties
-  {
-    operator const VkPhysicalDeviceProperties&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceProperties*>(this);
-    }
-
-    bool operator==( PhysicalDeviceProperties const& rhs ) const
-    {
-      return ( apiVersion == rhs.apiVersion )
-          && ( driverVersion == rhs.driverVersion )
-          && ( vendorID == rhs.vendorID )
-          && ( deviceID == rhs.deviceID )
-          && ( deviceType == rhs.deviceType )
-          && ( memcmp( deviceName, rhs.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof( char ) ) == 0 )
-          && ( memcmp( pipelineCacheUUID, rhs.pipelineCacheUUID, VK_UUID_SIZE * sizeof( uint8_t ) ) == 0 )
-          && ( limits == rhs.limits )
-          && ( sparseProperties == rhs.sparseProperties );
-    }
-
-    bool operator!=( PhysicalDeviceProperties const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t apiVersion;
-    uint32_t driverVersion;
-    uint32_t vendorID;
-    uint32_t deviceID;
-    PhysicalDeviceType deviceType;
-    char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
-    uint8_t pipelineCacheUUID[VK_UUID_SIZE];
-    PhysicalDeviceLimits limits;
-    PhysicalDeviceSparseProperties sparseProperties;
-  };
-  static_assert( sizeof( PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceProperties2KHR
-  {
-    operator const VkPhysicalDeviceProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceProperties2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( properties == rhs.properties );
-    }
-
-    bool operator!=( PhysicalDeviceProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    PhysicalDeviceProperties properties;
-  };
-  static_assert( sizeof( PhysicalDeviceProperties2KHR ) == sizeof( VkPhysicalDeviceProperties2KHR ), "struct and wrapper have different size!" );
-
-  struct ImageFormatProperties2KHR
-  {
-    operator const VkImageFormatProperties2KHR&() const
-    {
-      return *reinterpret_cast<const VkImageFormatProperties2KHR*>(this);
-    }
-
-    bool operator==( ImageFormatProperties2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( imageFormatProperties == rhs.imageFormatProperties );
-    }
-
-    bool operator!=( ImageFormatProperties2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImageFormatProperties2KHR;
-
-  public:
-    void* pNext = nullptr;
-    ImageFormatProperties imageFormatProperties;
-  };
-  static_assert( sizeof( ImageFormatProperties2KHR ) == sizeof( VkImageFormatProperties2KHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSparseImageFormatInfo2KHR
-  {
-    PhysicalDeviceSparseImageFormatInfo2KHR( Format format_ = Format::eUndefined, ImageType type_ = ImageType::e1D, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, ImageUsageFlags usage_ = ImageUsageFlags(), ImageTiling tiling_ = ImageTiling::eOptimal )
-      : format( format_ )
-      , type( type_ )
-      , samples( samples_ )
-      , usage( usage_ )
-      , tiling( tiling_ )
-    {
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) );
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& operator=( VkPhysicalDeviceSparseImageFormatInfo2KHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) );
-      return *this;
-    }
-    PhysicalDeviceSparseImageFormatInfo2KHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& setType( ImageType type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& setSamples( SampleCountFlagBits samples_ )
-    {
-      samples = samples_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& setUsage( ImageUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    PhysicalDeviceSparseImageFormatInfo2KHR& setTiling( ImageTiling tiling_ )
-    {
-      tiling = tiling_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceSparseImageFormatInfo2KHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( format == rhs.format )
-          && ( type == rhs.type )
-          && ( samples == rhs.samples )
-          && ( usage == rhs.usage )
-          && ( tiling == rhs.tiling );
-    }
-
-    bool operator!=( PhysicalDeviceSparseImageFormatInfo2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    ImageType type;
-    SampleCountFlagBits samples;
-    ImageUsageFlags usage;
-    ImageTiling tiling;
-  };
-  static_assert( sizeof( PhysicalDeviceSparseImageFormatInfo2KHR ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2KHR ), "struct and wrapper have different size!" );
-
-  struct SampleLocationsInfoEXT
-  {
-    SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, Extent2D sampleLocationGridSize_ = Extent2D(), uint32_t sampleLocationsCount_ = 0, const SampleLocationEXT* pSampleLocations_ = nullptr )
-      : sampleLocationsPerPixel( sampleLocationsPerPixel_ )
-      , sampleLocationGridSize( sampleLocationGridSize_ )
-      , sampleLocationsCount( sampleLocationsCount_ )
-      , pSampleLocations( pSampleLocations_ )
-    {
-    }
-
-    SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
-    }
-
-    SampleLocationsInfoEXT& operator=( VkSampleLocationsInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SampleLocationsInfoEXT ) );
-      return *this;
-    }
-    SampleLocationsInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SampleLocationsInfoEXT& setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ )
-    {
-      sampleLocationsPerPixel = sampleLocationsPerPixel_;
-      return *this;
-    }
-
-    SampleLocationsInfoEXT& setSampleLocationGridSize( Extent2D sampleLocationGridSize_ )
-    {
-      sampleLocationGridSize = sampleLocationGridSize_;
-      return *this;
-    }
-
-    SampleLocationsInfoEXT& setSampleLocationsCount( uint32_t sampleLocationsCount_ )
-    {
-      sampleLocationsCount = sampleLocationsCount_;
-      return *this;
-    }
-
-    SampleLocationsInfoEXT& setPSampleLocations( const SampleLocationEXT* pSampleLocations_ )
-    {
-      pSampleLocations = pSampleLocations_;
-      return *this;
-    }
-
-    operator const VkSampleLocationsInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkSampleLocationsInfoEXT*>(this);
-    }
-
-    bool operator==( SampleLocationsInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel )
-          && ( sampleLocationGridSize == rhs.sampleLocationGridSize )
-          && ( sampleLocationsCount == rhs.sampleLocationsCount )
-          && ( pSampleLocations == rhs.pSampleLocations );
-    }
-
-    bool operator!=( SampleLocationsInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSampleLocationsInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SampleCountFlagBits sampleLocationsPerPixel;
-    Extent2D sampleLocationGridSize;
-    uint32_t sampleLocationsCount;
-    const SampleLocationEXT* pSampleLocations;
-  };
-  static_assert( sizeof( SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), "struct and wrapper have different size!" );
-
-  struct AttachmentSampleLocationsEXT
-  {
-    AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : attachmentIndex( attachmentIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
-    {
-    }
-
-    AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
-    }
-
-    AttachmentSampleLocationsEXT& operator=( VkAttachmentSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentSampleLocationsEXT ) );
-      return *this;
-    }
-    AttachmentSampleLocationsEXT& setAttachmentIndex( uint32_t attachmentIndex_ )
-    {
-      attachmentIndex = attachmentIndex_;
-      return *this;
-    }
-
-    AttachmentSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
-    {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
-    }
-
-    operator const VkAttachmentSampleLocationsEXT&() const
-    {
-      return *reinterpret_cast<const VkAttachmentSampleLocationsEXT*>(this);
-    }
-
-    bool operator==( AttachmentSampleLocationsEXT const& rhs ) const
-    {
-      return ( attachmentIndex == rhs.attachmentIndex )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
-    }
-
-    bool operator!=( AttachmentSampleLocationsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t attachmentIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
-  };
-  static_assert( sizeof( AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), "struct and wrapper have different size!" );
-
-  struct SubpassSampleLocationsEXT
-  {
-    SubpassSampleLocationsEXT( uint32_t subpassIndex_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : subpassIndex( subpassIndex_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
-    {
-    }
-
-    SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
-    }
-
-    SubpassSampleLocationsEXT& operator=( VkSubpassSampleLocationsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassSampleLocationsEXT ) );
-      return *this;
-    }
-    SubpassSampleLocationsEXT& setSubpassIndex( uint32_t subpassIndex_ )
-    {
-      subpassIndex = subpassIndex_;
-      return *this;
-    }
-
-    SubpassSampleLocationsEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
-    {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
-    }
-
-    operator const VkSubpassSampleLocationsEXT&() const
-    {
-      return *reinterpret_cast<const VkSubpassSampleLocationsEXT*>(this);
-    }
-
-    bool operator==( SubpassSampleLocationsEXT const& rhs ) const
-    {
-      return ( subpassIndex == rhs.subpassIndex )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
-    }
-
-    bool operator!=( SubpassSampleLocationsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t subpassIndex;
-    SampleLocationsInfoEXT sampleLocationsInfo;
-  };
-  static_assert( sizeof( SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), "struct and wrapper have different size!" );
-
-  struct RenderPassSampleLocationsBeginInfoEXT
-  {
-    RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = 0, const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ = nullptr, uint32_t postSubpassSampleLocationsCount_ = 0, const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ = nullptr )
-      : attachmentInitialSampleLocationsCount( attachmentInitialSampleLocationsCount_ )
-      , pAttachmentInitialSampleLocations( pAttachmentInitialSampleLocations_ )
-      , postSubpassSampleLocationsCount( postSubpassSampleLocationsCount_ )
-      , pPostSubpassSampleLocations( pPostSubpassSampleLocations_ )
-    {
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassSampleLocationsBeginInfoEXT ) );
-      return *this;
-    }
-    RenderPassSampleLocationsBeginInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ )
-    {
-      attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_;
-      return *this;
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations_ )
-    {
-      pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_;
-      return *this;
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ )
-    {
-      postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_;
-      return *this;
-    }
-
-    RenderPassSampleLocationsBeginInfoEXT& setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT* pPostSubpassSampleLocations_ )
-    {
-      pPostSubpassSampleLocations = pPostSubpassSampleLocations_;
-      return *this;
-    }
-
-    operator const VkRenderPassSampleLocationsBeginInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT*>(this);
-    }
-
-    bool operator==( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount )
-          && ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations )
-          && ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount )
-          && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
-    }
-
-    bool operator!=( RenderPassSampleLocationsBeginInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t attachmentInitialSampleLocationsCount;
-    const AttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;
-    uint32_t postSubpassSampleLocationsCount;
-    const SubpassSampleLocationsEXT* pPostSubpassSampleLocations;
-  };
-  static_assert( sizeof( RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PipelineSampleLocationsStateCreateInfoEXT
-  {
-    PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = 0, SampleLocationsInfoEXT sampleLocationsInfo_ = SampleLocationsInfoEXT() )
-      : sampleLocationsEnable( sampleLocationsEnable_ )
-      , sampleLocationsInfo( sampleLocationsInfo_ )
-    {
-    }
-
-    PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
-    }
-
-    PipelineSampleLocationsStateCreateInfoEXT& operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineSampleLocationsStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineSampleLocationsStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsEnable( Bool32 sampleLocationsEnable_ )
-    {
-      sampleLocationsEnable = sampleLocationsEnable_;
-      return *this;
-    }
-
-    PipelineSampleLocationsStateCreateInfoEXT& setSampleLocationsInfo( SampleLocationsInfoEXT sampleLocationsInfo_ )
-    {
-      sampleLocationsInfo = sampleLocationsInfo_;
-      return *this;
-    }
-
-    operator const VkPipelineSampleLocationsStateCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sampleLocationsEnable == rhs.sampleLocationsEnable )
-          && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
-    }
-
-    bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 sampleLocationsEnable;
-    SampleLocationsInfoEXT sampleLocationsInfo;
-  };
-  static_assert( sizeof( PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceSampleLocationsPropertiesEXT
-  {
-    operator const VkPhysicalDeviceSampleLocationsPropertiesEXT&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT*>(this);
-    }
-
-    bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts )
-          && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize )
-          && ( memcmp( sampleLocationCoordinateRange, rhs.sampleLocationCoordinateRange, 2 * sizeof( float ) ) == 0 )
-          && ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits )
-          && ( variableSampleLocations == rhs.variableSampleLocations );
-    }
-
-    bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT;
-
-  public:
-    void* pNext = nullptr;
-    SampleCountFlags sampleLocationSampleCounts;
-    Extent2D maxSampleLocationGridSize;
-    float sampleLocationCoordinateRange[2];
-    uint32_t sampleLocationSubPixelBits;
-    Bool32 variableSampleLocations;
-  };
-  static_assert( sizeof( PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), "struct and wrapper have different size!" );
-
-  enum class AttachmentDescriptionFlagBits
-  {
-    eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT
-  };
-
-  using AttachmentDescriptionFlags = Flags<AttachmentDescriptionFlagBits, VkAttachmentDescriptionFlags>;
-
-  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator|( AttachmentDescriptionFlagBits bit0, AttachmentDescriptionFlagBits bit1 )
-  {
-    return AttachmentDescriptionFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE AttachmentDescriptionFlags operator~( AttachmentDescriptionFlagBits bits )
-  {
-    return ~( AttachmentDescriptionFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<AttachmentDescriptionFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(AttachmentDescriptionFlagBits::eMayAlias)
-    };
-  };
-
-  struct AttachmentDescription
-  {
-    AttachmentDescription( AttachmentDescriptionFlags flags_ = AttachmentDescriptionFlags(), Format format_ = Format::eUndefined, SampleCountFlagBits samples_ = SampleCountFlagBits::e1, AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, ImageLayout initialLayout_ = ImageLayout::eUndefined, ImageLayout finalLayout_ = ImageLayout::eUndefined )
-      : flags( flags_ )
-      , format( format_ )
-      , samples( samples_ )
-      , loadOp( loadOp_ )
-      , storeOp( storeOp_ )
-      , stencilLoadOp( stencilLoadOp_ )
-      , stencilStoreOp( stencilStoreOp_ )
-      , initialLayout( initialLayout_ )
-      , finalLayout( finalLayout_ )
-    {
-    }
-
-    AttachmentDescription( VkAttachmentDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
-    }
-
-    AttachmentDescription& operator=( VkAttachmentDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( AttachmentDescription ) );
-      return *this;
-    }
-    AttachmentDescription& setFlags( AttachmentDescriptionFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    AttachmentDescription& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    AttachmentDescription& setSamples( SampleCountFlagBits samples_ )
-    {
-      samples = samples_;
-      return *this;
-    }
-
-    AttachmentDescription& setLoadOp( AttachmentLoadOp loadOp_ )
-    {
-      loadOp = loadOp_;
-      return *this;
-    }
-
-    AttachmentDescription& setStoreOp( AttachmentStoreOp storeOp_ )
-    {
-      storeOp = storeOp_;
-      return *this;
-    }
-
-    AttachmentDescription& setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ )
-    {
-      stencilLoadOp = stencilLoadOp_;
-      return *this;
-    }
-
-    AttachmentDescription& setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ )
-    {
-      stencilStoreOp = stencilStoreOp_;
-      return *this;
-    }
-
-    AttachmentDescription& setInitialLayout( ImageLayout initialLayout_ )
-    {
-      initialLayout = initialLayout_;
-      return *this;
-    }
-
-    AttachmentDescription& setFinalLayout( ImageLayout finalLayout_ )
-    {
-      finalLayout = finalLayout_;
-      return *this;
-    }
-
-    operator const VkAttachmentDescription&() const
-    {
-      return *reinterpret_cast<const VkAttachmentDescription*>(this);
-    }
-
-    bool operator==( AttachmentDescription const& rhs ) const
-    {
-      return ( flags == rhs.flags )
-          && ( format == rhs.format )
-          && ( samples == rhs.samples )
-          && ( loadOp == rhs.loadOp )
-          && ( storeOp == rhs.storeOp )
-          && ( stencilLoadOp == rhs.stencilLoadOp )
-          && ( stencilStoreOp == rhs.stencilStoreOp )
-          && ( initialLayout == rhs.initialLayout )
-          && ( finalLayout == rhs.finalLayout );
-    }
-
-    bool operator!=( AttachmentDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    AttachmentDescriptionFlags flags;
-    Format format;
-    SampleCountFlagBits samples;
-    AttachmentLoadOp loadOp;
-    AttachmentStoreOp storeOp;
-    AttachmentLoadOp stencilLoadOp;
-    AttachmentStoreOp stencilStoreOp;
-    ImageLayout initialLayout;
-    ImageLayout finalLayout;
-  };
-  static_assert( sizeof( AttachmentDescription ) == sizeof( VkAttachmentDescription ), "struct and wrapper have different size!" );
-
-  enum class StencilFaceFlagBits
-  {
-    eFront = VK_STENCIL_FACE_FRONT_BIT,
-    eBack = VK_STENCIL_FACE_BACK_BIT,
-    eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK
-  };
-
-  using StencilFaceFlags = Flags<StencilFaceFlagBits, VkStencilFaceFlags>;
-
-  VULKAN_HPP_INLINE StencilFaceFlags operator|( StencilFaceFlagBits bit0, StencilFaceFlagBits bit1 )
-  {
-    return StencilFaceFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE StencilFaceFlags operator~( StencilFaceFlagBits bits )
-  {
-    return ~( StencilFaceFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<StencilFaceFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(StencilFaceFlagBits::eFront) | VkFlags(StencilFaceFlagBits::eBack) | VkFlags(StencilFaceFlagBits::eVkStencilFrontAndBack)
-    };
-  };
-
-  enum class DescriptorPoolCreateFlagBits
-  {
-    eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT
-  };
-
-  using DescriptorPoolCreateFlags = Flags<DescriptorPoolCreateFlagBits, VkDescriptorPoolCreateFlags>;
-
-  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator|( DescriptorPoolCreateFlagBits bit0, DescriptorPoolCreateFlagBits bit1 )
-  {
-    return DescriptorPoolCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DescriptorPoolCreateFlags operator~( DescriptorPoolCreateFlagBits bits )
-  {
-    return ~( DescriptorPoolCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DescriptorPoolCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DescriptorPoolCreateFlagBits::eFreeDescriptorSet)
-    };
-  };
-
-  struct DescriptorPoolCreateInfo
-  {
-    DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = DescriptorPoolCreateFlags(), uint32_t maxSets_ = 0, uint32_t poolSizeCount_ = 0, const DescriptorPoolSize* pPoolSizes_ = nullptr )
-      : flags( flags_ )
-      , maxSets( maxSets_ )
-      , poolSizeCount( poolSizeCount_ )
-      , pPoolSizes( pPoolSizes_ )
-    {
-    }
-
-    DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
-    }
-
-    DescriptorPoolCreateInfo& operator=( VkDescriptorPoolCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorPoolCreateInfo ) );
-      return *this;
-    }
-    DescriptorPoolCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setFlags( DescriptorPoolCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setMaxSets( uint32_t maxSets_ )
-    {
-      maxSets = maxSets_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setPoolSizeCount( uint32_t poolSizeCount_ )
-    {
-      poolSizeCount = poolSizeCount_;
-      return *this;
-    }
-
-    DescriptorPoolCreateInfo& setPPoolSizes( const DescriptorPoolSize* pPoolSizes_ )
-    {
-      pPoolSizes = pPoolSizes_;
-      return *this;
-    }
-
-    operator const VkDescriptorPoolCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkDescriptorPoolCreateInfo*>(this);
-    }
-
-    bool operator==( DescriptorPoolCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( maxSets == rhs.maxSets )
-          && ( poolSizeCount == rhs.poolSizeCount )
-          && ( pPoolSizes == rhs.pPoolSizes );
-    }
-
-    bool operator!=( DescriptorPoolCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorPoolCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorPoolCreateFlags flags;
-    uint32_t maxSets;
-    uint32_t poolSizeCount;
-    const DescriptorPoolSize* pPoolSizes;
-  };
-  static_assert( sizeof( DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class DependencyFlagBits
-  {
-    eByRegion = VK_DEPENDENCY_BY_REGION_BIT,
-    eViewLocalKHX = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX,
-    eDeviceGroupKHX = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX
-  };
-
-  using DependencyFlags = Flags<DependencyFlagBits, VkDependencyFlags>;
-
-  VULKAN_HPP_INLINE DependencyFlags operator|( DependencyFlagBits bit0, DependencyFlagBits bit1 )
-  {
-    return DependencyFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DependencyFlags operator~( DependencyFlagBits bits )
-  {
-    return ~( DependencyFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DependencyFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DependencyFlagBits::eByRegion) | VkFlags(DependencyFlagBits::eViewLocalKHX) | VkFlags(DependencyFlagBits::eDeviceGroupKHX)
-    };
-  };
-
-  struct SubpassDependency
-  {
-    SubpassDependency( uint32_t srcSubpass_ = 0, uint32_t dstSubpass_ = 0, PipelineStageFlags srcStageMask_ = PipelineStageFlags(), PipelineStageFlags dstStageMask_ = PipelineStageFlags(), AccessFlags srcAccessMask_ = AccessFlags(), AccessFlags dstAccessMask_ = AccessFlags(), DependencyFlags dependencyFlags_ = DependencyFlags() )
-      : srcSubpass( srcSubpass_ )
-      , dstSubpass( dstSubpass_ )
-      , srcStageMask( srcStageMask_ )
-      , dstStageMask( dstStageMask_ )
-      , srcAccessMask( srcAccessMask_ )
-      , dstAccessMask( dstAccessMask_ )
-      , dependencyFlags( dependencyFlags_ )
-    {
-    }
-
-    SubpassDependency( VkSubpassDependency const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency ) );
-    }
-
-    SubpassDependency& operator=( VkSubpassDependency const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDependency ) );
-      return *this;
-    }
-    SubpassDependency& setSrcSubpass( uint32_t srcSubpass_ )
-    {
-      srcSubpass = srcSubpass_;
-      return *this;
-    }
-
-    SubpassDependency& setDstSubpass( uint32_t dstSubpass_ )
-    {
-      dstSubpass = dstSubpass_;
-      return *this;
-    }
-
-    SubpassDependency& setSrcStageMask( PipelineStageFlags srcStageMask_ )
-    {
-      srcStageMask = srcStageMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDstStageMask( PipelineStageFlags dstStageMask_ )
-    {
-      dstStageMask = dstStageMask_;
-      return *this;
-    }
-
-    SubpassDependency& setSrcAccessMask( AccessFlags srcAccessMask_ )
-    {
-      srcAccessMask = srcAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDstAccessMask( AccessFlags dstAccessMask_ )
-    {
-      dstAccessMask = dstAccessMask_;
-      return *this;
-    }
-
-    SubpassDependency& setDependencyFlags( DependencyFlags dependencyFlags_ )
-    {
-      dependencyFlags = dependencyFlags_;
-      return *this;
-    }
-
-    operator const VkSubpassDependency&() const
-    {
-      return *reinterpret_cast<const VkSubpassDependency*>(this);
-    }
-
-    bool operator==( SubpassDependency const& rhs ) const
-    {
-      return ( srcSubpass == rhs.srcSubpass )
-          && ( dstSubpass == rhs.dstSubpass )
-          && ( srcStageMask == rhs.srcStageMask )
-          && ( dstStageMask == rhs.dstStageMask )
-          && ( srcAccessMask == rhs.srcAccessMask )
-          && ( dstAccessMask == rhs.dstAccessMask )
-          && ( dependencyFlags == rhs.dependencyFlags );
-    }
-
-    bool operator!=( SubpassDependency const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t srcSubpass;
-    uint32_t dstSubpass;
-    PipelineStageFlags srcStageMask;
-    PipelineStageFlags dstStageMask;
-    AccessFlags srcAccessMask;
-    AccessFlags dstAccessMask;
-    DependencyFlags dependencyFlags;
-  };
-  static_assert( sizeof( SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" );
-
-  enum class PresentModeKHR
-  {
-    eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR,
-    eMailbox = VK_PRESENT_MODE_MAILBOX_KHR,
-    eFifo = VK_PRESENT_MODE_FIFO_KHR,
-    eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
-    eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR,
-    eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR
-  };
-
-  enum class ColorSpaceKHR
-  {
-    eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
-    eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
-    eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
-    eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
-    eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
-    eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT,
-    eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
-    eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT,
-    eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT,
-    eDolbyvisionEXT = VK_COLOR_SPACE_DOLBYVISION_EXT,
-    eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT,
-    eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
-    eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
-    ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT,
-    eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT
-  };
-
-  struct SurfaceFormatKHR
-  {
-    operator const VkSurfaceFormatKHR&() const
-    {
-      return *reinterpret_cast<const VkSurfaceFormatKHR*>(this);
-    }
-
-    bool operator==( SurfaceFormatKHR const& rhs ) const
-    {
-      return ( format == rhs.format )
-          && ( colorSpace == rhs.colorSpace );
-    }
-
-    bool operator!=( SurfaceFormatKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    Format format;
-    ColorSpaceKHR colorSpace;
-  };
-  static_assert( sizeof( SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceFormat2KHR
-  {
-    operator const VkSurfaceFormat2KHR&() const
-    {
-      return *reinterpret_cast<const VkSurfaceFormat2KHR*>(this);
-    }
-
-    bool operator==( SurfaceFormat2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceFormat == rhs.surfaceFormat );
-    }
-
-    bool operator!=( SurfaceFormat2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceFormat2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceFormatKHR surfaceFormat;
-  };
-  static_assert( sizeof( SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" );
-
-  enum class DisplayPlaneAlphaFlagBitsKHR
-  {
-    eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
-    eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
-    ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
-    ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR
-  };
-
-  using DisplayPlaneAlphaFlagsKHR = Flags<DisplayPlaneAlphaFlagBitsKHR, VkDisplayPlaneAlphaFlagsKHR>;
-
-  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator|( DisplayPlaneAlphaFlagBitsKHR bit0, DisplayPlaneAlphaFlagBitsKHR bit1 )
-  {
-    return DisplayPlaneAlphaFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DisplayPlaneAlphaFlagsKHR operator~( DisplayPlaneAlphaFlagBitsKHR bits )
-  {
-    return ~( DisplayPlaneAlphaFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<DisplayPlaneAlphaFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(DisplayPlaneAlphaFlagBitsKHR::eOpaque) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::eGlobal) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixel) | VkFlags(DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied)
-    };
-  };
-
-  struct DisplayPlaneCapabilitiesKHR
-  {
-    operator const VkDisplayPlaneCapabilitiesKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayPlaneCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPlaneCapabilitiesKHR const& rhs ) const
-    {
-      return ( supportedAlpha == rhs.supportedAlpha )
-          && ( minSrcPosition == rhs.minSrcPosition )
-          && ( maxSrcPosition == rhs.maxSrcPosition )
-          && ( minSrcExtent == rhs.minSrcExtent )
-          && ( maxSrcExtent == rhs.maxSrcExtent )
-          && ( minDstPosition == rhs.minDstPosition )
-          && ( maxDstPosition == rhs.maxDstPosition )
-          && ( minDstExtent == rhs.minDstExtent )
-          && ( maxDstExtent == rhs.maxDstExtent );
-    }
-
-    bool operator!=( DisplayPlaneCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayPlaneAlphaFlagsKHR supportedAlpha;
-    Offset2D minSrcPosition;
-    Offset2D maxSrcPosition;
-    Extent2D minSrcExtent;
-    Extent2D maxSrcExtent;
-    Offset2D minDstPosition;
-    Offset2D maxDstPosition;
-    Extent2D minDstExtent;
-    Extent2D maxDstExtent;
-  };
-  static_assert( sizeof( DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  enum class CompositeAlphaFlagBitsKHR
-  {
-    eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-    ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
-    ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
-    eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR
-  };
-
-  using CompositeAlphaFlagsKHR = Flags<CompositeAlphaFlagBitsKHR, VkCompositeAlphaFlagsKHR>;
-
-  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator|( CompositeAlphaFlagBitsKHR bit0, CompositeAlphaFlagBitsKHR bit1 )
-  {
-    return CompositeAlphaFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE CompositeAlphaFlagsKHR operator~( CompositeAlphaFlagBitsKHR bits )
-  {
-    return ~( CompositeAlphaFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<CompositeAlphaFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(CompositeAlphaFlagBitsKHR::eOpaque) | VkFlags(CompositeAlphaFlagBitsKHR::ePreMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::ePostMultiplied) | VkFlags(CompositeAlphaFlagBitsKHR::eInherit)
-    };
-  };
-
-  enum class SurfaceTransformFlagBitsKHR
-  {
-    eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
-    eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
-    eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
-    eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
-    eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
-    eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
-    eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
-    eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
-    eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR
-  };
-
-  using SurfaceTransformFlagsKHR = Flags<SurfaceTransformFlagBitsKHR, VkSurfaceTransformFlagsKHR>;
-
-  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator|( SurfaceTransformFlagBitsKHR bit0, SurfaceTransformFlagBitsKHR bit1 )
-  {
-    return SurfaceTransformFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SurfaceTransformFlagsKHR operator~( SurfaceTransformFlagBitsKHR bits )
-  {
-    return ~( SurfaceTransformFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<SurfaceTransformFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(SurfaceTransformFlagBitsKHR::eIdentity) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirror) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) | VkFlags(SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) | VkFlags(SurfaceTransformFlagBitsKHR::eInherit)
-    };
-  };
-
-  struct DisplayPropertiesKHR
-  {
-    operator const VkDisplayPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplayPropertiesKHR*>(this);
-    }
-
-    bool operator==( DisplayPropertiesKHR const& rhs ) const
-    {
-      return ( display == rhs.display )
-          && ( displayName == rhs.displayName )
-          && ( physicalDimensions == rhs.physicalDimensions )
-          && ( physicalResolution == rhs.physicalResolution )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( planeReorderPossible == rhs.planeReorderPossible )
-          && ( persistentContent == rhs.persistentContent );
-    }
-
-    bool operator!=( DisplayPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    DisplayKHR display;
-    const char* displayName;
-    Extent2D physicalDimensions;
-    Extent2D physicalResolution;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    Bool32 planeReorderPossible;
-    Bool32 persistentContent;
-  };
-  static_assert( sizeof( DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct DisplaySurfaceCreateInfoKHR
-  {
-    DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = DisplaySurfaceCreateFlagsKHR(), DisplayModeKHR displayMode_ = DisplayModeKHR(), uint32_t planeIndex_ = 0, uint32_t planeStackIndex_ = 0, SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, float globalAlpha_ = 0, DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, Extent2D imageExtent_ = Extent2D() )
-      : flags( flags_ )
-      , displayMode( displayMode_ )
-      , planeIndex( planeIndex_ )
-      , planeStackIndex( planeStackIndex_ )
-      , transform( transform_ )
-      , globalAlpha( globalAlpha_ )
-      , alphaMode( alphaMode_ )
-      , imageExtent( imageExtent_ )
-    {
-    }
-
-    DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
-    }
-
-    DisplaySurfaceCreateInfoKHR& operator=( VkDisplaySurfaceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplaySurfaceCreateInfoKHR ) );
-      return *this;
-    }
-    DisplaySurfaceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setFlags( DisplaySurfaceCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setDisplayMode( DisplayModeKHR displayMode_ )
-    {
-      displayMode = displayMode_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setPlaneIndex( uint32_t planeIndex_ )
-    {
-      planeIndex = planeIndex_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setPlaneStackIndex( uint32_t planeStackIndex_ )
-    {
-      planeStackIndex = planeStackIndex_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setTransform( SurfaceTransformFlagBitsKHR transform_ )
-    {
-      transform = transform_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setGlobalAlpha( float globalAlpha_ )
-    {
-      globalAlpha = globalAlpha_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ )
-    {
-      alphaMode = alphaMode_;
-      return *this;
-    }
-
-    DisplaySurfaceCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    operator const VkDisplaySurfaceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( DisplaySurfaceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( displayMode == rhs.displayMode )
-          && ( planeIndex == rhs.planeIndex )
-          && ( planeStackIndex == rhs.planeStackIndex )
-          && ( transform == rhs.transform )
-          && ( globalAlpha == rhs.globalAlpha )
-          && ( alphaMode == rhs.alphaMode )
-          && ( imageExtent == rhs.imageExtent );
-    }
-
-    bool operator!=( DisplaySurfaceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DisplaySurfaceCreateFlagsKHR flags;
-    DisplayModeKHR displayMode;
-    uint32_t planeIndex;
-    uint32_t planeStackIndex;
-    SurfaceTransformFlagBitsKHR transform;
-    float globalAlpha;
-    DisplayPlaneAlphaFlagBitsKHR alphaMode;
-    Extent2D imageExtent;
-  };
-  static_assert( sizeof( DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceCapabilitiesKHR
-  {
-    operator const VkSurfaceCapabilitiesKHR&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilitiesKHR*>(this);
-    }
-
-    bool operator==( SurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return ( minImageCount == rhs.minImageCount )
-          && ( maxImageCount == rhs.maxImageCount )
-          && ( currentExtent == rhs.currentExtent )
-          && ( minImageExtent == rhs.minImageExtent )
-          && ( maxImageExtent == rhs.maxImageExtent )
-          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( currentTransform == rhs.currentTransform )
-          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
-          && ( supportedUsageFlags == rhs.supportedUsageFlags );
-    }
-
-    bool operator!=( SurfaceCapabilitiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    uint32_t minImageCount;
-    uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
-    uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
-  };
-  static_assert( sizeof( SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), "struct and wrapper have different size!" );
-
-  struct SurfaceCapabilities2KHR
-  {
-    operator const VkSurfaceCapabilities2KHR&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilities2KHR*>(this);
-    }
-
-    bool operator==( SurfaceCapabilities2KHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceCapabilities == rhs.surfaceCapabilities );
-    }
-
-    bool operator!=( SurfaceCapabilities2KHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceCapabilities2KHR;
-
-  public:
-    void* pNext = nullptr;
-    SurfaceCapabilitiesKHR surfaceCapabilities;
-  };
-  static_assert( sizeof( SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), "struct and wrapper have different size!" );
-
-  enum class DebugReportFlagBitsEXT
-  {
-    eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
-    eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT,
-    ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
-    eError = VK_DEBUG_REPORT_ERROR_BIT_EXT,
-    eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT
-  };
-
-  using DebugReportFlagsEXT = Flags<DebugReportFlagBitsEXT, VkDebugReportFlagsEXT>;
-
-  VULKAN_HPP_INLINE DebugReportFlagsEXT operator|( DebugReportFlagBitsEXT bit0, DebugReportFlagBitsEXT bit1 )
-  {
-    return DebugReportFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DebugReportFlagsEXT operator~( DebugReportFlagBitsEXT bits )
-  {
-    return ~( DebugReportFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<DebugReportFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(DebugReportFlagBitsEXT::eInformation) | VkFlags(DebugReportFlagBitsEXT::eWarning) | VkFlags(DebugReportFlagBitsEXT::ePerformanceWarning) | VkFlags(DebugReportFlagBitsEXT::eError) | VkFlags(DebugReportFlagBitsEXT::eDebug)
-    };
-  };
-
-  struct DebugReportCallbackCreateInfoEXT
-  {
-    DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = DebugReportFlagsEXT(), PFN_vkDebugReportCallbackEXT pfnCallback_ = nullptr, void* pUserData_ = nullptr )
-      : flags( flags_ )
-      , pfnCallback( pfnCallback_ )
-      , pUserData( pUserData_ )
-    {
-    }
-
-    DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
-    }
-
-    DebugReportCallbackCreateInfoEXT& operator=( VkDebugReportCallbackCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugReportCallbackCreateInfoEXT ) );
-      return *this;
-    }
-    DebugReportCallbackCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setFlags( DebugReportFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ )
-    {
-      pfnCallback = pfnCallback_;
-      return *this;
-    }
-
-    DebugReportCallbackCreateInfoEXT& setPUserData( void* pUserData_ )
-    {
-      pUserData = pUserData_;
-      return *this;
-    }
-
-    operator const VkDebugReportCallbackCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DebugReportCallbackCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( pfnCallback == rhs.pfnCallback )
-          && ( pUserData == rhs.pUserData );
-    }
-
-    bool operator!=( DebugReportCallbackCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportFlagsEXT flags;
-    PFN_vkDebugReportCallbackEXT pfnCallback;
-    void* pUserData;
-  };
-  static_assert( sizeof( DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DebugReportObjectTypeEXT
-  {
-    eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
-    eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
-    ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
-    eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-    eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
-    eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
-    eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-    eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
-    eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
-    eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
-    eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-    eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
-    eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
-    eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT,
-    eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
-    eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
-    ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT,
-    ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT,
-    eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-    ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
-    eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
-    eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT,
-    eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
-    eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
-    eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT,
-    eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT,
-    eSurfaceKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT,
-    eSwapchainKhr = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-    eDebugReportCallbackExt = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,
-    eDisplayKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT,
-    eDisplayModeKhr = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT,
-    eObjectTableNvx = VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT,
-    eIndirectCommandsLayoutNvx = VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT,
-    eValidationCacheExt = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
-    eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT,
-    eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT
-  };
-
-  struct DebugMarkerObjectNameInfoEXT
-  {
-    DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, const char* pObjectName_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , pObjectName( pObjectName_ )
-    {
-    }
-
-    DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
-    }
-
-    DebugMarkerObjectNameInfoEXT& operator=( VkDebugMarkerObjectNameInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectNameInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerObjectNameInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setObject( uint64_t object_ )
-    {
-      object = object_;
-      return *this;
-    }
-
-    DebugMarkerObjectNameInfoEXT& setPObjectName( const char* pObjectName_ )
-    {
-      pObjectName = pObjectName_;
-      return *this;
-    }
-
-    operator const VkDebugMarkerObjectNameInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerObjectNameInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( object == rhs.object )
-          && ( pObjectName == rhs.pObjectName );
-    }
-
-    bool operator!=( DebugMarkerObjectNameInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    const char* pObjectName;
-  };
-  static_assert( sizeof( DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), "struct and wrapper have different size!" );
-
-  struct DebugMarkerObjectTagInfoEXT
-  {
-    DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, uint64_t object_ = 0, uint64_t tagName_ = 0, size_t tagSize_ = 0, const void* pTag_ = nullptr )
-      : objectType( objectType_ )
-      , object( object_ )
-      , tagName( tagName_ )
-      , tagSize( tagSize_ )
-      , pTag( pTag_ )
-    {
-    }
-
-    DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
-    }
-
-    DebugMarkerObjectTagInfoEXT& operator=( VkDebugMarkerObjectTagInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DebugMarkerObjectTagInfoEXT ) );
-      return *this;
-    }
-    DebugMarkerObjectTagInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setObjectType( DebugReportObjectTypeEXT objectType_ )
-    {
-      objectType = objectType_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setObject( uint64_t object_ )
-    {
-      object = object_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setTagName( uint64_t tagName_ )
-    {
-      tagName = tagName_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setTagSize( size_t tagSize_ )
-    {
-      tagSize = tagSize_;
-      return *this;
-    }
-
-    DebugMarkerObjectTagInfoEXT& setPTag( const void* pTag_ )
-    {
-      pTag = pTag_;
-      return *this;
-    }
-
-    operator const VkDebugMarkerObjectTagInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>(this);
-    }
-
-    bool operator==( DebugMarkerObjectTagInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectType == rhs.objectType )
-          && ( object == rhs.object )
-          && ( tagName == rhs.tagName )
-          && ( tagSize == rhs.tagSize )
-          && ( pTag == rhs.pTag );
-    }
-
-    bool operator!=( DebugMarkerObjectTagInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DebugReportObjectTypeEXT objectType;
-    uint64_t object;
-    uint64_t tagName;
-    size_t tagSize;
-    const void* pTag;
-  };
-  static_assert( sizeof( DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class RasterizationOrderAMD
-  {
-    eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD,
-    eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD
-  };
-
-  struct PipelineRasterizationStateRasterizationOrderAMD
-  {
-    PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict )
-      : rasterizationOrder( rasterizationOrder_ )
-    {
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD& operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationStateRasterizationOrderAMD ) );
-      return *this;
-    }
-    PipelineRasterizationStateRasterizationOrderAMD& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationStateRasterizationOrderAMD& setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ )
-    {
-      rasterizationOrder = rasterizationOrder_;
-      return *this;
-    }
-
-    operator const VkPipelineRasterizationStateRasterizationOrderAMD&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD*>(this);
-    }
-
-    bool operator==( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( rasterizationOrder == rhs.rasterizationOrder );
-    }
-
-    bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD;
-
-  public:
-    const void* pNext = nullptr;
-    RasterizationOrderAMD rasterizationOrder;
-  };
-  static_assert( sizeof( PipelineRasterizationStateRasterizationOrderAMD ) == sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryHandleTypeFlagBitsNV
-  {
-    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,
-    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,
-    eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,
-    eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV
-  };
-
-  using ExternalMemoryHandleTypeFlagsNV = Flags<ExternalMemoryHandleTypeFlagBitsNV, VkExternalMemoryHandleTypeFlagsNV>;
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator|( ExternalMemoryHandleTypeFlagBitsNV bit0, ExternalMemoryHandleTypeFlagBitsNV bit1 )
-  {
-    return ExternalMemoryHandleTypeFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsNV operator~( ExternalMemoryHandleTypeFlagBitsNV bits )
-  {
-    return ~( ExternalMemoryHandleTypeFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) | VkFlags(ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt)
-    };
-  };
-
-  struct ExternalMemoryImageCreateInfoNV
-  {
-    ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
-    }
-
-    ExternalMemoryImageCreateInfoNV& operator=( VkExternalMemoryImageCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoNV ) );
-      return *this;
-    }
-    ExternalMemoryImageCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryImageCreateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExternalMemoryImageCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryImageCreateInfoNV*>(this);
-    }
-
-    bool operator==( ExternalMemoryImageCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryImageCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), "struct and wrapper have different size!" );
-
-  struct ExportMemoryAllocateInfoNV
-  {
-    ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = ExternalMemoryHandleTypeFlagsNV() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
-    }
-
-    ExportMemoryAllocateInfoNV& operator=( VkExportMemoryAllocateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoNV ) );
-      return *this;
-    }
-    ExportMemoryAllocateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryAllocateInfoNV& setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExportMemoryAllocateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryAllocateInfoNV*>(this);
-    }
-
-    bool operator==( ExportMemoryAllocateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportMemoryAllocateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleTypes;
-  };
-  static_assert( sizeof( ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoNV
-  {
-    ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = ExternalMemoryHandleTypeFlagsNV(), HANDLE handle_ = 0 )
-      : handleType( handleType_ )
-      , handle( handle_ )
-    {
-    }
-
-    ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
-    }
-
-    ImportMemoryWin32HandleInfoNV& operator=( VkImportMemoryWin32HandleInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoNV ) );
-      return *this;
-    }
-    ImportMemoryWin32HandleInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoNV& setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoNV& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    operator const VkImportMemoryWin32HandleInfoNV&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoNV*>(this);
-    }
-
-    bool operator==( ImportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle );
-    }
-
-    bool operator!=( ImportMemoryWin32HandleInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsNV handleType;
-    HANDLE handle;
-  };
-  static_assert( sizeof( ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  enum class ExternalMemoryFeatureFlagBitsNV
-  {
-    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,
-    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,
-    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV
-  };
-
-  using ExternalMemoryFeatureFlagsNV = Flags<ExternalMemoryFeatureFlagBitsNV, VkExternalMemoryFeatureFlagsNV>;
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator|( ExternalMemoryFeatureFlagBitsNV bit0, ExternalMemoryFeatureFlagBitsNV bit1 )
-  {
-    return ExternalMemoryFeatureFlagsNV( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsNV operator~( ExternalMemoryFeatureFlagBitsNV bits )
-  {
-    return ~( ExternalMemoryFeatureFlagsNV( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsNV>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsNV::eImportable)
-    };
-  };
-
-  struct ExternalImageFormatPropertiesNV
-  {
-    operator const VkExternalImageFormatPropertiesNV&() const
-    {
-      return *reinterpret_cast<const VkExternalImageFormatPropertiesNV*>(this);
-    }
-
-    bool operator==( ExternalImageFormatPropertiesNV const& rhs ) const
-    {
-      return ( imageFormatProperties == rhs.imageFormatProperties )
-          && ( externalMemoryFeatures == rhs.externalMemoryFeatures )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
-    }
-
-    bool operator!=( ExternalImageFormatPropertiesNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ImageFormatProperties imageFormatProperties;
-    ExternalMemoryFeatureFlagsNV externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
-  };
-  static_assert( sizeof( ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), "struct and wrapper have different size!" );
-
-  enum class ValidationCheckEXT
-  {
-    eAll = VK_VALIDATION_CHECK_ALL_EXT,
-    eShaders = VK_VALIDATION_CHECK_SHADERS_EXT
-  };
-
-  struct ValidationFlagsEXT
-  {
-    ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = 0, ValidationCheckEXT* pDisabledValidationChecks_ = nullptr )
-      : disabledValidationCheckCount( disabledValidationCheckCount_ )
-      , pDisabledValidationChecks( pDisabledValidationChecks_ )
-    {
-    }
-
-    ValidationFlagsEXT( VkValidationFlagsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
-    }
-
-    ValidationFlagsEXT& operator=( VkValidationFlagsEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ValidationFlagsEXT ) );
-      return *this;
-    }
-    ValidationFlagsEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ValidationFlagsEXT& setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ )
-    {
-      disabledValidationCheckCount = disabledValidationCheckCount_;
-      return *this;
-    }
-
-    ValidationFlagsEXT& setPDisabledValidationChecks( ValidationCheckEXT* pDisabledValidationChecks_ )
-    {
-      pDisabledValidationChecks = pDisabledValidationChecks_;
-      return *this;
-    }
-
-    operator const VkValidationFlagsEXT&() const
-    {
-      return *reinterpret_cast<const VkValidationFlagsEXT*>(this);
-    }
-
-    bool operator==( ValidationFlagsEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount )
-          && ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
-    }
-
-    bool operator!=( ValidationFlagsEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eValidationFlagsEXT;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t disabledValidationCheckCount;
-    ValidationCheckEXT* pDisabledValidationChecks;
-  };
-  static_assert( sizeof( ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" );
-
-  enum class IndirectCommandsLayoutUsageFlagBitsNVX
-  {
-    eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,
-    eSparseSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,
-    eEmptyExecutions = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,
-    eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX
-  };
-
-  using IndirectCommandsLayoutUsageFlagsNVX = Flags<IndirectCommandsLayoutUsageFlagBitsNVX, VkIndirectCommandsLayoutUsageFlagsNVX>;
-
-  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator|( IndirectCommandsLayoutUsageFlagBitsNVX bit0, IndirectCommandsLayoutUsageFlagBitsNVX bit1 )
-  {
-    return IndirectCommandsLayoutUsageFlagsNVX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE IndirectCommandsLayoutUsageFlagsNVX operator~( IndirectCommandsLayoutUsageFlagBitsNVX bits )
-  {
-    return ~( IndirectCommandsLayoutUsageFlagsNVX( bits ) );
-  }
-
-  template <> struct FlagTraits<IndirectCommandsLayoutUsageFlagBitsNVX>
-  {
-    enum
-    {
-      allFlags = VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) | VkFlags(IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences)
-    };
-  };
-
-  enum class ObjectEntryUsageFlagBitsNVX
-  {
-    eGraphics = VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,
-    eCompute = VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX
-  };
-
-  using ObjectEntryUsageFlagsNVX = Flags<ObjectEntryUsageFlagBitsNVX, VkObjectEntryUsageFlagsNVX>;
-
-  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator|( ObjectEntryUsageFlagBitsNVX bit0, ObjectEntryUsageFlagBitsNVX bit1 )
-  {
-    return ObjectEntryUsageFlagsNVX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ObjectEntryUsageFlagsNVX operator~( ObjectEntryUsageFlagBitsNVX bits )
-  {
-    return ~( ObjectEntryUsageFlagsNVX( bits ) );
-  }
-
-  template <> struct FlagTraits<ObjectEntryUsageFlagBitsNVX>
-  {
-    enum
-    {
-      allFlags = VkFlags(ObjectEntryUsageFlagBitsNVX::eGraphics) | VkFlags(ObjectEntryUsageFlagBitsNVX::eCompute)
-    };
-  };
-
-  enum class IndirectCommandsTokenTypeNVX
-  {
-    ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
-    eDescriptorSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX,
-    eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX,
-    eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX,
-    ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX,
-    eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX,
-    eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX,
-    eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX
-  };
-
-  struct IndirectCommandsTokenNVX
-  {
-    IndirectCommandsTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, Buffer buffer_ = Buffer(), DeviceSize offset_ = 0 )
-      : tokenType( tokenType_ )
-      , buffer( buffer_ )
-      , offset( offset_ )
-    {
-    }
-
-    IndirectCommandsTokenNVX( VkIndirectCommandsTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
-    }
-
-    IndirectCommandsTokenNVX& operator=( VkIndirectCommandsTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsTokenNVX ) );
-      return *this;
-    }
-    IndirectCommandsTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
-    {
-      tokenType = tokenType_;
-      return *this;
-    }
-
-    IndirectCommandsTokenNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    IndirectCommandsTokenNVX& setOffset( DeviceSize offset_ )
-    {
-      offset = offset_;
-      return *this;
-    }
-
-    operator const VkIndirectCommandsTokenNVX&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsTokenNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsTokenNVX const& rhs ) const
-    {
-      return ( tokenType == rhs.tokenType )
-          && ( buffer == rhs.buffer )
-          && ( offset == rhs.offset );
-    }
-
-    bool operator!=( IndirectCommandsTokenNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    IndirectCommandsTokenTypeNVX tokenType;
-    Buffer buffer;
-    DeviceSize offset;
-  };
-  static_assert( sizeof( IndirectCommandsTokenNVX ) == sizeof( VkIndirectCommandsTokenNVX ), "struct and wrapper have different size!" );
-
-  struct IndirectCommandsLayoutTokenNVX
-  {
-    IndirectCommandsLayoutTokenNVX( IndirectCommandsTokenTypeNVX tokenType_ = IndirectCommandsTokenTypeNVX::ePipeline, uint32_t bindingUnit_ = 0, uint32_t dynamicCount_ = 0, uint32_t divisor_ = 0 )
-      : tokenType( tokenType_ )
-      , bindingUnit( bindingUnit_ )
-      , dynamicCount( dynamicCount_ )
-      , divisor( divisor_ )
-    {
-    }
-
-    IndirectCommandsLayoutTokenNVX( VkIndirectCommandsLayoutTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
-    }
-
-    IndirectCommandsLayoutTokenNVX& operator=( VkIndirectCommandsLayoutTokenNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutTokenNVX ) );
-      return *this;
-    }
-    IndirectCommandsLayoutTokenNVX& setTokenType( IndirectCommandsTokenTypeNVX tokenType_ )
-    {
-      tokenType = tokenType_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setBindingUnit( uint32_t bindingUnit_ )
-    {
-      bindingUnit = bindingUnit_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setDynamicCount( uint32_t dynamicCount_ )
-    {
-      dynamicCount = dynamicCount_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutTokenNVX& setDivisor( uint32_t divisor_ )
-    {
-      divisor = divisor_;
-      return *this;
-    }
-
-    operator const VkIndirectCommandsLayoutTokenNVX&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsLayoutTokenNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsLayoutTokenNVX const& rhs ) const
-    {
-      return ( tokenType == rhs.tokenType )
-          && ( bindingUnit == rhs.bindingUnit )
-          && ( dynamicCount == rhs.dynamicCount )
-          && ( divisor == rhs.divisor );
-    }
-
-    bool operator!=( IndirectCommandsLayoutTokenNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    IndirectCommandsTokenTypeNVX tokenType;
-    uint32_t bindingUnit;
-    uint32_t dynamicCount;
-    uint32_t divisor;
-  };
-  static_assert( sizeof( IndirectCommandsLayoutTokenNVX ) == sizeof( VkIndirectCommandsLayoutTokenNVX ), "struct and wrapper have different size!" );
-
-  struct IndirectCommandsLayoutCreateInfoNVX
-  {
-    IndirectCommandsLayoutCreateInfoNVX( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, IndirectCommandsLayoutUsageFlagsNVX flags_ = IndirectCommandsLayoutUsageFlagsNVX(), uint32_t tokenCount_ = 0, const IndirectCommandsLayoutTokenNVX* pTokens_ = nullptr )
-      : pipelineBindPoint( pipelineBindPoint_ )
-      , flags( flags_ )
-      , tokenCount( tokenCount_ )
-      , pTokens( pTokens_ )
-    {
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& operator=( VkIndirectCommandsLayoutCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( IndirectCommandsLayoutCreateInfoNVX ) );
-      return *this;
-    }
-    IndirectCommandsLayoutCreateInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
-    {
-      pipelineBindPoint = pipelineBindPoint_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setFlags( IndirectCommandsLayoutUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setTokenCount( uint32_t tokenCount_ )
-    {
-      tokenCount = tokenCount_;
-      return *this;
-    }
-
-    IndirectCommandsLayoutCreateInfoNVX& setPTokens( const IndirectCommandsLayoutTokenNVX* pTokens_ )
-    {
-      pTokens = pTokens_;
-      return *this;
-    }
-
-    operator const VkIndirectCommandsLayoutCreateInfoNVX&() const
-    {
-      return *reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>(this);
-    }
-
-    bool operator==( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( flags == rhs.flags )
-          && ( tokenCount == rhs.tokenCount )
-          && ( pTokens == rhs.pTokens );
-    }
-
-    bool operator!=( IndirectCommandsLayoutCreateInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineBindPoint pipelineBindPoint;
-    IndirectCommandsLayoutUsageFlagsNVX flags;
-    uint32_t tokenCount;
-    const IndirectCommandsLayoutTokenNVX* pTokens;
-  };
-  static_assert( sizeof( IndirectCommandsLayoutCreateInfoNVX ) == sizeof( VkIndirectCommandsLayoutCreateInfoNVX ), "struct and wrapper have different size!" );
-
-  enum class ObjectEntryTypeNVX
-  {
-    eDescriptorSet = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
-    ePipeline = VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX,
-    eIndexBuffer = VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX,
-    eVertexBuffer = VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX,
-    ePushConstant = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX
-  };
-
-  struct ObjectTableCreateInfoNVX
-  {
-    ObjectTableCreateInfoNVX( uint32_t objectCount_ = 0, const ObjectEntryTypeNVX* pObjectEntryTypes_ = nullptr, const uint32_t* pObjectEntryCounts_ = nullptr, const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ = nullptr, uint32_t maxUniformBuffersPerDescriptor_ = 0, uint32_t maxStorageBuffersPerDescriptor_ = 0, uint32_t maxStorageImagesPerDescriptor_ = 0, uint32_t maxSampledImagesPerDescriptor_ = 0, uint32_t maxPipelineLayouts_ = 0 )
-      : objectCount( objectCount_ )
-      , pObjectEntryTypes( pObjectEntryTypes_ )
-      , pObjectEntryCounts( pObjectEntryCounts_ )
-      , pObjectEntryUsageFlags( pObjectEntryUsageFlags_ )
-      , maxUniformBuffersPerDescriptor( maxUniformBuffersPerDescriptor_ )
-      , maxStorageBuffersPerDescriptor( maxStorageBuffersPerDescriptor_ )
-      , maxStorageImagesPerDescriptor( maxStorageImagesPerDescriptor_ )
-      , maxSampledImagesPerDescriptor( maxSampledImagesPerDescriptor_ )
-      , maxPipelineLayouts( maxPipelineLayouts_ )
-    {
-    }
-
-    ObjectTableCreateInfoNVX( VkObjectTableCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
-    }
-
-    ObjectTableCreateInfoNVX& operator=( VkObjectTableCreateInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableCreateInfoNVX ) );
-      return *this;
-    }
-    ObjectTableCreateInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setObjectCount( uint32_t objectCount_ )
-    {
-      objectCount = objectCount_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryTypes( const ObjectEntryTypeNVX* pObjectEntryTypes_ )
-    {
-      pObjectEntryTypes = pObjectEntryTypes_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryCounts( const uint32_t* pObjectEntryCounts_ )
-    {
-      pObjectEntryCounts = pObjectEntryCounts_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setPObjectEntryUsageFlags( const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags_ )
-    {
-      pObjectEntryUsageFlags = pObjectEntryUsageFlags_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxUniformBuffersPerDescriptor( uint32_t maxUniformBuffersPerDescriptor_ )
-    {
-      maxUniformBuffersPerDescriptor = maxUniformBuffersPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxStorageBuffersPerDescriptor( uint32_t maxStorageBuffersPerDescriptor_ )
-    {
-      maxStorageBuffersPerDescriptor = maxStorageBuffersPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxStorageImagesPerDescriptor( uint32_t maxStorageImagesPerDescriptor_ )
-    {
-      maxStorageImagesPerDescriptor = maxStorageImagesPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxSampledImagesPerDescriptor( uint32_t maxSampledImagesPerDescriptor_ )
-    {
-      maxSampledImagesPerDescriptor = maxSampledImagesPerDescriptor_;
-      return *this;
-    }
-
-    ObjectTableCreateInfoNVX& setMaxPipelineLayouts( uint32_t maxPipelineLayouts_ )
-    {
-      maxPipelineLayouts = maxPipelineLayouts_;
-      return *this;
-    }
-
-    operator const VkObjectTableCreateInfoNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTableCreateInfoNVX*>(this);
-    }
-
-    bool operator==( ObjectTableCreateInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectCount == rhs.objectCount )
-          && ( pObjectEntryTypes == rhs.pObjectEntryTypes )
-          && ( pObjectEntryCounts == rhs.pObjectEntryCounts )
-          && ( pObjectEntryUsageFlags == rhs.pObjectEntryUsageFlags )
-          && ( maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor )
-          && ( maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor )
-          && ( maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor )
-          && ( maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor )
-          && ( maxPipelineLayouts == rhs.maxPipelineLayouts );
-    }
-
-    bool operator!=( ObjectTableCreateInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eObjectTableCreateInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t objectCount;
-    const ObjectEntryTypeNVX* pObjectEntryTypes;
-    const uint32_t* pObjectEntryCounts;
-    const ObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
-    uint32_t maxUniformBuffersPerDescriptor;
-    uint32_t maxStorageBuffersPerDescriptor;
-    uint32_t maxStorageImagesPerDescriptor;
-    uint32_t maxSampledImagesPerDescriptor;
-    uint32_t maxPipelineLayouts;
-  };
-  static_assert( sizeof( ObjectTableCreateInfoNVX ) == sizeof( VkObjectTableCreateInfoNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableEntryNVX
-  {
-    ObjectTableEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX() )
-      : type( type_ )
-      , flags( flags_ )
-    {
-    }
-
-    ObjectTableEntryNVX( VkObjectTableEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
-    }
-
-    ObjectTableEntryNVX& operator=( VkObjectTableEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableEntryNVX ) );
-      return *this;
-    }
-    ObjectTableEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    operator const VkObjectTableEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTableEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags );
-    }
-
-    bool operator!=( ObjectTableEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-  };
-  static_assert( sizeof( ObjectTableEntryNVX ) == sizeof( VkObjectTableEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTablePipelineEntryNVX
-  {
-    ObjectTablePipelineEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Pipeline pipeline_ = Pipeline() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipeline( pipeline_ )
-    {
-    }
-
-    ObjectTablePipelineEntryNVX( VkObjectTablePipelineEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
-    }
-
-    ObjectTablePipelineEntryNVX& operator=( VkObjectTablePipelineEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePipelineEntryNVX ) );
-      return *this;
-    }
-    ObjectTablePipelineEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTablePipelineEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTablePipelineEntryNVX& setPipeline( Pipeline pipeline_ )
-    {
-      pipeline = pipeline_;
-      return *this;
-    }
-
-    operator const VkObjectTablePipelineEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTablePipelineEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTablePipelineEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipeline == rhs.pipeline );
-    }
-
-    bool operator!=( ObjectTablePipelineEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Pipeline pipeline;
-  };
-  static_assert( sizeof( ObjectTablePipelineEntryNVX ) == sizeof( VkObjectTablePipelineEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableDescriptorSetEntryNVX
-  {
-    ObjectTableDescriptorSetEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), DescriptorSet descriptorSet_ = DescriptorSet() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , descriptorSet( descriptorSet_ )
-    {
-    }
-
-    ObjectTableDescriptorSetEntryNVX( VkObjectTableDescriptorSetEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
-    }
-
-    ObjectTableDescriptorSetEntryNVX& operator=( VkObjectTableDescriptorSetEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableDescriptorSetEntryNVX ) );
-      return *this;
-    }
-    ObjectTableDescriptorSetEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    ObjectTableDescriptorSetEntryNVX& setDescriptorSet( DescriptorSet descriptorSet_ )
-    {
-      descriptorSet = descriptorSet_;
-      return *this;
-    }
-
-    operator const VkObjectTableDescriptorSetEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTableDescriptorSetEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableDescriptorSetEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( descriptorSet == rhs.descriptorSet );
-    }
-
-    bool operator!=( ObjectTableDescriptorSetEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    DescriptorSet descriptorSet;
-  };
-  static_assert( sizeof( ObjectTableDescriptorSetEntryNVX ) == sizeof( VkObjectTableDescriptorSetEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableVertexBufferEntryNVX
-  {
-    ObjectTableVertexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer() )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
-    {
-    }
-
-    ObjectTableVertexBufferEntryNVX( VkObjectTableVertexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
-    }
-
-    ObjectTableVertexBufferEntryNVX& operator=( VkObjectTableVertexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableVertexBufferEntryNVX ) );
-      return *this;
-    }
-    ObjectTableVertexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableVertexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableVertexBufferEntryNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    operator const VkObjectTableVertexBufferEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTableVertexBufferEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableVertexBufferEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer );
-    }
-
-    bool operator!=( ObjectTableVertexBufferEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
-  };
-  static_assert( sizeof( ObjectTableVertexBufferEntryNVX ) == sizeof( VkObjectTableVertexBufferEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTableIndexBufferEntryNVX
-  {
-    ObjectTableIndexBufferEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), Buffer buffer_ = Buffer(), IndexType indexType_ = IndexType::eUint16 )
-      : type( type_ )
-      , flags( flags_ )
-      , buffer( buffer_ )
-      , indexType( indexType_ )
-    {
-    }
-
-    ObjectTableIndexBufferEntryNVX( VkObjectTableIndexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
-    }
-
-    ObjectTableIndexBufferEntryNVX& operator=( VkObjectTableIndexBufferEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTableIndexBufferEntryNVX ) );
-      return *this;
-    }
-    ObjectTableIndexBufferEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setBuffer( Buffer buffer_ )
-    {
-      buffer = buffer_;
-      return *this;
-    }
-
-    ObjectTableIndexBufferEntryNVX& setIndexType( IndexType indexType_ )
-    {
-      indexType = indexType_;
-      return *this;
-    }
-
-    operator const VkObjectTableIndexBufferEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTableIndexBufferEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTableIndexBufferEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( buffer == rhs.buffer )
-          && ( indexType == rhs.indexType );
-    }
-
-    bool operator!=( ObjectTableIndexBufferEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    Buffer buffer;
-    IndexType indexType;
-  };
-  static_assert( sizeof( ObjectTableIndexBufferEntryNVX ) == sizeof( VkObjectTableIndexBufferEntryNVX ), "struct and wrapper have different size!" );
-
-  struct ObjectTablePushConstantEntryNVX
-  {
-    ObjectTablePushConstantEntryNVX( ObjectEntryTypeNVX type_ = ObjectEntryTypeNVX::eDescriptorSet, ObjectEntryUsageFlagsNVX flags_ = ObjectEntryUsageFlagsNVX(), PipelineLayout pipelineLayout_ = PipelineLayout(), ShaderStageFlags stageFlags_ = ShaderStageFlags() )
-      : type( type_ )
-      , flags( flags_ )
-      , pipelineLayout( pipelineLayout_ )
-      , stageFlags( stageFlags_ )
-    {
-    }
-
-    ObjectTablePushConstantEntryNVX( VkObjectTablePushConstantEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
-    }
-
-    ObjectTablePushConstantEntryNVX& operator=( VkObjectTablePushConstantEntryNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ObjectTablePushConstantEntryNVX ) );
-      return *this;
-    }
-    ObjectTablePushConstantEntryNVX& setType( ObjectEntryTypeNVX type_ )
-    {
-      type = type_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setFlags( ObjectEntryUsageFlagsNVX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setPipelineLayout( PipelineLayout pipelineLayout_ )
-    {
-      pipelineLayout = pipelineLayout_;
-      return *this;
-    }
-
-    ObjectTablePushConstantEntryNVX& setStageFlags( ShaderStageFlags stageFlags_ )
-    {
-      stageFlags = stageFlags_;
-      return *this;
-    }
-
-    operator const VkObjectTablePushConstantEntryNVX&() const
-    {
-      return *reinterpret_cast<const VkObjectTablePushConstantEntryNVX*>(this);
-    }
-
-    bool operator==( ObjectTablePushConstantEntryNVX const& rhs ) const
-    {
-      return ( type == rhs.type )
-          && ( flags == rhs.flags )
-          && ( pipelineLayout == rhs.pipelineLayout )
-          && ( stageFlags == rhs.stageFlags );
-    }
-
-    bool operator!=( ObjectTablePushConstantEntryNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ObjectEntryTypeNVX type;
-    ObjectEntryUsageFlagsNVX flags;
-    PipelineLayout pipelineLayout;
-    ShaderStageFlags stageFlags;
-  };
-  static_assert( sizeof( ObjectTablePushConstantEntryNVX ) == sizeof( VkObjectTablePushConstantEntryNVX ), "struct and wrapper have different size!" );
-
-  enum class DescriptorSetLayoutCreateFlagBits
-  {
-    ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR
-  };
-
-  using DescriptorSetLayoutCreateFlags = Flags<DescriptorSetLayoutCreateFlagBits, VkDescriptorSetLayoutCreateFlags>;
-
-  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator|( DescriptorSetLayoutCreateFlagBits bit0, DescriptorSetLayoutCreateFlagBits bit1 )
-  {
-    return DescriptorSetLayoutCreateFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DescriptorSetLayoutCreateFlags operator~( DescriptorSetLayoutCreateFlagBits bits )
-  {
-    return ~( DescriptorSetLayoutCreateFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<DescriptorSetLayoutCreateFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR)
-    };
-  };
-
-  struct DescriptorSetLayoutCreateInfo
-  {
-    DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = DescriptorSetLayoutCreateFlags(), uint32_t bindingCount_ = 0, const DescriptorSetLayoutBinding* pBindings_ = nullptr )
-      : flags( flags_ )
-      , bindingCount( bindingCount_ )
-      , pBindings( pBindings_ )
-    {
-    }
-
-    DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
-    }
-
-    DescriptorSetLayoutCreateInfo& operator=( VkDescriptorSetLayoutCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DescriptorSetLayoutCreateInfo ) );
-      return *this;
-    }
-    DescriptorSetLayoutCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DescriptorSetLayoutCreateInfo& setFlags( DescriptorSetLayoutCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    DescriptorSetLayoutCreateInfo& setBindingCount( uint32_t bindingCount_ )
-    {
-      bindingCount = bindingCount_;
-      return *this;
-    }
-
-    DescriptorSetLayoutCreateInfo& setPBindings( const DescriptorSetLayoutBinding* pBindings_ )
-    {
-      pBindings = pBindings_;
-      return *this;
-    }
-
-    operator const VkDescriptorSetLayoutCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>(this);
-    }
-
-    bool operator==( DescriptorSetLayoutCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( bindingCount == rhs.bindingCount )
-          && ( pBindings == rhs.pBindings );
-    }
-
-    bool operator!=( DescriptorSetLayoutCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    DescriptorSetLayoutCreateFlags flags;
-    uint32_t bindingCount;
-    const DescriptorSetLayoutBinding* pBindings;
-  };
-  static_assert( sizeof( DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryHandleTypeFlagBitsKHR
-  {
-    eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
-    eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
-    eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
-    eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR,
-    eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR,
-    eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR,
-    eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR,
-    eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
-    eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
-    eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT
-  };
-
-  using ExternalMemoryHandleTypeFlagsKHR = Flags<ExternalMemoryHandleTypeFlagBitsKHR, VkExternalMemoryHandleTypeFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator|( ExternalMemoryHandleTypeFlagBitsKHR bit0, ExternalMemoryHandleTypeFlagBitsKHR bit1 )
-  {
-    return ExternalMemoryHandleTypeFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryHandleTypeFlagsKHR operator~( ExternalMemoryHandleTypeFlagBitsKHR bits )
-  {
-    return ~( ExternalMemoryHandleTypeFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryHandleTypeFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) | VkFlags(ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT)
-    };
-  };
-
-  struct PhysicalDeviceExternalImageFormatInfoKHR
-  {
-    PhysicalDeviceExternalImageFormatInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalImageFormatInfoKHR( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) );
-    }
-
-    PhysicalDeviceExternalImageFormatInfoKHR& operator=( VkPhysicalDeviceExternalImageFormatInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) );
-      return *this;
-    }
-    PhysicalDeviceExternalImageFormatInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalImageFormatInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceExternalImageFormatInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfoKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalImageFormatInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalImageFormatInfoKHR ) == sizeof( VkPhysicalDeviceExternalImageFormatInfoKHR ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceExternalBufferInfoKHR
-  {
-    PhysicalDeviceExternalBufferInfoKHR( BufferCreateFlags flags_ = BufferCreateFlags(), BufferUsageFlags usage_ = BufferUsageFlags(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : flags( flags_ )
-      , usage( usage_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalBufferInfoKHR( VkPhysicalDeviceExternalBufferInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) );
-    }
-
-    PhysicalDeviceExternalBufferInfoKHR& operator=( VkPhysicalDeviceExternalBufferInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalBufferInfoKHR ) );
-      return *this;
-    }
-    PhysicalDeviceExternalBufferInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfoKHR& setFlags( BufferCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfoKHR& setUsage( BufferUsageFlags usage_ )
-    {
-      usage = usage_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalBufferInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceExternalBufferInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( usage == rhs.usage )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalBufferInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    BufferCreateFlags flags;
-    BufferUsageFlags usage;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalBufferInfoKHR ) == sizeof( VkPhysicalDeviceExternalBufferInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ExternalMemoryImageCreateInfoKHR
-  {
-    ExternalMemoryImageCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryImageCreateInfoKHR( VkExternalMemoryImageCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) );
-    }
-
-    ExternalMemoryImageCreateInfoKHR& operator=( VkExternalMemoryImageCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryImageCreateInfoKHR ) );
-      return *this;
-    }
-    ExternalMemoryImageCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryImageCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExternalMemoryImageCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryImageCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ExternalMemoryImageCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryImageCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryImageCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsKHR handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryImageCreateInfoKHR ) == sizeof( VkExternalMemoryImageCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ExternalMemoryBufferCreateInfoKHR
-  {
-    ExternalMemoryBufferCreateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExternalMemoryBufferCreateInfoKHR( VkExternalMemoryBufferCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) );
-    }
-
-    ExternalMemoryBufferCreateInfoKHR& operator=( VkExternalMemoryBufferCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExternalMemoryBufferCreateInfoKHR ) );
-      return *this;
-    }
-    ExternalMemoryBufferCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExternalMemoryBufferCreateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExternalMemoryBufferCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryBufferCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ExternalMemoryBufferCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExternalMemoryBufferCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalMemoryBufferCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsKHR handleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryBufferCreateInfoKHR ) == sizeof( VkExternalMemoryBufferCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ExportMemoryAllocateInfoKHR
-  {
-    ExportMemoryAllocateInfoKHR( ExternalMemoryHandleTypeFlagsKHR handleTypes_ = ExternalMemoryHandleTypeFlagsKHR() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportMemoryAllocateInfoKHR( VkExportMemoryAllocateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) );
-    }
-
-    ExportMemoryAllocateInfoKHR& operator=( VkExportMemoryAllocateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportMemoryAllocateInfoKHR ) );
-      return *this;
-    }
-    ExportMemoryAllocateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportMemoryAllocateInfoKHR& setHandleTypes( ExternalMemoryHandleTypeFlagsKHR handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExportMemoryAllocateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportMemoryAllocateInfoKHR*>(this);
-    }
-
-    bool operator==( ExportMemoryAllocateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportMemoryAllocateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportMemoryAllocateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagsKHR handleTypes;
-  };
-  static_assert( sizeof( ExportMemoryAllocateInfoKHR ) == sizeof( VkExportMemoryAllocateInfoKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportMemoryWin32HandleInfoKHR
-  {
-    ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
-    }
-
-    ImportMemoryWin32HandleInfoKHR& operator=( VkImportMemoryWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportMemoryWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportMemoryWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkImportMemoryWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportMemoryWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct MemoryGetWin32HandleInfoKHR
-  {
-    MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
-    }
-
-    MemoryGetWin32HandleInfoKHR& operator=( VkMemoryGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    MemoryGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryGetWin32HandleInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    MemoryGetWin32HandleInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkMemoryGetWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( MemoryGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( MemoryGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportMemoryFdInfoKHR
-  {
-    ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
-    }
-
-    ImportMemoryFdInfoKHR& operator=( VkImportMemoryFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryFdInfoKHR ) );
-      return *this;
-    }
-    ImportMemoryFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator const VkImportMemoryFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportMemoryFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportMemoryFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), "struct and wrapper have different size!" );
-
-  struct MemoryGetFdInfoKHR
-  {
-    MemoryGetFdInfoKHR( DeviceMemory memory_ = DeviceMemory(), ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd )
-      : memory( memory_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
-    }
-
-    MemoryGetFdInfoKHR& operator=( VkMemoryGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryGetFdInfoKHR ) );
-      return *this;
-    }
-    MemoryGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryGetFdInfoKHR& setMemory( DeviceMemory memory_ )
-    {
-      memory = memory_;
-      return *this;
-    }
-
-    MemoryGetFdInfoKHR& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkMemoryGetFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkMemoryGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( MemoryGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memory == rhs.memory )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( MemoryGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceMemory memory;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ImportMemoryHostPointerInfoEXT
-  {
-    ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType_ = ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd, void* pHostPointer_ = nullptr )
-      : handleType( handleType_ )
-      , pHostPointer( pHostPointer_ )
-    {
-    }
-
-    ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
-    }
-
-    ImportMemoryHostPointerInfoEXT& operator=( VkImportMemoryHostPointerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportMemoryHostPointerInfoEXT ) );
-      return *this;
-    }
-    ImportMemoryHostPointerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportMemoryHostPointerInfoEXT& setHandleType( ExternalMemoryHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportMemoryHostPointerInfoEXT& setPHostPointer( void* pHostPointer_ )
-    {
-      pHostPointer = pHostPointer_;
-      return *this;
-    }
-
-    operator const VkImportMemoryHostPointerInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkImportMemoryHostPointerInfoEXT*>(this);
-    }
-
-    bool operator==( ImportMemoryHostPointerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType )
-          && ( pHostPointer == rhs.pHostPointer );
-    }
-
-    bool operator!=( ImportMemoryHostPointerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalMemoryHandleTypeFlagBitsKHR handleType;
-    void* pHostPointer;
-  };
-  static_assert( sizeof( ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class ExternalMemoryFeatureFlagBitsKHR
-  {
-    eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR,
-    eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR,
-    eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR
-  };
-
-  using ExternalMemoryFeatureFlagsKHR = Flags<ExternalMemoryFeatureFlagBitsKHR, VkExternalMemoryFeatureFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator|( ExternalMemoryFeatureFlagBitsKHR bit0, ExternalMemoryFeatureFlagBitsKHR bit1 )
-  {
-    return ExternalMemoryFeatureFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalMemoryFeatureFlagsKHR operator~( ExternalMemoryFeatureFlagBitsKHR bits )
-  {
-    return ~( ExternalMemoryFeatureFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalMemoryFeatureFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalMemoryFeatureFlagBitsKHR::eImportable)
-    };
-  };
-
-  struct ExternalMemoryPropertiesKHR
-  {
-    operator const VkExternalMemoryPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalMemoryPropertiesKHR*>(this);
-    }
-
-    bool operator==( ExternalMemoryPropertiesKHR const& rhs ) const
-    {
-      return ( externalMemoryFeatures == rhs.externalMemoryFeatures )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes );
-    }
-
-    bool operator!=( ExternalMemoryPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ExternalMemoryFeatureFlagsKHR externalMemoryFeatures;
-    ExternalMemoryHandleTypeFlagsKHR exportFromImportedHandleTypes;
-    ExternalMemoryHandleTypeFlagsKHR compatibleHandleTypes;
-  };
-  static_assert( sizeof( ExternalMemoryPropertiesKHR ) == sizeof( VkExternalMemoryPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct ExternalImageFormatPropertiesKHR
-  {
-    operator const VkExternalImageFormatPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalImageFormatPropertiesKHR*>(this);
-    }
-
-    bool operator==( ExternalImageFormatPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( externalMemoryProperties == rhs.externalMemoryProperties );
-    }
-
-    bool operator!=( ExternalImageFormatPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalImageFormatPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryPropertiesKHR externalMemoryProperties;
-  };
-  static_assert( sizeof( ExternalImageFormatPropertiesKHR ) == sizeof( VkExternalImageFormatPropertiesKHR ), "struct and wrapper have different size!" );
-
-  struct ExternalBufferPropertiesKHR
-  {
-    operator const VkExternalBufferPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalBufferPropertiesKHR*>(this);
-    }
-
-    bool operator==( ExternalBufferPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( externalMemoryProperties == rhs.externalMemoryProperties );
-    }
-
-    bool operator!=( ExternalBufferPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalBufferPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ExternalMemoryPropertiesKHR externalMemoryProperties;
-  };
-  static_assert( sizeof( ExternalBufferPropertiesKHR ) == sizeof( VkExternalBufferPropertiesKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalSemaphoreHandleTypeFlagBitsKHR
-  {
-    eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
-    eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
-    eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
-    eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR,
-    eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
-  };
-
-  using ExternalSemaphoreHandleTypeFlagsKHR = Flags<ExternalSemaphoreHandleTypeFlagBitsKHR, VkExternalSemaphoreHandleTypeFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator|( ExternalSemaphoreHandleTypeFlagBitsKHR bit0, ExternalSemaphoreHandleTypeFlagBitsKHR bit1 )
-  {
-    return ExternalSemaphoreHandleTypeFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalSemaphoreHandleTypeFlagsKHR operator~( ExternalSemaphoreHandleTypeFlagBitsKHR bits )
-  {
-    return ~( ExternalSemaphoreHandleTypeFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalSemaphoreHandleTypeFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) | VkFlags(ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd)
-    };
-  };
-
-  struct PhysicalDeviceExternalSemaphoreInfoKHR
-  {
-    PhysicalDeviceExternalSemaphoreInfoKHR( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalSemaphoreInfoKHR( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) );
-    }
-
-    PhysicalDeviceExternalSemaphoreInfoKHR& operator=( VkPhysicalDeviceExternalSemaphoreInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) );
-      return *this;
-    }
-    PhysicalDeviceExternalSemaphoreInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalSemaphoreInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceExternalSemaphoreInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalSemaphoreInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalSemaphoreInfoKHR ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ExportSemaphoreCreateInfoKHR
-  {
-    ExportSemaphoreCreateInfoKHR( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ = ExternalSemaphoreHandleTypeFlagsKHR() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportSemaphoreCreateInfoKHR( VkExportSemaphoreCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) );
-    }
-
-    ExportSemaphoreCreateInfoKHR& operator=( VkExportSemaphoreCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportSemaphoreCreateInfoKHR ) );
-      return *this;
-    }
-    ExportSemaphoreCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportSemaphoreCreateInfoKHR& setHandleTypes( ExternalSemaphoreHandleTypeFlagsKHR handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExportSemaphoreCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportSemaphoreCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ExportSemaphoreCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportSemaphoreCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportSemaphoreCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlagsKHR handleTypes;
-  };
-  static_assert( sizeof( ExportSemaphoreCreateInfoKHR ) == sizeof( VkExportSemaphoreCreateInfoKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct SemaphoreGetWin32HandleInfoKHR
-  {
-    SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    SemaphoreGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    SemaphoreGetWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkSemaphoreGetWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( SemaphoreGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct SemaphoreGetFdInfoKHR
-  {
-    SemaphoreGetFdInfoKHR( Semaphore semaphore_ = Semaphore(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd )
-      : semaphore( semaphore_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
-    }
-
-    SemaphoreGetFdInfoKHR& operator=( VkSemaphoreGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SemaphoreGetFdInfoKHR ) );
-      return *this;
-    }
-    SemaphoreGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SemaphoreGetFdInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    SemaphoreGetFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkSemaphoreGetFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( SemaphoreGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( SemaphoreGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSemaphoreGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalSemaphoreFeatureFlagBitsKHR
-  {
-    eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR,
-    eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR
-  };
-
-  using ExternalSemaphoreFeatureFlagsKHR = Flags<ExternalSemaphoreFeatureFlagBitsKHR, VkExternalSemaphoreFeatureFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator|( ExternalSemaphoreFeatureFlagBitsKHR bit0, ExternalSemaphoreFeatureFlagBitsKHR bit1 )
-  {
-    return ExternalSemaphoreFeatureFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalSemaphoreFeatureFlagsKHR operator~( ExternalSemaphoreFeatureFlagBitsKHR bits )
-  {
-    return ~( ExternalSemaphoreFeatureFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalSemaphoreFeatureFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalSemaphoreFeatureFlagBitsKHR::eImportable)
-    };
-  };
-
-  struct ExternalSemaphorePropertiesKHR
-  {
-    operator const VkExternalSemaphorePropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalSemaphorePropertiesKHR*>(this);
-    }
-
-    bool operator==( ExternalSemaphorePropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
-          && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
-    }
-
-    bool operator!=( ExternalSemaphorePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalSemaphorePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ExternalSemaphoreHandleTypeFlagsKHR exportFromImportedHandleTypes;
-    ExternalSemaphoreHandleTypeFlagsKHR compatibleHandleTypes;
-    ExternalSemaphoreFeatureFlagsKHR externalSemaphoreFeatures;
-  };
-  static_assert( sizeof( ExternalSemaphorePropertiesKHR ) == sizeof( VkExternalSemaphorePropertiesKHR ), "struct and wrapper have different size!" );
-
-  enum class SemaphoreImportFlagBitsKHR
-  {
-    eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR
-  };
-
-  using SemaphoreImportFlagsKHR = Flags<SemaphoreImportFlagBitsKHR, VkSemaphoreImportFlagsKHR>;
-
-  VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator|( SemaphoreImportFlagBitsKHR bit0, SemaphoreImportFlagBitsKHR bit1 )
-  {
-    return SemaphoreImportFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SemaphoreImportFlagsKHR operator~( SemaphoreImportFlagBitsKHR bits )
-  {
-    return ~( SemaphoreImportFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<SemaphoreImportFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(SemaphoreImportFlagBitsKHR::eTemporary)
-    };
-  };
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportSemaphoreWin32HandleInfoKHR
-  {
-    ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportSemaphoreWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportSemaphoreWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkImportSemaphoreWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportSemaphoreWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlagsKHR flags;
-    ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportSemaphoreFdInfoKHR
-  {
-    ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = Semaphore(), SemaphoreImportFlagsKHR flags_ = SemaphoreImportFlagsKHR(), ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ = ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : semaphore( semaphore_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
-    }
-
-    ImportSemaphoreFdInfoKHR& operator=( VkImportSemaphoreFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportSemaphoreFdInfoKHR ) );
-      return *this;
-    }
-    ImportSemaphoreFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setSemaphore( Semaphore semaphore_ )
-    {
-      semaphore = semaphore_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setFlags( SemaphoreImportFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setHandleType( ExternalSemaphoreHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportSemaphoreFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator const VkImportSemaphoreFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportSemaphoreFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( semaphore == rhs.semaphore )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportSemaphoreFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportSemaphoreFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Semaphore semaphore;
-    SemaphoreImportFlagsKHR flags;
-    ExternalSemaphoreHandleTypeFlagBitsKHR handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalFenceHandleTypeFlagBitsKHR
-  {
-    eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
-    eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
-    eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
-    eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
-  };
-
-  using ExternalFenceHandleTypeFlagsKHR = Flags<ExternalFenceHandleTypeFlagBitsKHR, VkExternalFenceHandleTypeFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator|( ExternalFenceHandleTypeFlagBitsKHR bit0, ExternalFenceHandleTypeFlagBitsKHR bit1 )
-  {
-    return ExternalFenceHandleTypeFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalFenceHandleTypeFlagsKHR operator~( ExternalFenceHandleTypeFlagBitsKHR bits )
-  {
-    return ~( ExternalFenceHandleTypeFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalFenceHandleTypeFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) | VkFlags(ExternalFenceHandleTypeFlagBitsKHR::eSyncFd)
-    };
-  };
-
-  struct PhysicalDeviceExternalFenceInfoKHR
-  {
-    PhysicalDeviceExternalFenceInfoKHR( ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : handleType( handleType_ )
-    {
-    }
-
-    PhysicalDeviceExternalFenceInfoKHR( VkPhysicalDeviceExternalFenceInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) );
-    }
-
-    PhysicalDeviceExternalFenceInfoKHR& operator=( VkPhysicalDeviceExternalFenceInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PhysicalDeviceExternalFenceInfoKHR ) );
-      return *this;
-    }
-    PhysicalDeviceExternalFenceInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PhysicalDeviceExternalFenceInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkPhysicalDeviceExternalFenceInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>(this);
-    }
-
-    bool operator==( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( PhysicalDeviceExternalFenceInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( PhysicalDeviceExternalFenceInfoKHR ) == sizeof( VkPhysicalDeviceExternalFenceInfoKHR ), "struct and wrapper have different size!" );
-
-  struct ExportFenceCreateInfoKHR
-  {
-    ExportFenceCreateInfoKHR( ExternalFenceHandleTypeFlagsKHR handleTypes_ = ExternalFenceHandleTypeFlagsKHR() )
-      : handleTypes( handleTypes_ )
-    {
-    }
-
-    ExportFenceCreateInfoKHR( VkExportFenceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) );
-    }
-
-    ExportFenceCreateInfoKHR& operator=( VkExportFenceCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ExportFenceCreateInfoKHR ) );
-      return *this;
-    }
-    ExportFenceCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ExportFenceCreateInfoKHR& setHandleTypes( ExternalFenceHandleTypeFlagsKHR handleTypes_ )
-    {
-      handleTypes = handleTypes_;
-      return *this;
-    }
-
-    operator const VkExportFenceCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkExportFenceCreateInfoKHR*>(this);
-    }
-
-    bool operator==( ExportFenceCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( handleTypes == rhs.handleTypes );
-    }
-
-    bool operator!=( ExportFenceCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExportFenceCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    ExternalFenceHandleTypeFlagsKHR handleTypes;
-  };
-  static_assert( sizeof( ExportFenceCreateInfoKHR ) == sizeof( VkExportFenceCreateInfoKHR ), "struct and wrapper have different size!" );
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct FenceGetWin32HandleInfoKHR
-  {
-    FenceGetWin32HandleInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
-    }
-
-    FenceGetWin32HandleInfoKHR& operator=( VkFenceGetWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetWin32HandleInfoKHR ) );
-      return *this;
-    }
-    FenceGetWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceGetWin32HandleInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    FenceGetWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkFenceGetWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( FenceGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( FenceGetWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct FenceGetFdInfoKHR
-  {
-    FenceGetFdInfoKHR( Fence fence_ = Fence(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd )
-      : fence( fence_ )
-      , handleType( handleType_ )
-    {
-    }
-
-    FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
-    }
-
-    FenceGetFdInfoKHR& operator=( VkFenceGetFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( FenceGetFdInfoKHR ) );
-      return *this;
-    }
-    FenceGetFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    FenceGetFdInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    FenceGetFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    operator const VkFenceGetFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkFenceGetFdInfoKHR*>(this);
-    }
-
-    bool operator==( FenceGetFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( handleType == rhs.handleType );
-    }
-
-    bool operator!=( FenceGetFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eFenceGetFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    ExternalFenceHandleTypeFlagBitsKHR handleType;
-  };
-  static_assert( sizeof( FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ExternalFenceFeatureFlagBitsKHR
-  {
-    eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR,
-    eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR
-  };
-
-  using ExternalFenceFeatureFlagsKHR = Flags<ExternalFenceFeatureFlagBitsKHR, VkExternalFenceFeatureFlagsKHR>;
-
-  VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator|( ExternalFenceFeatureFlagBitsKHR bit0, ExternalFenceFeatureFlagBitsKHR bit1 )
-  {
-    return ExternalFenceFeatureFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE ExternalFenceFeatureFlagsKHR operator~( ExternalFenceFeatureFlagBitsKHR bits )
-  {
-    return ~( ExternalFenceFeatureFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<ExternalFenceFeatureFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(ExternalFenceFeatureFlagBitsKHR::eExportable) | VkFlags(ExternalFenceFeatureFlagBitsKHR::eImportable)
-    };
-  };
-
-  struct ExternalFencePropertiesKHR
-  {
-    operator const VkExternalFencePropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkExternalFencePropertiesKHR*>(this);
-    }
-
-    bool operator==( ExternalFencePropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes )
-          && ( compatibleHandleTypes == rhs.compatibleHandleTypes )
-          && ( externalFenceFeatures == rhs.externalFenceFeatures );
-    }
-
-    bool operator!=( ExternalFencePropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eExternalFencePropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    ExternalFenceHandleTypeFlagsKHR exportFromImportedHandleTypes;
-    ExternalFenceHandleTypeFlagsKHR compatibleHandleTypes;
-    ExternalFenceFeatureFlagsKHR externalFenceFeatures;
-  };
-  static_assert( sizeof( ExternalFencePropertiesKHR ) == sizeof( VkExternalFencePropertiesKHR ), "struct and wrapper have different size!" );
-
-  enum class FenceImportFlagBitsKHR
-  {
-    eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT_KHR
-  };
-
-  using FenceImportFlagsKHR = Flags<FenceImportFlagBitsKHR, VkFenceImportFlagsKHR>;
-
-  VULKAN_HPP_INLINE FenceImportFlagsKHR operator|( FenceImportFlagBitsKHR bit0, FenceImportFlagBitsKHR bit1 )
-  {
-    return FenceImportFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE FenceImportFlagsKHR operator~( FenceImportFlagBitsKHR bits )
-  {
-    return ~( FenceImportFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<FenceImportFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(FenceImportFlagBitsKHR::eTemporary)
-    };
-  };
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  struct ImportFenceWin32HandleInfoKHR
-  {
-    ImportFenceWin32HandleInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, HANDLE handle_ = 0, LPCWSTR name_ = 0 )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , handle( handle_ )
-      , name( name_ )
-    {
-    }
-
-    ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
-    }
-
-    ImportFenceWin32HandleInfoKHR& operator=( VkImportFenceWin32HandleInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceWin32HandleInfoKHR ) );
-      return *this;
-    }
-    ImportFenceWin32HandleInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setFlags( FenceImportFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setHandle( HANDLE handle_ )
-    {
-      handle = handle_;
-      return *this;
-    }
-
-    ImportFenceWin32HandleInfoKHR& setName( LPCWSTR name_ )
-    {
-      name = name_;
-      return *this;
-    }
-
-    operator const VkImportFenceWin32HandleInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>(this);
-    }
-
-    bool operator==( ImportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( handle == rhs.handle )
-          && ( name == rhs.name );
-    }
-
-    bool operator!=( ImportFenceWin32HandleInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlagsKHR flags;
-    ExternalFenceHandleTypeFlagBitsKHR handleType;
-    HANDLE handle;
-    LPCWSTR name;
-  };
-  static_assert( sizeof( ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), "struct and wrapper have different size!" );
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  struct ImportFenceFdInfoKHR
-  {
-    ImportFenceFdInfoKHR( Fence fence_ = Fence(), FenceImportFlagsKHR flags_ = FenceImportFlagsKHR(), ExternalFenceHandleTypeFlagBitsKHR handleType_ = ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd, int fd_ = 0 )
-      : fence( fence_ )
-      , flags( flags_ )
-      , handleType( handleType_ )
-      , fd( fd_ )
-    {
-    }
-
-    ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
-    }
-
-    ImportFenceFdInfoKHR& operator=( VkImportFenceFdInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ImportFenceFdInfoKHR ) );
-      return *this;
-    }
-    ImportFenceFdInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFence( Fence fence_ )
-    {
-      fence = fence_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFlags( FenceImportFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setHandleType( ExternalFenceHandleTypeFlagBitsKHR handleType_ )
-    {
-      handleType = handleType_;
-      return *this;
-    }
-
-    ImportFenceFdInfoKHR& setFd( int fd_ )
-    {
-      fd = fd_;
-      return *this;
-    }
-
-    operator const VkImportFenceFdInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkImportFenceFdInfoKHR*>(this);
-    }
-
-    bool operator==( ImportFenceFdInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( fence == rhs.fence )
-          && ( flags == rhs.flags )
-          && ( handleType == rhs.handleType )
-          && ( fd == rhs.fd );
-    }
-
-    bool operator!=( ImportFenceFdInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eImportFenceFdInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Fence fence;
-    FenceImportFlagsKHR flags;
-    ExternalFenceHandleTypeFlagBitsKHR handleType;
-    int fd;
-  };
-  static_assert( sizeof( ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class SurfaceCounterFlagBitsEXT
-  {
-    eVblank = VK_SURFACE_COUNTER_VBLANK_EXT
-  };
-
-  using SurfaceCounterFlagsEXT = Flags<SurfaceCounterFlagBitsEXT, VkSurfaceCounterFlagsEXT>;
-
-  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator|( SurfaceCounterFlagBitsEXT bit0, SurfaceCounterFlagBitsEXT bit1 )
-  {
-    return SurfaceCounterFlagsEXT( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SurfaceCounterFlagsEXT operator~( SurfaceCounterFlagBitsEXT bits )
-  {
-    return ~( SurfaceCounterFlagsEXT( bits ) );
-  }
-
-  template <> struct FlagTraits<SurfaceCounterFlagBitsEXT>
-  {
-    enum
-    {
-      allFlags = VkFlags(SurfaceCounterFlagBitsEXT::eVblank)
-    };
-  };
-
-  struct SurfaceCapabilities2EXT
-  {
-    operator const VkSurfaceCapabilities2EXT&() const
-    {
-      return *reinterpret_cast<const VkSurfaceCapabilities2EXT*>(this);
-    }
-
-    bool operator==( SurfaceCapabilities2EXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( minImageCount == rhs.minImageCount )
-          && ( maxImageCount == rhs.maxImageCount )
-          && ( currentExtent == rhs.currentExtent )
-          && ( minImageExtent == rhs.minImageExtent )
-          && ( maxImageExtent == rhs.maxImageExtent )
-          && ( maxImageArrayLayers == rhs.maxImageArrayLayers )
-          && ( supportedTransforms == rhs.supportedTransforms )
-          && ( currentTransform == rhs.currentTransform )
-          && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha )
-          && ( supportedUsageFlags == rhs.supportedUsageFlags )
-          && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
-    }
-
-    bool operator!=( SurfaceCapabilities2EXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSurfaceCapabilities2EXT;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t minImageCount;
-    uint32_t maxImageCount;
-    Extent2D currentExtent;
-    Extent2D minImageExtent;
-    Extent2D maxImageExtent;
-    uint32_t maxImageArrayLayers;
-    SurfaceTransformFlagsKHR supportedTransforms;
-    SurfaceTransformFlagBitsKHR currentTransform;
-    CompositeAlphaFlagsKHR supportedCompositeAlpha;
-    ImageUsageFlags supportedUsageFlags;
-    SurfaceCounterFlagsEXT supportedSurfaceCounters;
-  };
-  static_assert( sizeof( SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), "struct and wrapper have different size!" );
-
-  struct SwapchainCounterCreateInfoEXT
-  {
-    SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = SurfaceCounterFlagsEXT() )
-      : surfaceCounters( surfaceCounters_ )
-    {
-    }
-
-    SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
-    }
-
-    SwapchainCounterCreateInfoEXT& operator=( VkSwapchainCounterCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCounterCreateInfoEXT ) );
-      return *this;
-    }
-    SwapchainCounterCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SwapchainCounterCreateInfoEXT& setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ )
-    {
-      surfaceCounters = surfaceCounters_;
-      return *this;
-    }
-
-    operator const VkSwapchainCounterCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkSwapchainCounterCreateInfoEXT*>(this);
-    }
-
-    bool operator==( SwapchainCounterCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( surfaceCounters == rhs.surfaceCounters );
-    }
-
-    bool operator!=( SwapchainCounterCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SurfaceCounterFlagsEXT surfaceCounters;
-  };
-  static_assert( sizeof( SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DisplayPowerStateEXT
-  {
-    eOff = VK_DISPLAY_POWER_STATE_OFF_EXT,
-    eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT,
-    eOn = VK_DISPLAY_POWER_STATE_ON_EXT
-  };
-
-  struct DisplayPowerInfoEXT
-  {
-    DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff )
-      : powerState( powerState_ )
-    {
-    }
-
-    DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
-    }
-
-    DisplayPowerInfoEXT& operator=( VkDisplayPowerInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayPowerInfoEXT ) );
-      return *this;
-    }
-    DisplayPowerInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayPowerInfoEXT& setPowerState( DisplayPowerStateEXT powerState_ )
-    {
-      powerState = powerState_;
-      return *this;
-    }
-
-    operator const VkDisplayPowerInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDisplayPowerInfoEXT*>(this);
-    }
-
-    bool operator==( DisplayPowerInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( powerState == rhs.powerState );
-    }
-
-    bool operator!=( DisplayPowerInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayPowerInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayPowerStateEXT powerState;
-  };
-  static_assert( sizeof( DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DeviceEventTypeEXT
-  {
-    eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT
-  };
-
-  struct DeviceEventInfoEXT
-  {
-    DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug )
-      : deviceEvent( deviceEvent_ )
-    {
-    }
-
-    DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
-    }
-
-    DeviceEventInfoEXT& operator=( VkDeviceEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceEventInfoEXT ) );
-      return *this;
-    }
-    DeviceEventInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceEventInfoEXT& setDeviceEvent( DeviceEventTypeEXT deviceEvent_ )
-    {
-      deviceEvent = deviceEvent_;
-      return *this;
-    }
-
-    operator const VkDeviceEventInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDeviceEventInfoEXT*>(this);
-    }
-
-    bool operator==( DeviceEventInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( deviceEvent == rhs.deviceEvent );
-    }
-
-    bool operator!=( DeviceEventInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceEventTypeEXT deviceEvent;
-  };
-  static_assert( sizeof( DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class DisplayEventTypeEXT
-  {
-    eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT
-  };
-
-  struct DisplayEventInfoEXT
-  {
-    DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut )
-      : displayEvent( displayEvent_ )
-    {
-    }
-
-    DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
-    }
-
-    DisplayEventInfoEXT& operator=( VkDisplayEventInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DisplayEventInfoEXT ) );
-      return *this;
-    }
-    DisplayEventInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DisplayEventInfoEXT& setDisplayEvent( DisplayEventTypeEXT displayEvent_ )
-    {
-      displayEvent = displayEvent_;
-      return *this;
-    }
-
-    operator const VkDisplayEventInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDisplayEventInfoEXT*>(this);
-    }
-
-    bool operator==( DisplayEventInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( displayEvent == rhs.displayEvent );
-    }
-
-    bool operator!=( DisplayEventInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDisplayEventInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    DisplayEventTypeEXT displayEvent;
-  };
-  static_assert( sizeof( DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class PeerMemoryFeatureFlagBitsKHX
-  {
-    eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHX,
-    eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHX,
-    eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHX,
-    eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHX
-  };
-
-  using PeerMemoryFeatureFlagsKHX = Flags<PeerMemoryFeatureFlagBitsKHX, VkPeerMemoryFeatureFlagsKHX>;
-
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator|( PeerMemoryFeatureFlagBitsKHX bit0, PeerMemoryFeatureFlagBitsKHX bit1 )
-  {
-    return PeerMemoryFeatureFlagsKHX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX operator~( PeerMemoryFeatureFlagBitsKHX bits )
-  {
-    return ~( PeerMemoryFeatureFlagsKHX( bits ) );
-  }
-
-  template <> struct FlagTraits<PeerMemoryFeatureFlagBitsKHX>
-  {
-    enum
-    {
-      allFlags = VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopySrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eCopyDst) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericSrc) | VkFlags(PeerMemoryFeatureFlagBitsKHX::eGenericDst)
-    };
-  };
-
-  enum class MemoryAllocateFlagBitsKHX
-  {
-    eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHX
-  };
-
-  using MemoryAllocateFlagsKHX = Flags<MemoryAllocateFlagBitsKHX, VkMemoryAllocateFlagsKHX>;
-
-  VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator|( MemoryAllocateFlagBitsKHX bit0, MemoryAllocateFlagBitsKHX bit1 )
-  {
-    return MemoryAllocateFlagsKHX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE MemoryAllocateFlagsKHX operator~( MemoryAllocateFlagBitsKHX bits )
-  {
-    return ~( MemoryAllocateFlagsKHX( bits ) );
-  }
-
-  template <> struct FlagTraits<MemoryAllocateFlagBitsKHX>
-  {
-    enum
-    {
-      allFlags = VkFlags(MemoryAllocateFlagBitsKHX::eDeviceMask)
-    };
-  };
-
-  struct MemoryAllocateFlagsInfoKHX
-  {
-    MemoryAllocateFlagsInfoKHX( MemoryAllocateFlagsKHX flags_ = MemoryAllocateFlagsKHX(), uint32_t deviceMask_ = 0 )
-      : flags( flags_ )
-      , deviceMask( deviceMask_ )
-    {
-    }
-
-    MemoryAllocateFlagsInfoKHX( VkMemoryAllocateFlagsInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) );
-    }
-
-    MemoryAllocateFlagsInfoKHX& operator=( VkMemoryAllocateFlagsInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( MemoryAllocateFlagsInfoKHX ) );
-      return *this;
-    }
-    MemoryAllocateFlagsInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    MemoryAllocateFlagsInfoKHX& setFlags( MemoryAllocateFlagsKHX flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    MemoryAllocateFlagsInfoKHX& setDeviceMask( uint32_t deviceMask_ )
-    {
-      deviceMask = deviceMask_;
-      return *this;
-    }
-
-    operator const VkMemoryAllocateFlagsInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkMemoryAllocateFlagsInfoKHX*>(this);
-    }
-
-    bool operator==( MemoryAllocateFlagsInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( deviceMask == rhs.deviceMask );
-    }
-
-    bool operator!=( MemoryAllocateFlagsInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eMemoryAllocateFlagsInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    MemoryAllocateFlagsKHX flags;
-    uint32_t deviceMask;
-  };
-  static_assert( sizeof( MemoryAllocateFlagsInfoKHX ) == sizeof( VkMemoryAllocateFlagsInfoKHX ), "struct and wrapper have different size!" );
-
-  enum class DeviceGroupPresentModeFlagBitsKHX
-  {
-    eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHX,
-    eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHX,
-    eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHX,
-    eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHX
-  };
-
-  using DeviceGroupPresentModeFlagsKHX = Flags<DeviceGroupPresentModeFlagBitsKHX, VkDeviceGroupPresentModeFlagsKHX>;
-
-  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator|( DeviceGroupPresentModeFlagBitsKHX bit0, DeviceGroupPresentModeFlagBitsKHX bit1 )
-  {
-    return DeviceGroupPresentModeFlagsKHX( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE DeviceGroupPresentModeFlagsKHX operator~( DeviceGroupPresentModeFlagBitsKHX bits )
-  {
-    return ~( DeviceGroupPresentModeFlagsKHX( bits ) );
-  }
-
-  template <> struct FlagTraits<DeviceGroupPresentModeFlagBitsKHX>
-  {
-    enum
-    {
-      allFlags = VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocal) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eRemote) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eSum) | VkFlags(DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice)
-    };
-  };
-
-  struct DeviceGroupPresentCapabilitiesKHX
-  {
-    operator const VkDeviceGroupPresentCapabilitiesKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupPresentCapabilitiesKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupPresentCapabilitiesKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( memcmp( presentMask, rhs.presentMask, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( uint32_t ) ) == 0 )
-          && ( modes == rhs.modes );
-    }
-
-    bool operator!=( DeviceGroupPresentCapabilitiesKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE_KHX];
-    DeviceGroupPresentModeFlagsKHX modes;
-  };
-  static_assert( sizeof( DeviceGroupPresentCapabilitiesKHX ) == sizeof( VkDeviceGroupPresentCapabilitiesKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupPresentInfoKHX
-  {
-    DeviceGroupPresentInfoKHX( uint32_t swapchainCount_ = 0, const uint32_t* pDeviceMasks_ = nullptr, DeviceGroupPresentModeFlagBitsKHX mode_ = DeviceGroupPresentModeFlagBitsKHX::eLocal )
-      : swapchainCount( swapchainCount_ )
-      , pDeviceMasks( pDeviceMasks_ )
-      , mode( mode_ )
-    {
-    }
-
-    DeviceGroupPresentInfoKHX( VkDeviceGroupPresentInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) );
-    }
-
-    DeviceGroupPresentInfoKHX& operator=( VkDeviceGroupPresentInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupPresentInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupPresentInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHX& setSwapchainCount( uint32_t swapchainCount_ )
-    {
-      swapchainCount = swapchainCount_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHX& setPDeviceMasks( const uint32_t* pDeviceMasks_ )
-    {
-      pDeviceMasks = pDeviceMasks_;
-      return *this;
-    }
-
-    DeviceGroupPresentInfoKHX& setMode( DeviceGroupPresentModeFlagBitsKHX mode_ )
-    {
-      mode = mode_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupPresentInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupPresentInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupPresentInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( swapchainCount == rhs.swapchainCount )
-          && ( pDeviceMasks == rhs.pDeviceMasks )
-          && ( mode == rhs.mode );
-    }
-
-    bool operator!=( DeviceGroupPresentInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupPresentInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t swapchainCount;
-    const uint32_t* pDeviceMasks;
-    DeviceGroupPresentModeFlagBitsKHX mode;
-  };
-  static_assert( sizeof( DeviceGroupPresentInfoKHX ) == sizeof( VkDeviceGroupPresentInfoKHX ), "struct and wrapper have different size!" );
-
-  struct DeviceGroupSwapchainCreateInfoKHX
-  {
-    DeviceGroupSwapchainCreateInfoKHX( DeviceGroupPresentModeFlagsKHX modes_ = DeviceGroupPresentModeFlagsKHX() )
-      : modes( modes_ )
-    {
-    }
-
-    DeviceGroupSwapchainCreateInfoKHX( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) );
-    }
-
-    DeviceGroupSwapchainCreateInfoKHX& operator=( VkDeviceGroupSwapchainCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupSwapchainCreateInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupSwapchainCreateInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupSwapchainCreateInfoKHX& setModes( DeviceGroupPresentModeFlagsKHX modes_ )
-    {
-      modes = modes_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupSwapchainCreateInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( modes == rhs.modes );
-    }
-
-    bool operator!=( DeviceGroupSwapchainCreateInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    DeviceGroupPresentModeFlagsKHX modes;
-  };
-  static_assert( sizeof( DeviceGroupSwapchainCreateInfoKHX ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHX ), "struct and wrapper have different size!" );
-
-  enum class SwapchainCreateFlagBitsKHR
-  {
-    eBindSfrKHX = VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX
-  };
-
-  using SwapchainCreateFlagsKHR = Flags<SwapchainCreateFlagBitsKHR, VkSwapchainCreateFlagsKHR>;
-
-  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator|( SwapchainCreateFlagBitsKHR bit0, SwapchainCreateFlagBitsKHR bit1 )
-  {
-    return SwapchainCreateFlagsKHR( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SwapchainCreateFlagsKHR operator~( SwapchainCreateFlagBitsKHR bits )
-  {
-    return ~( SwapchainCreateFlagsKHR( bits ) );
-  }
-
-  template <> struct FlagTraits<SwapchainCreateFlagBitsKHR>
-  {
-    enum
-    {
-      allFlags = VkFlags(SwapchainCreateFlagBitsKHR::eBindSfrKHX)
-    };
-  };
-
-  struct SwapchainCreateInfoKHR
-  {
-    SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = SwapchainCreateFlagsKHR(), SurfaceKHR surface_ = SurfaceKHR(), uint32_t minImageCount_ = 0, Format imageFormat_ = Format::eUndefined, ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, Extent2D imageExtent_ = Extent2D(), uint32_t imageArrayLayers_ = 0, ImageUsageFlags imageUsage_ = ImageUsageFlags(), SharingMode imageSharingMode_ = SharingMode::eExclusive, uint32_t queueFamilyIndexCount_ = 0, const uint32_t* pQueueFamilyIndices_ = nullptr, SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, Bool32 clipped_ = 0, SwapchainKHR oldSwapchain_ = SwapchainKHR() )
-      : flags( flags_ )
-      , surface( surface_ )
-      , minImageCount( minImageCount_ )
-      , imageFormat( imageFormat_ )
-      , imageColorSpace( imageColorSpace_ )
-      , imageExtent( imageExtent_ )
-      , imageArrayLayers( imageArrayLayers_ )
-      , imageUsage( imageUsage_ )
-      , imageSharingMode( imageSharingMode_ )
-      , queueFamilyIndexCount( queueFamilyIndexCount_ )
-      , pQueueFamilyIndices( pQueueFamilyIndices_ )
-      , preTransform( preTransform_ )
-      , compositeAlpha( compositeAlpha_ )
-      , presentMode( presentMode_ )
-      , clipped( clipped_ )
-      , oldSwapchain( oldSwapchain_ )
-    {
-    }
-
-    SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
-    }
-
-    SwapchainCreateInfoKHR& operator=( VkSwapchainCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SwapchainCreateInfoKHR ) );
-      return *this;
-    }
-    SwapchainCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setFlags( SwapchainCreateFlagsKHR flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setSurface( SurfaceKHR surface_ )
-    {
-      surface = surface_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setMinImageCount( uint32_t minImageCount_ )
-    {
-      minImageCount = minImageCount_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageFormat( Format imageFormat_ )
-    {
-      imageFormat = imageFormat_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageColorSpace( ColorSpaceKHR imageColorSpace_ )
-    {
-      imageColorSpace = imageColorSpace_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageExtent( Extent2D imageExtent_ )
-    {
-      imageExtent = imageExtent_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageArrayLayers( uint32_t imageArrayLayers_ )
-    {
-      imageArrayLayers = imageArrayLayers_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageUsage( ImageUsageFlags imageUsage_ )
-    {
-      imageUsage = imageUsage_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setImageSharingMode( SharingMode imageSharingMode_ )
-    {
-      imageSharingMode = imageSharingMode_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ )
-    {
-      queueFamilyIndexCount = queueFamilyIndexCount_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPQueueFamilyIndices( const uint32_t* pQueueFamilyIndices_ )
-    {
-      pQueueFamilyIndices = pQueueFamilyIndices_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ )
-    {
-      preTransform = preTransform_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ )
-    {
-      compositeAlpha = compositeAlpha_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setPresentMode( PresentModeKHR presentMode_ )
-    {
-      presentMode = presentMode_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setClipped( Bool32 clipped_ )
-    {
-      clipped = clipped_;
-      return *this;
-    }
-
-    SwapchainCreateInfoKHR& setOldSwapchain( SwapchainKHR oldSwapchain_ )
-    {
-      oldSwapchain = oldSwapchain_;
-      return *this;
-    }
-
-    operator const VkSwapchainCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkSwapchainCreateInfoKHR*>(this);
-    }
-
-    bool operator==( SwapchainCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( surface == rhs.surface )
-          && ( minImageCount == rhs.minImageCount )
-          && ( imageFormat == rhs.imageFormat )
-          && ( imageColorSpace == rhs.imageColorSpace )
-          && ( imageExtent == rhs.imageExtent )
-          && ( imageArrayLayers == rhs.imageArrayLayers )
-          && ( imageUsage == rhs.imageUsage )
-          && ( imageSharingMode == rhs.imageSharingMode )
-          && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount )
-          && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices )
-          && ( preTransform == rhs.preTransform )
-          && ( compositeAlpha == rhs.compositeAlpha )
-          && ( presentMode == rhs.presentMode )
-          && ( clipped == rhs.clipped )
-          && ( oldSwapchain == rhs.oldSwapchain );
-    }
-
-    bool operator!=( SwapchainCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSwapchainCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    SwapchainCreateFlagsKHR flags;
-    SurfaceKHR surface;
-    uint32_t minImageCount;
-    Format imageFormat;
-    ColorSpaceKHR imageColorSpace;
-    Extent2D imageExtent;
-    uint32_t imageArrayLayers;
-    ImageUsageFlags imageUsage;
-    SharingMode imageSharingMode;
-    uint32_t queueFamilyIndexCount;
-    const uint32_t* pQueueFamilyIndices;
-    SurfaceTransformFlagBitsKHR preTransform;
-    CompositeAlphaFlagBitsKHR compositeAlpha;
-    PresentModeKHR presentMode;
-    Bool32 clipped;
-    SwapchainKHR oldSwapchain;
-  };
-  static_assert( sizeof( SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class ViewportCoordinateSwizzleNV
-  {
-    ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
-    eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV,
-    ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV,
-    eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV,
-    ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV,
-    eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV,
-    ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV,
-    eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV
-  };
-
-  struct ViewportSwizzleNV
-  {
-    ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX )
-      : x( x_ )
-      , y( y_ )
-      , z( z_ )
-      , w( w_ )
-    {
-    }
-
-    ViewportSwizzleNV( VkViewportSwizzleNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
-    }
-
-    ViewportSwizzleNV& operator=( VkViewportSwizzleNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( ViewportSwizzleNV ) );
-      return *this;
-    }
-    ViewportSwizzleNV& setX( ViewportCoordinateSwizzleNV x_ )
-    {
-      x = x_;
-      return *this;
-    }
-
-    ViewportSwizzleNV& setY( ViewportCoordinateSwizzleNV y_ )
-    {
-      y = y_;
-      return *this;
-    }
-
-    ViewportSwizzleNV& setZ( ViewportCoordinateSwizzleNV z_ )
-    {
-      z = z_;
-      return *this;
-    }
-
-    ViewportSwizzleNV& setW( ViewportCoordinateSwizzleNV w_ )
-    {
-      w = w_;
-      return *this;
-    }
-
-    operator const VkViewportSwizzleNV&() const
-    {
-      return *reinterpret_cast<const VkViewportSwizzleNV*>(this);
-    }
-
-    bool operator==( ViewportSwizzleNV const& rhs ) const
-    {
-      return ( x == rhs.x )
-          && ( y == rhs.y )
-          && ( z == rhs.z )
-          && ( w == rhs.w );
-    }
-
-    bool operator!=( ViewportSwizzleNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    ViewportCoordinateSwizzleNV x;
-    ViewportCoordinateSwizzleNV y;
-    ViewportCoordinateSwizzleNV z;
-    ViewportCoordinateSwizzleNV w;
-  };
-  static_assert( sizeof( ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" );
-
-  struct PipelineViewportSwizzleStateCreateInfoNV
-  {
-    PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = PipelineViewportSwizzleStateCreateFlagsNV(), uint32_t viewportCount_ = 0, const ViewportSwizzleNV* pViewportSwizzles_ = nullptr )
-      : flags( flags_ )
-      , viewportCount( viewportCount_ )
-      , pViewportSwizzles( pViewportSwizzles_ )
-    {
-    }
-
-    PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
-    }
-
-    PipelineViewportSwizzleStateCreateInfoNV& operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineViewportSwizzleStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineViewportSwizzleStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineViewportSwizzleStateCreateInfoNV& setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineViewportSwizzleStateCreateInfoNV& setViewportCount( uint32_t viewportCount_ )
-    {
-      viewportCount = viewportCount_;
-      return *this;
-    }
-
-    PipelineViewportSwizzleStateCreateInfoNV& setPViewportSwizzles( const ViewportSwizzleNV* pViewportSwizzles_ )
-    {
-      pViewportSwizzles = pViewportSwizzles_;
-      return *this;
-    }
-
-    operator const VkPipelineViewportSwizzleStateCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( viewportCount == rhs.viewportCount )
-          && ( pViewportSwizzles == rhs.pViewportSwizzles );
-    }
-
-    bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineViewportSwizzleStateCreateFlagsNV flags;
-    uint32_t viewportCount;
-    const ViewportSwizzleNV* pViewportSwizzles;
-  };
-  static_assert( sizeof( PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  enum class DiscardRectangleModeEXT
-  {
-    eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
-    eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT
-  };
-
-  struct PipelineDiscardRectangleStateCreateInfoEXT
-  {
-    PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = PipelineDiscardRectangleStateCreateFlagsEXT(), DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, uint32_t discardRectangleCount_ = 0, const Rect2D* pDiscardRectangles_ = nullptr )
-      : flags( flags_ )
-      , discardRectangleMode( discardRectangleMode_ )
-      , discardRectangleCount( discardRectangleCount_ )
-      , pDiscardRectangles( pDiscardRectangles_ )
-    {
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineDiscardRectangleStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ )
-    {
-      discardRectangleMode = discardRectangleMode_;
-      return *this;
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& setDiscardRectangleCount( uint32_t discardRectangleCount_ )
-    {
-      discardRectangleCount = discardRectangleCount_;
-      return *this;
-    }
-
-    PipelineDiscardRectangleStateCreateInfoEXT& setPDiscardRectangles( const Rect2D* pDiscardRectangles_ )
-    {
-      pDiscardRectangles = pDiscardRectangles_;
-      return *this;
-    }
-
-    operator const VkPipelineDiscardRectangleStateCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( discardRectangleMode == rhs.discardRectangleMode )
-          && ( discardRectangleCount == rhs.discardRectangleCount )
-          && ( pDiscardRectangles == rhs.pDiscardRectangles );
-    }
-
-    bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineDiscardRectangleStateCreateFlagsEXT flags;
-    DiscardRectangleModeEXT discardRectangleMode;
-    uint32_t discardRectangleCount;
-    const Rect2D* pDiscardRectangles;
-  };
-  static_assert( sizeof( PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class SubpassDescriptionFlagBits
-  {
-    ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX,
-    ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX
-  };
-
-  using SubpassDescriptionFlags = Flags<SubpassDescriptionFlagBits, VkSubpassDescriptionFlags>;
-
-  VULKAN_HPP_INLINE SubpassDescriptionFlags operator|( SubpassDescriptionFlagBits bit0, SubpassDescriptionFlagBits bit1 )
-  {
-    return SubpassDescriptionFlags( bit0 ) | bit1;
-  }
-
-  VULKAN_HPP_INLINE SubpassDescriptionFlags operator~( SubpassDescriptionFlagBits bits )
-  {
-    return ~( SubpassDescriptionFlags( bits ) );
-  }
-
-  template <> struct FlagTraits<SubpassDescriptionFlagBits>
-  {
-    enum
-    {
-      allFlags = VkFlags(SubpassDescriptionFlagBits::ePerViewAttributesNVX) | VkFlags(SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX)
-    };
-  };
-
-  struct SubpassDescription
-  {
-    SubpassDescription( SubpassDescriptionFlags flags_ = SubpassDescriptionFlags(), PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, uint32_t inputAttachmentCount_ = 0, const AttachmentReference* pInputAttachments_ = nullptr, uint32_t colorAttachmentCount_ = 0, const AttachmentReference* pColorAttachments_ = nullptr, const AttachmentReference* pResolveAttachments_ = nullptr, const AttachmentReference* pDepthStencilAttachment_ = nullptr, uint32_t preserveAttachmentCount_ = 0, const uint32_t* pPreserveAttachments_ = nullptr )
-      : flags( flags_ )
-      , pipelineBindPoint( pipelineBindPoint_ )
-      , inputAttachmentCount( inputAttachmentCount_ )
-      , pInputAttachments( pInputAttachments_ )
-      , colorAttachmentCount( colorAttachmentCount_ )
-      , pColorAttachments( pColorAttachments_ )
-      , pResolveAttachments( pResolveAttachments_ )
-      , pDepthStencilAttachment( pDepthStencilAttachment_ )
-      , preserveAttachmentCount( preserveAttachmentCount_ )
-      , pPreserveAttachments( pPreserveAttachments_ )
-    {
-    }
-
-    SubpassDescription( VkSubpassDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDescription ) );
-    }
-
-    SubpassDescription& operator=( VkSubpassDescription const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubpassDescription ) );
-      return *this;
-    }
-    SubpassDescription& setFlags( SubpassDescriptionFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    SubpassDescription& setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ )
-    {
-      pipelineBindPoint = pipelineBindPoint_;
-      return *this;
-    }
-
-    SubpassDescription& setInputAttachmentCount( uint32_t inputAttachmentCount_ )
-    {
-      inputAttachmentCount = inputAttachmentCount_;
-      return *this;
-    }
-
-    SubpassDescription& setPInputAttachments( const AttachmentReference* pInputAttachments_ )
-    {
-      pInputAttachments = pInputAttachments_;
-      return *this;
-    }
-
-    SubpassDescription& setColorAttachmentCount( uint32_t colorAttachmentCount_ )
-    {
-      colorAttachmentCount = colorAttachmentCount_;
-      return *this;
-    }
-
-    SubpassDescription& setPColorAttachments( const AttachmentReference* pColorAttachments_ )
-    {
-      pColorAttachments = pColorAttachments_;
-      return *this;
-    }
-
-    SubpassDescription& setPResolveAttachments( const AttachmentReference* pResolveAttachments_ )
-    {
-      pResolveAttachments = pResolveAttachments_;
-      return *this;
-    }
-
-    SubpassDescription& setPDepthStencilAttachment( const AttachmentReference* pDepthStencilAttachment_ )
-    {
-      pDepthStencilAttachment = pDepthStencilAttachment_;
-      return *this;
-    }
-
-    SubpassDescription& setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ )
-    {
-      preserveAttachmentCount = preserveAttachmentCount_;
-      return *this;
-    }
-
-    SubpassDescription& setPPreserveAttachments( const uint32_t* pPreserveAttachments_ )
-    {
-      pPreserveAttachments = pPreserveAttachments_;
-      return *this;
-    }
-
-    operator const VkSubpassDescription&() const
-    {
-      return *reinterpret_cast<const VkSubpassDescription*>(this);
-    }
-
-    bool operator==( SubpassDescription const& rhs ) const
-    {
-      return ( flags == rhs.flags )
-          && ( pipelineBindPoint == rhs.pipelineBindPoint )
-          && ( inputAttachmentCount == rhs.inputAttachmentCount )
-          && ( pInputAttachments == rhs.pInputAttachments )
-          && ( colorAttachmentCount == rhs.colorAttachmentCount )
-          && ( pColorAttachments == rhs.pColorAttachments )
-          && ( pResolveAttachments == rhs.pResolveAttachments )
-          && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment )
-          && ( preserveAttachmentCount == rhs.preserveAttachmentCount )
-          && ( pPreserveAttachments == rhs.pPreserveAttachments );
-    }
-
-    bool operator!=( SubpassDescription const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-    SubpassDescriptionFlags flags;
-    PipelineBindPoint pipelineBindPoint;
-    uint32_t inputAttachmentCount;
-    const AttachmentReference* pInputAttachments;
-    uint32_t colorAttachmentCount;
-    const AttachmentReference* pColorAttachments;
-    const AttachmentReference* pResolveAttachments;
-    const AttachmentReference* pDepthStencilAttachment;
-    uint32_t preserveAttachmentCount;
-    const uint32_t* pPreserveAttachments;
-  };
-  static_assert( sizeof( SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" );
-
-  struct RenderPassCreateInfo
-  {
-    RenderPassCreateInfo( RenderPassCreateFlags flags_ = RenderPassCreateFlags(), uint32_t attachmentCount_ = 0, const AttachmentDescription* pAttachments_ = nullptr, uint32_t subpassCount_ = 0, const SubpassDescription* pSubpasses_ = nullptr, uint32_t dependencyCount_ = 0, const SubpassDependency* pDependencies_ = nullptr )
-      : flags( flags_ )
-      , attachmentCount( attachmentCount_ )
-      , pAttachments( pAttachments_ )
-      , subpassCount( subpassCount_ )
-      , pSubpasses( pSubpasses_ )
-      , dependencyCount( dependencyCount_ )
-      , pDependencies( pDependencies_ )
-    {
-    }
-
-    RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
-    }
-
-    RenderPassCreateInfo& operator=( VkRenderPassCreateInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( RenderPassCreateInfo ) );
-      return *this;
-    }
-    RenderPassCreateInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setFlags( RenderPassCreateFlags flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setAttachmentCount( uint32_t attachmentCount_ )
-    {
-      attachmentCount = attachmentCount_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setPAttachments( const AttachmentDescription* pAttachments_ )
-    {
-      pAttachments = pAttachments_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setSubpassCount( uint32_t subpassCount_ )
-    {
-      subpassCount = subpassCount_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setPSubpasses( const SubpassDescription* pSubpasses_ )
-    {
-      pSubpasses = pSubpasses_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setDependencyCount( uint32_t dependencyCount_ )
-    {
-      dependencyCount = dependencyCount_;
-      return *this;
-    }
-
-    RenderPassCreateInfo& setPDependencies( const SubpassDependency* pDependencies_ )
-    {
-      pDependencies = pDependencies_;
-      return *this;
-    }
-
-    operator const VkRenderPassCreateInfo&() const
-    {
-      return *reinterpret_cast<const VkRenderPassCreateInfo*>(this);
-    }
-
-    bool operator==( RenderPassCreateInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( attachmentCount == rhs.attachmentCount )
-          && ( pAttachments == rhs.pAttachments )
-          && ( subpassCount == rhs.subpassCount )
-          && ( pSubpasses == rhs.pSubpasses )
-          && ( dependencyCount == rhs.dependencyCount )
-          && ( pDependencies == rhs.pDependencies );
-    }
-
-    bool operator!=( RenderPassCreateInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eRenderPassCreateInfo;
-
-  public:
-    const void* pNext = nullptr;
-    RenderPassCreateFlags flags;
-    uint32_t attachmentCount;
-    const AttachmentDescription* pAttachments;
-    uint32_t subpassCount;
-    const SubpassDescription* pSubpasses;
-    uint32_t dependencyCount;
-    const SubpassDependency* pDependencies;
-  };
-  static_assert( sizeof( RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" );
-
-  enum class PointClippingBehaviorKHR
-  {
-    eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR,
-    eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR
-  };
-
-  struct PhysicalDevicePointClippingPropertiesKHR
-  {
-    operator const VkPhysicalDevicePointClippingPropertiesKHR&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDevicePointClippingPropertiesKHR*>(this);
-    }
-
-    bool operator==( PhysicalDevicePointClippingPropertiesKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( pointClippingBehavior == rhs.pointClippingBehavior );
-    }
-
-    bool operator!=( PhysicalDevicePointClippingPropertiesKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDevicePointClippingPropertiesKHR;
-
-  public:
-    void* pNext = nullptr;
-    PointClippingBehaviorKHR pointClippingBehavior;
-  };
-  static_assert( sizeof( PhysicalDevicePointClippingPropertiesKHR ) == sizeof( VkPhysicalDevicePointClippingPropertiesKHR ), "struct and wrapper have different size!" );
-
-  enum class SamplerReductionModeEXT
-  {
-    eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
-    eMin = VK_SAMPLER_REDUCTION_MODE_MIN_EXT,
-    eMax = VK_SAMPLER_REDUCTION_MODE_MAX_EXT
-  };
-
-  struct SamplerReductionModeCreateInfoEXT
-  {
-    SamplerReductionModeCreateInfoEXT( SamplerReductionModeEXT reductionMode_ = SamplerReductionModeEXT::eWeightedAverage )
-      : reductionMode( reductionMode_ )
-    {
-    }
-
-    SamplerReductionModeCreateInfoEXT( VkSamplerReductionModeCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
-    }
-
-    SamplerReductionModeCreateInfoEXT& operator=( VkSamplerReductionModeCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerReductionModeCreateInfoEXT ) );
-      return *this;
-    }
-    SamplerReductionModeCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerReductionModeCreateInfoEXT& setReductionMode( SamplerReductionModeEXT reductionMode_ )
-    {
-      reductionMode = reductionMode_;
-      return *this;
-    }
-
-    operator const VkSamplerReductionModeCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT*>(this);
-    }
-
-    bool operator==( SamplerReductionModeCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( reductionMode == rhs.reductionMode );
-    }
-
-    bool operator!=( SamplerReductionModeCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerReductionModeCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    SamplerReductionModeEXT reductionMode;
-  };
-  static_assert( sizeof( SamplerReductionModeCreateInfoEXT ) == sizeof( VkSamplerReductionModeCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class TessellationDomainOriginKHR
-  {
-    eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR,
-    eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR
-  };
-
-  struct PipelineTessellationDomainOriginStateCreateInfoKHR
-  {
-    PipelineTessellationDomainOriginStateCreateInfoKHR( TessellationDomainOriginKHR domainOrigin_ = TessellationDomainOriginKHR::eUpperLeft )
-      : domainOrigin( domainOrigin_ )
-    {
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfoKHR( VkPipelineTessellationDomainOriginStateCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) );
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfoKHR& operator=( VkPipelineTessellationDomainOriginStateCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) );
-      return *this;
-    }
-    PipelineTessellationDomainOriginStateCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineTessellationDomainOriginStateCreateInfoKHR& setDomainOrigin( TessellationDomainOriginKHR domainOrigin_ )
-    {
-      domainOrigin = domainOrigin_;
-      return *this;
-    }
-
-    operator const VkPipelineTessellationDomainOriginStateCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfoKHR*>(this);
-    }
-
-    bool operator==( PipelineTessellationDomainOriginStateCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( domainOrigin == rhs.domainOrigin );
-    }
-
-    bool operator!=( PipelineTessellationDomainOriginStateCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    TessellationDomainOriginKHR domainOrigin;
-  };
-  static_assert( sizeof( PipelineTessellationDomainOriginStateCreateInfoKHR ) == sizeof( VkPipelineTessellationDomainOriginStateCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class SamplerYcbcrModelConversionKHR
-  {
-    eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
-    eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR,
-    eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR,
-    eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR,
-    eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR
-  };
-
-  enum class SamplerYcbcrRangeKHR
-  {
-    eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
-    eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR
-  };
-
-  enum class ChromaLocationKHR
-  {
-    eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN_KHR,
-    eMidpoint = VK_CHROMA_LOCATION_MIDPOINT_KHR
-  };
-
-  struct SamplerYcbcrConversionCreateInfoKHR
-  {
-    SamplerYcbcrConversionCreateInfoKHR( Format format_ = Format::eUndefined, SamplerYcbcrModelConversionKHR ycbcrModel_ = SamplerYcbcrModelConversionKHR::eRgbIdentity, SamplerYcbcrRangeKHR ycbcrRange_ = SamplerYcbcrRangeKHR::eItuFull, ComponentMapping components_ = ComponentMapping(), ChromaLocationKHR xChromaOffset_ = ChromaLocationKHR::eCositedEven, ChromaLocationKHR yChromaOffset_ = ChromaLocationKHR::eCositedEven, Filter chromaFilter_ = Filter::eNearest, Bool32 forceExplicitReconstruction_ = 0 )
-      : format( format_ )
-      , ycbcrModel( ycbcrModel_ )
-      , ycbcrRange( ycbcrRange_ )
-      , components( components_ )
-      , xChromaOffset( xChromaOffset_ )
-      , yChromaOffset( yChromaOffset_ )
-      , chromaFilter( chromaFilter_ )
-      , forceExplicitReconstruction( forceExplicitReconstruction_ )
-    {
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR( VkSamplerYcbcrConversionCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfoKHR ) );
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& operator=( VkSamplerYcbcrConversionCreateInfoKHR const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SamplerYcbcrConversionCreateInfoKHR ) );
-      return *this;
-    }
-    SamplerYcbcrConversionCreateInfoKHR& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setFormat( Format format_ )
-    {
-      format = format_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setYcbcrModel( SamplerYcbcrModelConversionKHR ycbcrModel_ )
-    {
-      ycbcrModel = ycbcrModel_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setYcbcrRange( SamplerYcbcrRangeKHR ycbcrRange_ )
-    {
-      ycbcrRange = ycbcrRange_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setComponents( ComponentMapping components_ )
-    {
-      components = components_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setXChromaOffset( ChromaLocationKHR xChromaOffset_ )
-    {
-      xChromaOffset = xChromaOffset_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setYChromaOffset( ChromaLocationKHR yChromaOffset_ )
-    {
-      yChromaOffset = yChromaOffset_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setChromaFilter( Filter chromaFilter_ )
-    {
-      chromaFilter = chromaFilter_;
-      return *this;
-    }
-
-    SamplerYcbcrConversionCreateInfoKHR& setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ )
-    {
-      forceExplicitReconstruction = forceExplicitReconstruction_;
-      return *this;
-    }
-
-    operator const VkSamplerYcbcrConversionCreateInfoKHR&() const
-    {
-      return *reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>(this);
-    }
-
-    bool operator==( SamplerYcbcrConversionCreateInfoKHR const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( format == rhs.format )
-          && ( ycbcrModel == rhs.ycbcrModel )
-          && ( ycbcrRange == rhs.ycbcrRange )
-          && ( components == rhs.components )
-          && ( xChromaOffset == rhs.xChromaOffset )
-          && ( yChromaOffset == rhs.yChromaOffset )
-          && ( chromaFilter == rhs.chromaFilter )
-          && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction );
-    }
-
-    bool operator!=( SamplerYcbcrConversionCreateInfoKHR const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfoKHR;
-
-  public:
-    const void* pNext = nullptr;
-    Format format;
-    SamplerYcbcrModelConversionKHR ycbcrModel;
-    SamplerYcbcrRangeKHR ycbcrRange;
-    ComponentMapping components;
-    ChromaLocationKHR xChromaOffset;
-    ChromaLocationKHR yChromaOffset;
-    Filter chromaFilter;
-    Bool32 forceExplicitReconstruction;
-  };
-  static_assert( sizeof( SamplerYcbcrConversionCreateInfoKHR ) == sizeof( VkSamplerYcbcrConversionCreateInfoKHR ), "struct and wrapper have different size!" );
-
-  enum class BlendOverlapEXT
-  {
-    eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
-    eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT,
-    eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT
-  };
-
-  struct PipelineColorBlendAdvancedStateCreateInfoEXT
-  {
-    PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = 0, Bool32 dstPremultiplied_ = 0, BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated )
-      : srcPremultiplied( srcPremultiplied_ )
-      , dstPremultiplied( dstPremultiplied_ )
-      , blendOverlap( blendOverlap_ )
-    {
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setSrcPremultiplied( Bool32 srcPremultiplied_ )
-    {
-      srcPremultiplied = srcPremultiplied_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setDstPremultiplied( Bool32 dstPremultiplied_ )
-    {
-      dstPremultiplied = dstPremultiplied_;
-      return *this;
-    }
-
-    PipelineColorBlendAdvancedStateCreateInfoEXT& setBlendOverlap( BlendOverlapEXT blendOverlap_ )
-    {
-      blendOverlap = blendOverlap_;
-      return *this;
-    }
-
-    operator const VkPipelineColorBlendAdvancedStateCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( srcPremultiplied == rhs.srcPremultiplied )
-          && ( dstPremultiplied == rhs.dstPremultiplied )
-          && ( blendOverlap == rhs.blendOverlap );
-    }
-
-    bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    Bool32 srcPremultiplied;
-    Bool32 dstPremultiplied;
-    BlendOverlapEXT blendOverlap;
-  };
-  static_assert( sizeof( PipelineColorBlendAdvancedStateCreateInfoEXT ) == sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class CoverageModulationModeNV
-  {
-    eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV,
-    eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV,
-    eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV,
-    eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV
-  };
-
-  struct PipelineCoverageModulationStateCreateInfoNV
-  {
-    PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = PipelineCoverageModulationStateCreateFlagsNV(), CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, Bool32 coverageModulationTableEnable_ = 0, uint32_t coverageModulationTableCount_ = 0, const float* pCoverageModulationTable_ = nullptr )
-      : flags( flags_ )
-      , coverageModulationMode( coverageModulationMode_ )
-      , coverageModulationTableEnable( coverageModulationTableEnable_ )
-      , coverageModulationTableCount( coverageModulationTableCount_ )
-      , pCoverageModulationTable( pCoverageModulationTable_ )
-    {
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineCoverageModulationStateCreateInfoNV ) );
-      return *this;
-    }
-    PipelineCoverageModulationStateCreateInfoNV& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ )
-    {
-      coverageModulationMode = coverageModulationMode_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ )
-    {
-      coverageModulationTableEnable = coverageModulationTableEnable_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ )
-    {
-      coverageModulationTableCount = coverageModulationTableCount_;
-      return *this;
-    }
-
-    PipelineCoverageModulationStateCreateInfoNV& setPCoverageModulationTable( const float* pCoverageModulationTable_ )
-    {
-      pCoverageModulationTable = pCoverageModulationTable_;
-      return *this;
-    }
-
-    operator const VkPipelineCoverageModulationStateCreateInfoNV&() const
-    {
-      return *reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV*>(this);
-    }
-
-    bool operator==( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( coverageModulationMode == rhs.coverageModulationMode )
-          && ( coverageModulationTableEnable == rhs.coverageModulationTableEnable )
-          && ( coverageModulationTableCount == rhs.coverageModulationTableCount )
-          && ( pCoverageModulationTable == rhs.pCoverageModulationTable );
-    }
-
-    bool operator!=( PipelineCoverageModulationStateCreateInfoNV const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineCoverageModulationStateCreateFlagsNV flags;
-    CoverageModulationModeNV coverageModulationMode;
-    Bool32 coverageModulationTableEnable;
-    uint32_t coverageModulationTableCount;
-    const float* pCoverageModulationTable;
-  };
-  static_assert( sizeof( PipelineCoverageModulationStateCreateInfoNV ) == sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), "struct and wrapper have different size!" );
-
-  enum class ValidationCacheHeaderVersionEXT
-  {
-    eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT
-  };
-
-  enum class ShaderInfoTypeAMD
-  {
-    eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
-    eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD,
-    eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD
-  };
-
-  enum class QueueGlobalPriorityEXT
-  {
-    eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
-    eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT,
-    eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT,
-    eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT
-  };
-
-  struct DeviceQueueGlobalPriorityCreateInfoEXT
-  {
-    DeviceQueueGlobalPriorityCreateInfoEXT( QueueGlobalPriorityEXT globalPriority_ = QueueGlobalPriorityEXT::eLow )
-      : globalPriority( globalPriority_ )
-    {
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT& operator=( VkDeviceQueueGlobalPriorityCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) );
-      return *this;
-    }
-    DeviceQueueGlobalPriorityCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceQueueGlobalPriorityCreateInfoEXT& setGlobalPriority( QueueGlobalPriorityEXT globalPriority_ )
-    {
-      globalPriority = globalPriority_;
-      return *this;
-    }
-
-    operator const VkDeviceQueueGlobalPriorityCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(this);
-    }
-
-    bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( globalPriority == rhs.globalPriority );
-    }
-
-    bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    QueueGlobalPriorityEXT globalPriority;
-  };
-  static_assert( sizeof( DeviceQueueGlobalPriorityCreateInfoEXT ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  enum class ConservativeRasterizationModeEXT
-  {
-    eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
-    eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT,
-    eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT
-  };
-
-  struct PipelineRasterizationConservativeStateCreateInfoEXT
-  {
-    PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = PipelineRasterizationConservativeStateCreateFlagsEXT(), ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, float extraPrimitiveOverestimationSize_ = 0 )
-      : flags( flags_ )
-      , conservativeRasterizationMode( conservativeRasterizationMode_ )
-      , extraPrimitiveOverestimationSize( extraPrimitiveOverestimationSize_ )
-    {
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) );
-      return *this;
-    }
-    PipelineRasterizationConservativeStateCreateInfoEXT& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ )
-    {
-      flags = flags_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ )
-    {
-      conservativeRasterizationMode = conservativeRasterizationMode_;
-      return *this;
-    }
-
-    PipelineRasterizationConservativeStateCreateInfoEXT& setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ )
-    {
-      extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_;
-      return *this;
-    }
-
-    operator const VkPipelineRasterizationConservativeStateCreateInfoEXT&() const
-    {
-      return *reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT*>(this);
-    }
-
-    bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( flags == rhs.flags )
-          && ( conservativeRasterizationMode == rhs.conservativeRasterizationMode )
-          && ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
-    }
-
-    bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT;
-
-  public:
-    const void* pNext = nullptr;
-    PipelineRasterizationConservativeStateCreateFlagsEXT flags;
-    ConservativeRasterizationModeEXT conservativeRasterizationMode;
-    float extraPrimitiveOverestimationSize;
-  };
-  static_assert( sizeof( PipelineRasterizationConservativeStateCreateInfoEXT ) == sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), "struct and wrapper have different size!" );
-
-  Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties );
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator = std::allocator<LayerProperties>> 
-  typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties();
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties )
-  {
-    return static_cast<Result>( vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateInstanceLayerProperties()
-  {
-    std::vector<LayerProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::enumerateInstanceLayerProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-  Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties );
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator = std::allocator<ExtensionProperties>> 
-  typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName = nullptr );
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties )
-  {
-    return static_cast<Result>( vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateInstanceExtensionProperties( Optional<const std::string> layerName )
-  {
-    std::vector<ExtensionProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::enumerateInstanceExtensionProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-  // forward declarations
-  struct CmdProcessCommandsInfoNVX;
-
-  class CommandBuffer
-  {
-  public:
-    CommandBuffer()
-      : m_commandBuffer(VK_NULL_HANDLE)
-    {}
-
-    CommandBuffer( std::nullptr_t )
-      : m_commandBuffer(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT CommandBuffer( VkCommandBuffer commandBuffer )
-      : m_commandBuffer( commandBuffer )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    CommandBuffer & operator=(VkCommandBuffer commandBuffer)
-    {
-      m_commandBuffer = commandBuffer;
-      return *this; 
-    }
-#endif
-
-    CommandBuffer & operator=( std::nullptr_t )
-    {
-      m_commandBuffer = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( CommandBuffer const & rhs ) const
-    {
-      return m_commandBuffer == rhs.m_commandBuffer;
-    }
-
-    bool operator!=(CommandBuffer const & rhs ) const
-    {
-      return m_commandBuffer != rhs.m_commandBuffer;
-    }
-
-    bool operator<(CommandBuffer const & rhs ) const
-    {
-      return m_commandBuffer < rhs.m_commandBuffer;
-    }
-
-    Result begin( const CommandBufferBeginInfo* pBeginInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type begin( const CommandBufferBeginInfo & beginInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result end() const;
-#else
-    ResultValueType<void>::type end() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result reset( CommandBufferResetFlags flags ) const;
-#else
-    ResultValueType<void>::type reset( CommandBufferResetFlags flags ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const;
-
-    void setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setLineWidth( float lineWidth ) const;
-
-    void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const;
-
-    void setBlendConstants( const float blendConstants[4] ) const;
-
-    void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const;
-
-    void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const;
-
-    void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const;
-
-    void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const;
-
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const;
-
-    void bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const;
-
-    void drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const;
-
-    void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const;
-
-    void drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const;
-
-    void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const;
-
-    void dispatchIndirect( Buffer buffer, DeviceSize offset ) const;
-
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T>
-    void updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const;
-
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setEvent( Event event, PipelineStageFlags stageMask ) const;
-
-    void resetEvent( Event event, PipelineStageFlags stageMask ) const;
-
-    void waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const;
-
-    void endQuery( QueryPool queryPool, uint32_t query ) const;
-
-    void resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const;
-
-    void writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const;
-
-    void copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const;
-
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T>
-    void pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void nextSubpass( SubpassContents contents ) const;
-
-    void endRenderPass() const;
-
-    void executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void executeCommands( ArrayProxy<const CommandBuffer> commandBuffers ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void debugMarkerEndEXT() const;
-
-    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const;
-
-    void drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const;
-
-    void processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setDeviceMaskKHX( uint32_t deviceMask ) const;
-
-    void dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const;
-
-    void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const;
-
-    void setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandBuffer() const
-    {
-      return m_commandBuffer;
-    }
-
-    explicit operator bool() const
-    {
-      return m_commandBuffer != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_commandBuffer == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkCommandBuffer m_commandBuffer;
-  };
-
-  static_assert( sizeof( CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" );
-
-  VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo* pBeginInfo ) const
-  {
-    return static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( pBeginInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const
-  {
-    Result result = static_cast<Result>( vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast<const VkCommandBufferBeginInfo*>( &beginInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::begin" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result CommandBuffer::end() const
-  {
-    return static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::end() const
-  {
-    Result result = static_cast<Result>( vkEndCommandBuffer( m_commandBuffer ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::end" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags ) const
-  {
-    return static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags ) const
-  {
-    Result result = static_cast<Result>( vkResetCommandBuffer( m_commandBuffer, static_cast<VkCommandBufferResetFlags>( flags ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::CommandBuffer::reset" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline ) const
-  {
-    vkCmdBindPipeline( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipeline>( pipeline ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport* pViewports ) const
-  {
-    vkCmdSetViewport( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewport*>( pViewports ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy<const Viewport> viewports ) const
-  {
-    vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size() , reinterpret_cast<const VkViewport*>( viewports.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D* pScissors ) const
-  {
-    vkCmdSetScissor( m_commandBuffer, firstScissor, scissorCount, reinterpret_cast<const VkRect2D*>( pScissors ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy<const Rect2D> scissors ) const
-  {
-    vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size() , reinterpret_cast<const VkRect2D*>( scissors.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const
-  {
-    vkCmdSetLineWidth( m_commandBuffer, lineWidth );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const
-  {
-    vkCmdSetDepthBias( m_commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const
-  {
-    vkCmdSetBlendConstants( m_commandBuffer, blendConstants );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const
-  {
-    vkCmdSetDepthBounds( m_commandBuffer, minDepthBounds, maxDepthBounds );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const
-  {
-    vkCmdSetStencilCompareMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), compareMask );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const
-  {
-    vkCmdSetStencilWriteMask( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), writeMask );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const
-  {
-    vkCmdSetStencilReference( m_commandBuffer, static_cast<VkStencilFaceFlags>( faceMask ), reference );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets ) const
-  {
-    vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ), dynamicOffsetCount, pDynamicOffsets );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t firstSet, ArrayProxy<const DescriptorSet> descriptorSets, ArrayProxy<const uint32_t> dynamicOffsets ) const
-  {
-    vkCmdBindDescriptorSets( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), firstSet, descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ), dynamicOffsets.size() , dynamicOffsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType ) const
-  {
-    vkCmdBindIndexBuffer( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkIndexType>( indexType ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, uint32_t bindingCount, const Buffer* pBuffers, const DeviceSize* pOffsets ) const
-  {
-    vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, bindingCount, reinterpret_cast<const VkBuffer*>( pBuffers ), pOffsets );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, ArrayProxy<const Buffer> buffers, ArrayProxy<const DeviceSize> offsets ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( buffers.size() == offsets.size() );
-#else
-    if ( buffers.size() != offsets.size() )
-    {
-      throw LogicError( "VULKAN_HPP_NAMESPACE::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    vkCmdBindVertexBuffers( m_commandBuffer, firstBinding, buffers.size() , reinterpret_cast<const VkBuffer*>( buffers.data() ), offsets.data() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const
-  {
-    vkCmdDraw( m_commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const
-  {
-    vkCmdDrawIndexed( m_commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
-  {
-    vkCmdDrawIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const
-  {
-    vkCmdDrawIndexedIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, drawCount, stride );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
-  {
-    vkCmdDispatch( m_commandBuffer, groupCountX, groupCountY, groupCountZ );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset ) const
-  {
-    vkCmdDispatchIndirect( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy* pRegions ) const
-  {
-    vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy<const BufferCopy> regions ) const
-  {
-    vkCmdCopyBuffer( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageCopy* pRegions ) const
-  {
-    vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageCopy> regions ) const
-  {
-    vkCmdCopyImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageBlit* pRegions, Filter filter ) const
-  {
-    vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageBlit*>( pRegions ), static_cast<VkFilter>( filter ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageBlit> regions, Filter filter ) const
-  {
-    vkCmdBlitImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageBlit*>( regions.data() ), static_cast<VkFilter>( filter ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const BufferImageCopy* pRegions ) const
-  {
-    vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const BufferImageCopy> regions ) const
-  {
-    vkCmdCopyBufferToImage( m_commandBuffer, static_cast<VkBuffer>( srcBuffer ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, uint32_t regionCount, const BufferImageCopy* pRegions ) const
-  {
-    vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regionCount, reinterpret_cast<const VkBufferImageCopy*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, ImageLayout srcImageLayout, Buffer dstBuffer, ArrayProxy<const BufferImageCopy> regions ) const
-  {
-    vkCmdCopyImageToBuffer( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkBuffer>( dstBuffer ), regions.size() , reinterpret_cast<const VkBufferImageCopy*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void* pData ) const
-  {
-    vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, dataSize, pData );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy<const T> data ) const
-  {
-    vkCmdUpdateBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, data.size() * sizeof( T ) , reinterpret_cast<const void*>( data.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const
-  {
-    vkCmdFillBuffer( m_commandBuffer, static_cast<VkBuffer>( dstBuffer ), dstOffset, size, data );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue* pColor, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const
-  {
-    vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( pColor ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, ImageLayout imageLayout, const ClearColorValue & color, ArrayProxy<const ImageSubresourceRange> ranges ) const
-  {
-    vkCmdClearColorImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearColorValue*>( &color ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const ImageSubresourceRange* pRanges ) const
-  {
-    vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( pDepthStencil ), rangeCount, reinterpret_cast<const VkImageSubresourceRange*>( pRanges ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, ImageLayout imageLayout, const ClearDepthStencilValue & depthStencil, ArrayProxy<const ImageSubresourceRange> ranges ) const
-  {
-    vkCmdClearDepthStencilImage( m_commandBuffer, static_cast<VkImage>( image ), static_cast<VkImageLayout>( imageLayout ), reinterpret_cast<const VkClearDepthStencilValue*>( &depthStencil ), ranges.size() , reinterpret_cast<const VkImageSubresourceRange*>( ranges.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( uint32_t attachmentCount, const ClearAttachment* pAttachments, uint32_t rectCount, const ClearRect* pRects ) const
-  {
-    vkCmdClearAttachments( m_commandBuffer, attachmentCount, reinterpret_cast<const VkClearAttachment*>( pAttachments ), rectCount, reinterpret_cast<const VkClearRect*>( pRects ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy<const ClearAttachment> attachments, ArrayProxy<const ClearRect> rects ) const
-  {
-    vkCmdClearAttachments( m_commandBuffer, attachments.size() , reinterpret_cast<const VkClearAttachment*>( attachments.data() ), rects.size() , reinterpret_cast<const VkClearRect*>( rects.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, uint32_t regionCount, const ImageResolve* pRegions ) const
-  {
-    vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regionCount, reinterpret_cast<const VkImageResolve*>( pRegions ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, ImageLayout srcImageLayout, Image dstImage, ImageLayout dstImageLayout, ArrayProxy<const ImageResolve> regions ) const
-  {
-    vkCmdResolveImage( m_commandBuffer, static_cast<VkImage>( srcImage ), static_cast<VkImageLayout>( srcImageLayout ), static_cast<VkImage>( dstImage ), static_cast<VkImageLayout>( dstImageLayout ), regions.size() , reinterpret_cast<const VkImageResolve*>( regions.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask ) const
-  {
-    vkCmdSetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask ) const
-  {
-    vkCmdResetEvent( m_commandBuffer, static_cast<VkEvent>( event ), static_cast<VkPipelineStageFlags>( stageMask ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, const Event* pEvents, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const
-  {
-    vkCmdWaitEvents( m_commandBuffer, eventCount, reinterpret_cast<const VkEvent*>( pEvents ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy<const Event> events, PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const
-  {
-    vkCmdWaitEvents( m_commandBuffer, events.size() , reinterpret_cast<const VkEvent*>( events.data() ), static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const MemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const BufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const ImageMemoryBarrier* pImageMemoryBarriers ) const
-  {
-    vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarrierCount, reinterpret_cast<const VkMemoryBarrier*>( pMemoryBarriers ), bufferMemoryBarrierCount, reinterpret_cast<const VkBufferMemoryBarrier*>( pBufferMemoryBarriers ), imageMemoryBarrierCount, reinterpret_cast<const VkImageMemoryBarrier*>( pImageMemoryBarriers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, PipelineStageFlags dstStageMask, DependencyFlags dependencyFlags, ArrayProxy<const MemoryBarrier> memoryBarriers, ArrayProxy<const BufferMemoryBarrier> bufferMemoryBarriers, ArrayProxy<const ImageMemoryBarrier> imageMemoryBarriers ) const
-  {
-    vkCmdPipelineBarrier( m_commandBuffer, static_cast<VkPipelineStageFlags>( srcStageMask ), static_cast<VkPipelineStageFlags>( dstStageMask ), static_cast<VkDependencyFlags>( dependencyFlags ), memoryBarriers.size() , reinterpret_cast<const VkMemoryBarrier*>( memoryBarriers.data() ), bufferMemoryBarriers.size() , reinterpret_cast<const VkBufferMemoryBarrier*>( bufferMemoryBarriers.data() ), imageMemoryBarriers.size() , reinterpret_cast<const VkImageMemoryBarrier*>( imageMemoryBarriers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const
-  {
-    vkCmdBeginQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query, static_cast<VkQueryControlFlags>( flags ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query ) const
-  {
-    vkCmdEndQuery( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), query );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const
-  {
-    vkCmdResetQueryPool( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query ) const
-  {
-    vkCmdWriteTimestamp( m_commandBuffer, static_cast<VkPipelineStageFlagBits>( pipelineStage ), static_cast<VkQueryPool>( queryPool ), query );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Buffer dstBuffer, DeviceSize dstOffset, DeviceSize stride, QueryResultFlags flags ) const
-  {
-    vkCmdCopyQueryPoolResults( m_commandBuffer, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, static_cast<VkBuffer>( dstBuffer ), dstOffset, stride, static_cast<VkQueryResultFlags>( flags ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues ) const
-  {
-    vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, size, pValues );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, ArrayProxy<const T> values ) const
-  {
-    vkCmdPushConstants( m_commandBuffer, static_cast<VkPipelineLayout>( layout ), static_cast<VkShaderStageFlags>( stageFlags ), offset, values.size() * sizeof( T ) , reinterpret_cast<const void*>( values.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo* pRenderPassBegin, SubpassContents contents ) const
-  {
-    vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( pRenderPassBegin ), static_cast<VkSubpassContents>( contents ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const
-  {
-    vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast<const VkRenderPassBeginInfo*>( &renderPassBegin ), static_cast<VkSubpassContents>( contents ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents ) const
-  {
-    vkCmdNextSubpass( m_commandBuffer, static_cast<VkSubpassContents>( contents ) );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const
-  {
-    vkCmdEndRenderPass( m_commandBuffer );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const
-  {
-    vkCmdExecuteCommands( m_commandBuffer, commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy<const CommandBuffer> commandBuffers ) const
-  {
-    vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const
-  {
-    vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const
-  {
-    vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const
-  {
-    vkCmdDebugMarkerEndEXT( m_commandBuffer );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT* pMarkerInfo ) const
-  {
-    vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( pMarkerInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const
-  {
-    vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast<const VkDebugMarkerMarkerInfoEXT*>( &markerInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
-  {
-    vkCmdDrawIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, DeviceSize offset, Buffer countBuffer, DeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride ) const
-  {
-    vkCmdDrawIndexedIndirectCountAMD( m_commandBuffer, static_cast<VkBuffer>( buffer ), offset, static_cast<VkBuffer>( countBuffer ), countBufferOffset, maxDrawCount, stride );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX* pProcessCommandsInfo ) const
-  {
-    vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( pProcessCommandsInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::processCommandsNVX( const CmdProcessCommandsInfoNVX & processCommandsInfo ) const
-  {
-    vkCmdProcessCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>( &processCommandsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo ) const
-  {
-    vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( pReserveSpaceInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::reserveSpaceForCommandsNVX( const CmdReserveSpaceForCommandsInfoNVX & reserveSpaceInfo ) const
-  {
-    vkCmdReserveSpaceForCommandsNVX( m_commandBuffer, reinterpret_cast<const VkCmdReserveSpaceForCommandsInfoNVX*>( &reserveSpaceInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites ) const
-  {
-    vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, PipelineLayout layout, uint32_t set, ArrayProxy<const WriteDescriptorSet> descriptorWrites ) const
-  {
-    vkCmdPushDescriptorSetKHR( m_commandBuffer, static_cast<VkPipelineBindPoint>( pipelineBindPoint ), static_cast<VkPipelineLayout>( layout ), set, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHX( uint32_t deviceMask ) const
-  {
-    vkCmdSetDeviceMaskKHX( m_commandBuffer, deviceMask );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHX( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const
-  {
-    vkCmdDispatchBaseKHX( m_commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void* pData ) const
-  {
-    vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), static_cast<VkPipelineLayout>( layout ), set, pData );
-  }
-
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, uint32_t viewportCount, const ViewportWScalingNV* pViewportWScalings ) const
-  {
-    vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportCount, reinterpret_cast<const VkViewportWScalingNV*>( pViewportWScalings ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, ArrayProxy<const ViewportWScalingNV> viewportWScalings ) const
-  {
-    vkCmdSetViewportWScalingNV( m_commandBuffer, firstViewport, viewportWScalings.size() , reinterpret_cast<const VkViewportWScalingNV*>( viewportWScalings.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const Rect2D* pDiscardRectangles ) const
-  {
-    vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangleCount, reinterpret_cast<const VkRect2D*>( pDiscardRectangles ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy<const Rect2D> discardRectangles ) const
-  {
-    vkCmdSetDiscardRectangleEXT( m_commandBuffer, firstDiscardRectangle, discardRectangles.size() , reinterpret_cast<const VkRect2D*>( discardRectangles.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT* pSampleLocationsInfo ) const
-  {
-    vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( pSampleLocationsInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const
-  {
-    vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast<const VkSampleLocationsInfoEXT*>( &sampleLocationsInfo ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  struct SubmitInfo
-  {
-    SubmitInfo( uint32_t waitSemaphoreCount_ = 0, const Semaphore* pWaitSemaphores_ = nullptr, const PipelineStageFlags* pWaitDstStageMask_ = nullptr, uint32_t commandBufferCount_ = 0, const CommandBuffer* pCommandBuffers_ = nullptr, uint32_t signalSemaphoreCount_ = 0, const Semaphore* pSignalSemaphores_ = nullptr )
-      : waitSemaphoreCount( waitSemaphoreCount_ )
-      , pWaitSemaphores( pWaitSemaphores_ )
-      , pWaitDstStageMask( pWaitDstStageMask_ )
-      , commandBufferCount( commandBufferCount_ )
-      , pCommandBuffers( pCommandBuffers_ )
-      , signalSemaphoreCount( signalSemaphoreCount_ )
-      , pSignalSemaphores( pSignalSemaphores_ )
-    {
-    }
-
-    SubmitInfo( VkSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubmitInfo ) );
-    }
-
-    SubmitInfo& operator=( VkSubmitInfo const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( SubmitInfo ) );
-      return *this;
-    }
-    SubmitInfo& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    SubmitInfo& setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ )
-    {
-      waitSemaphoreCount = waitSemaphoreCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPWaitSemaphores( const Semaphore* pWaitSemaphores_ )
-    {
-      pWaitSemaphores = pWaitSemaphores_;
-      return *this;
-    }
-
-    SubmitInfo& setPWaitDstStageMask( const PipelineStageFlags* pWaitDstStageMask_ )
-    {
-      pWaitDstStageMask = pWaitDstStageMask_;
-      return *this;
-    }
-
-    SubmitInfo& setCommandBufferCount( uint32_t commandBufferCount_ )
-    {
-      commandBufferCount = commandBufferCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPCommandBuffers( const CommandBuffer* pCommandBuffers_ )
-    {
-      pCommandBuffers = pCommandBuffers_;
-      return *this;
-    }
-
-    SubmitInfo& setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ )
-    {
-      signalSemaphoreCount = signalSemaphoreCount_;
-      return *this;
-    }
-
-    SubmitInfo& setPSignalSemaphores( const Semaphore* pSignalSemaphores_ )
-    {
-      pSignalSemaphores = pSignalSemaphores_;
-      return *this;
-    }
-
-    operator const VkSubmitInfo&() const
-    {
-      return *reinterpret_cast<const VkSubmitInfo*>(this);
-    }
-
-    bool operator==( SubmitInfo const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( waitSemaphoreCount == rhs.waitSemaphoreCount )
-          && ( pWaitSemaphores == rhs.pWaitSemaphores )
-          && ( pWaitDstStageMask == rhs.pWaitDstStageMask )
-          && ( commandBufferCount == rhs.commandBufferCount )
-          && ( pCommandBuffers == rhs.pCommandBuffers )
-          && ( signalSemaphoreCount == rhs.signalSemaphoreCount )
-          && ( pSignalSemaphores == rhs.pSignalSemaphores );
-    }
-
-    bool operator!=( SubmitInfo const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eSubmitInfo;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t waitSemaphoreCount;
-    const Semaphore* pWaitSemaphores;
-    const PipelineStageFlags* pWaitDstStageMask;
-    uint32_t commandBufferCount;
-    const CommandBuffer* pCommandBuffers;
-    uint32_t signalSemaphoreCount;
-    const Semaphore* pSignalSemaphores;
-  };
-  static_assert( sizeof( SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" );
-
-  class Queue
-  {
-  public:
-    Queue()
-      : m_queue(VK_NULL_HANDLE)
-    {}
-
-    Queue( std::nullptr_t )
-      : m_queue(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Queue( VkQueue queue )
-      : m_queue( queue )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Queue & operator=(VkQueue queue)
-    {
-      m_queue = queue;
-      return *this; 
-    }
-#endif
-
-    Queue & operator=( std::nullptr_t )
-    {
-      m_queue = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Queue const & rhs ) const
-    {
-      return m_queue == rhs.m_queue;
-    }
-
-    bool operator!=(Queue const & rhs ) const
-    {
-      return m_queue != rhs.m_queue;
-    }
-
-    bool operator<(Queue const & rhs ) const
-    {
-      return m_queue < rhs.m_queue;
-    }
-
-    Result submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type submit( ArrayProxy<const SubmitInfo> submits, Fence fence ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result waitIdle() const;
-#else
-    ResultValueType<void>::type waitIdle() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result presentKHR( const PresentInfoKHR* pPresentInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result presentKHR( const PresentInfoKHR & presentInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueue() const
-    {
-      return m_queue;
-    }
-
-    explicit operator bool() const
-    {
-      return m_queue != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_queue == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkQueue m_queue;
-  };
-
-  static_assert( sizeof( Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" );
-
-  VULKAN_HPP_INLINE Result Queue::submit( uint32_t submitCount, const SubmitInfo* pSubmits, Fence fence ) const
-  {
-    return static_cast<Result>( vkQueueSubmit( m_queue, submitCount, reinterpret_cast<const VkSubmitInfo*>( pSubmits ), static_cast<VkFence>( fence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::submit( ArrayProxy<const SubmitInfo> submits, Fence fence ) const
-  {
-    Result result = static_cast<Result>( vkQueueSubmit( m_queue, submits.size() , reinterpret_cast<const VkSubmitInfo*>( submits.data() ), static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::submit" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Queue::waitIdle() const
-  {
-    return static_cast<Result>( vkQueueWaitIdle( m_queue ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::waitIdle() const
-  {
-    Result result = static_cast<Result>( vkQueueWaitIdle( m_queue ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::waitIdle" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo* pBindInfo, Fence fence ) const
-  {
-    return static_cast<Result>( vkQueueBindSparse( m_queue, bindInfoCount, reinterpret_cast<const VkBindSparseInfo*>( pBindInfo ), static_cast<VkFence>( fence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Queue::bindSparse( ArrayProxy<const BindSparseInfo> bindInfo, Fence fence ) const
-  {
-    Result result = static_cast<Result>( vkQueueBindSparse( m_queue, bindInfo.size() , reinterpret_cast<const VkBindSparseInfo*>( bindInfo.data() ), static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::bindSparse" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR* pPresentInfo ) const
-  {
-    return static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( pPresentInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo ) const
-  {
-    Result result = static_cast<Result>( vkQueuePresentKHR( m_queue, reinterpret_cast<const VkPresentInfoKHR*>( &presentInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class BufferDeleter;
-  template <> class UniqueHandleTraits<Buffer> {public: using deleter = BufferDeleter; };
-  using UniqueBuffer = UniqueHandle<Buffer>;
-  class BufferViewDeleter;
-  template <> class UniqueHandleTraits<BufferView> {public: using deleter = BufferViewDeleter; };
-  using UniqueBufferView = UniqueHandle<BufferView>;
-  class CommandBufferDeleter;
-  template <> class UniqueHandleTraits<CommandBuffer> {public: using deleter = CommandBufferDeleter; };
-  using UniqueCommandBuffer = UniqueHandle<CommandBuffer>;
-  class CommandPoolDeleter;
-  template <> class UniqueHandleTraits<CommandPool> {public: using deleter = CommandPoolDeleter; };
-  using UniqueCommandPool = UniqueHandle<CommandPool>;
-  class DescriptorPoolDeleter;
-  template <> class UniqueHandleTraits<DescriptorPool> {public: using deleter = DescriptorPoolDeleter; };
-  using UniqueDescriptorPool = UniqueHandle<DescriptorPool>;
-  class DescriptorSetDeleter;
-  template <> class UniqueHandleTraits<DescriptorSet> {public: using deleter = DescriptorSetDeleter; };
-  using UniqueDescriptorSet = UniqueHandle<DescriptorSet>;
-  class DescriptorSetLayoutDeleter;
-  template <> class UniqueHandleTraits<DescriptorSetLayout> {public: using deleter = DescriptorSetLayoutDeleter; };
-  using UniqueDescriptorSetLayout = UniqueHandle<DescriptorSetLayout>;
-  class DescriptorUpdateTemplateKHRDeleter;
-  template <> class UniqueHandleTraits<DescriptorUpdateTemplateKHR> {public: using deleter = DescriptorUpdateTemplateKHRDeleter; };
-  using UniqueDescriptorUpdateTemplateKHR = UniqueHandle<DescriptorUpdateTemplateKHR>;
-  class DeviceMemoryDeleter;
-  template <> class UniqueHandleTraits<DeviceMemory> {public: using deleter = DeviceMemoryDeleter; };
-  using UniqueDeviceMemory = UniqueHandle<DeviceMemory>;
-  class EventDeleter;
-  template <> class UniqueHandleTraits<Event> {public: using deleter = EventDeleter; };
-  using UniqueEvent = UniqueHandle<Event>;
-  class FenceDeleter;
-  template <> class UniqueHandleTraits<Fence> {public: using deleter = FenceDeleter; };
-  using UniqueFence = UniqueHandle<Fence>;
-  class FramebufferDeleter;
-  template <> class UniqueHandleTraits<Framebuffer> {public: using deleter = FramebufferDeleter; };
-  using UniqueFramebuffer = UniqueHandle<Framebuffer>;
-  class ImageDeleter;
-  template <> class UniqueHandleTraits<Image> {public: using deleter = ImageDeleter; };
-  using UniqueImage = UniqueHandle<Image>;
-  class ImageViewDeleter;
-  template <> class UniqueHandleTraits<ImageView> {public: using deleter = ImageViewDeleter; };
-  using UniqueImageView = UniqueHandle<ImageView>;
-  class IndirectCommandsLayoutNVXDeleter;
-  template <> class UniqueHandleTraits<IndirectCommandsLayoutNVX> {public: using deleter = IndirectCommandsLayoutNVXDeleter; };
-  using UniqueIndirectCommandsLayoutNVX = UniqueHandle<IndirectCommandsLayoutNVX>;
-  class ObjectTableNVXDeleter;
-  template <> class UniqueHandleTraits<ObjectTableNVX> {public: using deleter = ObjectTableNVXDeleter; };
-  using UniqueObjectTableNVX = UniqueHandle<ObjectTableNVX>;
-  class PipelineDeleter;
-  template <> class UniqueHandleTraits<Pipeline> {public: using deleter = PipelineDeleter; };
-  using UniquePipeline = UniqueHandle<Pipeline>;
-  class PipelineCacheDeleter;
-  template <> class UniqueHandleTraits<PipelineCache> {public: using deleter = PipelineCacheDeleter; };
-  using UniquePipelineCache = UniqueHandle<PipelineCache>;
-  class PipelineLayoutDeleter;
-  template <> class UniqueHandleTraits<PipelineLayout> {public: using deleter = PipelineLayoutDeleter; };
-  using UniquePipelineLayout = UniqueHandle<PipelineLayout>;
-  class QueryPoolDeleter;
-  template <> class UniqueHandleTraits<QueryPool> {public: using deleter = QueryPoolDeleter; };
-  using UniqueQueryPool = UniqueHandle<QueryPool>;
-  class RenderPassDeleter;
-  template <> class UniqueHandleTraits<RenderPass> {public: using deleter = RenderPassDeleter; };
-  using UniqueRenderPass = UniqueHandle<RenderPass>;
-  class SamplerDeleter;
-  template <> class UniqueHandleTraits<Sampler> {public: using deleter = SamplerDeleter; };
-  using UniqueSampler = UniqueHandle<Sampler>;
-  class SamplerYcbcrConversionKHRDeleter;
-  template <> class UniqueHandleTraits<SamplerYcbcrConversionKHR> {public: using deleter = SamplerYcbcrConversionKHRDeleter; };
-  using UniqueSamplerYcbcrConversionKHR = UniqueHandle<SamplerYcbcrConversionKHR>;
-  class SemaphoreDeleter;
-  template <> class UniqueHandleTraits<Semaphore> {public: using deleter = SemaphoreDeleter; };
-  using UniqueSemaphore = UniqueHandle<Semaphore>;
-  class ShaderModuleDeleter;
-  template <> class UniqueHandleTraits<ShaderModule> {public: using deleter = ShaderModuleDeleter; };
-  using UniqueShaderModule = UniqueHandle<ShaderModule>;
-  class SwapchainKHRDeleter;
-  template <> class UniqueHandleTraits<SwapchainKHR> {public: using deleter = SwapchainKHRDeleter; };
-  using UniqueSwapchainKHR = UniqueHandle<SwapchainKHR>;
-  class ValidationCacheEXTDeleter;
-  template <> class UniqueHandleTraits<ValidationCacheEXT> {public: using deleter = ValidationCacheEXTDeleter; };
-  using UniqueValidationCacheEXT = UniqueHandle<ValidationCacheEXT>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class Device
-  {
-  public:
-    Device()
-      : m_device(VK_NULL_HANDLE)
-    {}
-
-    Device( std::nullptr_t )
-      : m_device(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Device( VkDevice device )
-      : m_device( device )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Device & operator=(VkDevice device)
-    {
-      m_device = device;
-      return *this; 
-    }
-#endif
-
-    Device & operator=( std::nullptr_t )
-    {
-      m_device = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Device const & rhs ) const
-    {
-      return m_device == rhs.m_device;
-    }
-
-    bool operator!=(Device const & rhs ) const
-    {
-      return m_device != rhs.m_device;
-    }
-
-    bool operator<(Device const & rhs ) const
-    {
-      return m_device < rhs.m_device;
-    }
-
-    PFN_vkVoidFunction getProcAddr( const char* pName ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PFN_vkVoidFunction getProcAddr( const std::string & name ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroy( const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result waitIdle() const;
-#else
-    ResultValueType<void>::type waitIdle() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DeviceMemory>::type allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDeviceMemory>::type allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void*>::type mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags = MemoryMapFlags() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void unmapMemory( DeviceMemory memory ) const;
-
-    Result flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    DeviceSize getMemoryCommitment( DeviceMemory memory ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    MemoryRequirements getBufferMemoryRequirements( Buffer buffer ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const;
-#else
-    ResultValueType<void>::type bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    MemoryRequirements getImageMemoryRequirements( Image image ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const;
-#else
-    ResultValueType<void>::type bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements>> 
-    std::vector<SparseImageMemoryRequirements,Allocator> getImageSparseMemoryRequirements( Image image ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Fence>::type createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueFence>::type createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyFence( Fence fence, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result resetFences( uint32_t fenceCount, const Fence* pFences ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type resetFences( ArrayProxy<const Fence> fences ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getFenceStatus( Fence fence ) const;
-
-    Result waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Semaphore>::type createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSemaphore>::type createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Event>::type createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueEvent>::type createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyEvent( Event event, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyEvent( Event event, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getEventStatus( Event event ) const;
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result setEvent( Event event ) const;
-#else
-    ResultValueType<void>::type setEvent( Event event ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result resetEvent( Event event ) const;
-#else
-    ResultValueType<void>::type resetEvent( Event event ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<QueryPool>::type createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueQueryPool>::type createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename T>
-    Result getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Buffer>::type createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueBuffer>::type createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<BufferView>::type createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueBufferView>::type createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Image>::type createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueImage>::type createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyImage( Image image, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyImage( Image image, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    SubresourceLayout getImageSubresourceLayout( Image image, const ImageSubresource & subresource ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ImageView>::type createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueImageView>::type createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ShaderModule>::type createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueShaderModule>::type createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<PipelineCache>::type createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniquePipelineCache>::type createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getPipelineCacheData( PipelineCache pipelineCache ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Pipeline>> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<Pipeline>::type createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<Pipeline>> 
-    typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<UniquePipeline>::type createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Pipeline>> 
-    typename ResultValueType<std::vector<Pipeline,Allocator>>::type createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<Pipeline>::type createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<Pipeline>> 
-    typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<UniquePipeline>::type createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<PipelineLayout>::type createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniquePipelineLayout>::type createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Sampler>::type createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSampler>::type createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DescriptorSetLayout>::type createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDescriptorSetLayout>::type createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DescriptorPool>::type createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDescriptorPool>::type createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const;
-#else
-    ResultValueType<void>::type resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags = DescriptorPoolResetFlags() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DescriptorSet>> 
-    typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<DescriptorSet>> 
-    typename ResultValueType<std::vector<UniqueDescriptorSet,Allocator>>::type allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Framebuffer>::type createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueFramebuffer>::type createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<RenderPass>::type createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueRenderPass>::type createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Extent2D getRenderAreaGranularity( RenderPass renderPass ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<CommandPool>::type createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueCommandPool>::type createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const;
-#else
-    ResultValueType<void>::type resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<CommandBuffer>> 
-    typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<CommandBuffer>> 
-    typename ResultValueType<std::vector<UniqueCommandBuffer,Allocator>>::type allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SwapchainKHR>> 
-    typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<SwapchainKHR>::type createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    template <typename Allocator = std::allocator<SwapchainKHR>> 
-    typename ResultValueType<std::vector<UniqueSwapchainKHR,Allocator>>::type createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-    ResultValueType<UniqueSwapchainKHR>::type createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SwapchainKHR>::type createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSwapchainKHR>::type createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Image>> 
-    typename ResultValueType<std::vector<Image,Allocator>>::type getSwapchainImagesKHR( SwapchainKHR swapchain ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValue<uint32_t> acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<HANDLE>::type getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    Result createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<IndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueIndirectCommandsLayoutNVX>::type createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ObjectTableNVX>::type createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueObjectTableNVX>::type createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags ) const;
-#else
-    void trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags = CommandPoolTrimFlagsKHR() ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<HANDLE>::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<MemoryWin32HandlePropertiesKHR>::type getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    Result getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<int>::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<MemoryFdPropertiesKHR>::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<HANDLE>::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<int>::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<HANDLE>::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-    Result getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<int>::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Fence>::type registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Fence>::type registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValue<uint64_t> getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PeerMemoryFeatureFlagsKHX getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfoKHR* pBindInfos ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfoKHR> bindInfos ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfoKHR* pBindInfos ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfoKHR> bindInfos ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type getGroupPresentCapabilitiesKHX() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DeviceGroupPresentModeFlagsKHX>::type getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValue<uint32_t> acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DescriptorUpdateTemplateKHR>::type createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDescriptorUpdateTemplateKHR>::type createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const;
-
-    void setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSwapchainStatusKHR( SwapchainKHR swapchain ) const;
-
-    Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<RefreshCycleDurationGOOGLE>::type getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PastPresentationTimingGOOGLE>> 
-    typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    MemoryRequirements2KHR getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const;
-    template <typename ...T>
-    StructureChain<T...> getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    MemoryRequirements2KHR getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const;
-    template <typename ...T>
-    StructureChain<T...> getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageMemoryRequirements2KHR>> 
-    std::vector<SparseImageMemoryRequirements2KHR,Allocator> getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversionKHR* pYcbcrConversion ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SamplerYcbcrConversionKHR>::type createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSamplerYcbcrConversionKHR>::type createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ValidationCacheEXT>::type createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueValidationCacheEXT>::type createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<void>::type mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<uint8_t>> 
-    typename ResultValueType<std::vector<uint8_t,Allocator>>::type getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<MemoryHostPointerPropertiesEXT>::type getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDevice() const
-    {
-      return m_device;
-    }
-
-    explicit operator bool() const
-    {
-      return m_device != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_device == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkDevice m_device;
-  };
-
-  static_assert( sizeof( Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" );
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class BufferDeleter
-  {
-  public:
-    BufferDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Buffer buffer )
-    {
-      m_device.destroyBuffer( buffer, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class BufferViewDeleter
-  {
-  public:
-    BufferViewDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( BufferView bufferView )
-    {
-      m_device.destroyBufferView( bufferView, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class CommandBufferDeleter
-  {
-  public:
-    CommandBufferDeleter( Device device = Device(), CommandPool commandPool = CommandPool() )
-      : m_device( device )
-      , m_commandPool( commandPool )
-    {}
-
-    Device getDevice() const { return m_device; }
-    CommandPool getCommandPool() const { return m_commandPool; }
-
-  protected:
-    void destroy( CommandBuffer commandBuffer )
-    {
-      m_device.freeCommandBuffers( m_commandPool, commandBuffer );
-    }
-
-  private:
-    Device m_device;
-    CommandPool m_commandPool;
-  };
-
-  class CommandPoolDeleter
-  {
-  public:
-    CommandPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( CommandPool commandPool )
-    {
-      m_device.destroyCommandPool( commandPool, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class DescriptorPoolDeleter
-  {
-  public:
-    DescriptorPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( DescriptorPool descriptorPool )
-    {
-      m_device.destroyDescriptorPool( descriptorPool, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class DescriptorSetDeleter
-  {
-  public:
-    DescriptorSetDeleter( Device device = Device(), DescriptorPool descriptorPool = DescriptorPool() )
-      : m_device( device )
-      , m_descriptorPool( descriptorPool )
-    {}
-
-    Device getDevice() const { return m_device; }
-    DescriptorPool getDescriptorPool() const { return m_descriptorPool; }
-
-  protected:
-    void destroy( DescriptorSet descriptorSet )
-    {
-      m_device.freeDescriptorSets( m_descriptorPool, descriptorSet );
-    }
-
-  private:
-    Device m_device;
-    DescriptorPool m_descriptorPool;
-  };
-
-  class DescriptorSetLayoutDeleter
-  {
-  public:
-    DescriptorSetLayoutDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( DescriptorSetLayout descriptorSetLayout )
-    {
-      m_device.destroyDescriptorSetLayout( descriptorSetLayout, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class DescriptorUpdateTemplateKHRDeleter
-  {
-  public:
-    DescriptorUpdateTemplateKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( DescriptorUpdateTemplateKHR descriptorUpdateTemplateKHR )
-    {
-      m_device.destroyDescriptorUpdateTemplateKHR( descriptorUpdateTemplateKHR, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class DeviceMemoryDeleter
-  {
-  public:
-    DeviceMemoryDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( DeviceMemory deviceMemory )
-    {
-      m_device.freeMemory( deviceMemory, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class EventDeleter
-  {
-  public:
-    EventDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Event event )
-    {
-      m_device.destroyEvent( event, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class FenceDeleter
-  {
-  public:
-    FenceDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Fence fence )
-    {
-      m_device.destroyFence( fence, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class FramebufferDeleter
-  {
-  public:
-    FramebufferDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Framebuffer framebuffer )
-    {
-      m_device.destroyFramebuffer( framebuffer, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class ImageDeleter
-  {
-  public:
-    ImageDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Image image )
-    {
-      m_device.destroyImage( image, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class ImageViewDeleter
-  {
-  public:
-    ImageViewDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( ImageView imageView )
-    {
-      m_device.destroyImageView( imageView, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class IndirectCommandsLayoutNVXDeleter
-  {
-  public:
-    IndirectCommandsLayoutNVXDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( IndirectCommandsLayoutNVX indirectCommandsLayoutNVX )
-    {
-      m_device.destroyIndirectCommandsLayoutNVX( indirectCommandsLayoutNVX, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class ObjectTableNVXDeleter
-  {
-  public:
-    ObjectTableNVXDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( ObjectTableNVX objectTableNVX )
-    {
-      m_device.destroyObjectTableNVX( objectTableNVX, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class PipelineDeleter
-  {
-  public:
-    PipelineDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Pipeline pipeline )
-    {
-      m_device.destroyPipeline( pipeline, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class PipelineCacheDeleter
-  {
-  public:
-    PipelineCacheDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( PipelineCache pipelineCache )
-    {
-      m_device.destroyPipelineCache( pipelineCache, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class PipelineLayoutDeleter
-  {
-  public:
-    PipelineLayoutDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( PipelineLayout pipelineLayout )
-    {
-      m_device.destroyPipelineLayout( pipelineLayout, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class QueryPoolDeleter
-  {
-  public:
-    QueryPoolDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( QueryPool queryPool )
-    {
-      m_device.destroyQueryPool( queryPool, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class RenderPassDeleter
-  {
-  public:
-    RenderPassDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( RenderPass renderPass )
-    {
-      m_device.destroyRenderPass( renderPass, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class SamplerDeleter
-  {
-  public:
-    SamplerDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Sampler sampler )
-    {
-      m_device.destroySampler( sampler, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class SamplerYcbcrConversionKHRDeleter
-  {
-  public:
-    SamplerYcbcrConversionKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( SamplerYcbcrConversionKHR samplerYcbcrConversionKHR )
-    {
-      m_device.destroySamplerYcbcrConversionKHR( samplerYcbcrConversionKHR, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class SemaphoreDeleter
-  {
-  public:
-    SemaphoreDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Semaphore semaphore )
-    {
-      m_device.destroySemaphore( semaphore, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class ShaderModuleDeleter
-  {
-  public:
-    ShaderModuleDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( ShaderModule shaderModule )
-    {
-      m_device.destroyShaderModule( shaderModule, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class SwapchainKHRDeleter
-  {
-  public:
-    SwapchainKHRDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( SwapchainKHR swapchainKHR )
-    {
-      m_device.destroySwapchainKHR( swapchainKHR, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class ValidationCacheEXTDeleter
-  {
-  public:
-    ValidationCacheEXTDeleter( Device device = Device(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_device( device )
-      , m_allocator( allocator )
-    {}
-
-    Device getDevice() const { return m_device; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( ValidationCacheEXT validationCacheEXT )
-    {
-      m_device.destroyValidationCacheEXT( validationCacheEXT, m_allocator );
-    }
-
-  private:
-    Device m_device;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char* pName ) const
-  {
-    return vkGetDeviceProcAddr( m_device, pName );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const std::string & name ) const
-  {
-    return vkGetDeviceProcAddr( m_device, name.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroy( Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyDevice( m_device, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue* pQueue ) const
-  {
-    vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( pQueue ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const
-  {
-    Queue queue;
-    vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast<VkQueue*>( &queue ) );
-    return queue;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::waitIdle() const
-  {
-    return static_cast<Result>( vkDeviceWaitIdle( m_device ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::waitIdle() const
-  {
-    Result result = static_cast<Result>( vkDeviceWaitIdle( m_device ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::waitIdle" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo* pAllocateInfo, const AllocationCallbacks* pAllocator, DeviceMemory* pMemory ) const
-  {
-    return static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( pAllocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDeviceMemory*>( pMemory ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DeviceMemory>::type Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DeviceMemory memory;
-    Result result = static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
-    return createResultValue( result, memory, "VULKAN_HPP_NAMESPACE::Device::allocateMemory" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDeviceMemory>::type Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DeviceMemory memory;
-    Result result = static_cast<Result>( vkAllocateMemory( m_device, reinterpret_cast<const VkMemoryAllocateInfo*>( &allocateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDeviceMemory*>( &memory ) ) );
-
-    DeviceMemoryDeleter deleter( *this, allocator );
-    return createResultValue( result, memory, "VULKAN_HPP_NAMESPACE::Device::allocateMemoryUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks* pAllocator ) const
-  {
-    vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkFreeMemory( m_device, static_cast<VkDeviceMemory>( memory ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void** ppData ) const
-  {
-    return static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), ppData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void*>::type Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags ) const
-  {
-    void* pData;
-    Result result = static_cast<Result>( vkMapMemory( m_device, static_cast<VkDeviceMemory>( memory ), offset, size, static_cast<VkMemoryMapFlags>( flags ), &pData ) );
-    return createResultValue( result, pData, "VULKAN_HPP_NAMESPACE::Device::mapMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory ) const
-  {
-    vkUnmapMemory( m_device, static_cast<VkDeviceMemory>( memory ) );
-  }
-
-  VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const
-  {
-    return static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::flushMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const
-  {
-    Result result = static_cast<Result>( vkFlushMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::flushMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, const MappedMemoryRange* pMemoryRanges ) const
-  {
-    return static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRangeCount, reinterpret_cast<const VkMappedMemoryRange*>( pMemoryRanges ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::invalidateMappedMemoryRanges( ArrayProxy<const MappedMemoryRange> memoryRanges ) const
-  {
-    Result result = static_cast<Result>( vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size() , reinterpret_cast<const VkMappedMemoryRange*>( memoryRanges.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::invalidateMappedMemoryRanges" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize* pCommittedMemoryInBytes ) const
-  {
-    vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), pCommittedMemoryInBytes );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory ) const
-  {
-    DeviceSize committedMemoryInBytes;
-    vkGetDeviceMemoryCommitment( m_device, static_cast<VkDeviceMemory>( memory ), &committedMemoryInBytes );
-    return committedMemoryInBytes;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements* pMemoryRequirements ) const
-  {
-    vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer ) const
-  {
-    MemoryRequirements memoryRequirements;
-    vkGetBufferMemoryRequirements( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const
-  {
-    return static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset ) const
-  {
-    Result result = static_cast<Result>( vkBindBufferMemory( m_device, static_cast<VkBuffer>( buffer ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindBufferMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( Image image, MemoryRequirements* pMemoryRequirements ) const
-  {
-    vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image ) const
-  {
-    MemoryRequirements memoryRequirements;
-    vkGetImageMemoryRequirements( m_device, static_cast<VkImage>( image ), reinterpret_cast<VkMemoryRequirements*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const
-  {
-    return static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset ) const
-  {
-    Result result = static_cast<Result>( vkBindImageMemory( m_device, static_cast<VkImage>( image ), static_cast<VkDeviceMemory>( memory ), memoryOffset ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindImageMemory" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements* pSparseMemoryRequirements ) const
-  {
-    vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( pSparseMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements,Allocator> Device::getImageSparseMemoryRequirements( Image image ) const
-  {
-    std::vector<SparseImageMemoryRequirements,Allocator> sparseMemoryRequirements;
-    uint32_t sparseMemoryRequirementCount;
-    vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    vkGetImageSparseMemoryRequirements( m_device, static_cast<VkImage>( image ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
-  {
-    return static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::createFence( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::createFence" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueFence>::type Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( vkCreateFence( m_device, reinterpret_cast<const VkFenceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-
-    FenceDeleter deleter( *this, allocator );
-    return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::createFenceUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyFence( m_device, static_cast<VkFence>( fence ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence* pFences ) const
-  {
-    return static_cast<Result>( vkResetFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> fences ) const
-  {
-    Result result = static_cast<Result>( vkResetFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetFences" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence ) const
-  {
-    return static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence ) const
-  {
-    Result result = static_cast<Result>( vkGetFenceStatus( m_device, static_cast<VkFence>( fence ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::waitForFences( uint32_t fenceCount, const Fence* pFences, Bool32 waitAll, uint64_t timeout ) const
-  {
-    return static_cast<Result>( vkWaitForFences( m_device, fenceCount, reinterpret_cast<const VkFence*>( pFences ), waitAll, timeout ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy<const Fence> fences, Bool32 waitAll, uint64_t timeout ) const
-  {
-    Result result = static_cast<Result>( vkWaitForFences( m_device, fences.size() , reinterpret_cast<const VkFence*>( fences.data() ), waitAll, timeout ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::waitForFences", { Result::eSuccess, Result::eTimeout } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Semaphore* pSemaphore ) const
-  {
-    return static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSemaphore*>( pSemaphore ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Semaphore>::type Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Semaphore semaphore;
-    Result result = static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
-    return createResultValue( result, semaphore, "VULKAN_HPP_NAMESPACE::Device::createSemaphore" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSemaphore>::type Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Semaphore semaphore;
-    Result result = static_cast<Result>( vkCreateSemaphore( m_device, reinterpret_cast<const VkSemaphoreCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSemaphore*>( &semaphore ) ) );
-
-    SemaphoreDeleter deleter( *this, allocator );
-    return createResultValue( result, semaphore, "VULKAN_HPP_NAMESPACE::Device::createSemaphoreUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroySemaphore( m_device, static_cast<VkSemaphore>( semaphore ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Event* pEvent ) const
-  {
-    return static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkEvent*>( pEvent ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Event>::type Device::createEvent( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Event event;
-    Result result = static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
-    return createResultValue( result, event, "VULKAN_HPP_NAMESPACE::Device::createEvent" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueEvent>::type Device::createEventUnique( const EventCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Event event;
-    Result result = static_cast<Result>( vkCreateEvent( m_device, reinterpret_cast<const VkEventCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkEvent*>( &event ) ) );
-
-    EventDeleter deleter( *this, allocator );
-    return createResultValue( result, event, "VULKAN_HPP_NAMESPACE::Device::createEventUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyEvent( m_device, static_cast<VkEvent>( event ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event ) const
-  {
-    return static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE Result Device::getEventStatus( Event event ) const
-  {
-    Result result = static_cast<Result>( vkGetEventStatus( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::setEvent( Event event ) const
-  {
-    return static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::setEvent( Event event ) const
-  {
-    Result result = static_cast<Result>( vkSetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::setEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::resetEvent( Event event ) const
-  {
-    return static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetEvent( Event event ) const
-  {
-    Result result = static_cast<Result>( vkResetEvent( m_device, static_cast<VkEvent>( event ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetEvent" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, QueryPool* pQueryPool ) const
-  {
-    return static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkQueryPool*>( pQueryPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<QueryPool>::type Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    QueryPool queryPool;
-    Result result = static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
-    return createResultValue( result, queryPool, "VULKAN_HPP_NAMESPACE::Device::createQueryPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueQueryPool>::type Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    QueryPool queryPool;
-    Result result = static_cast<Result>( vkCreateQueryPool( m_device, reinterpret_cast<const VkQueryPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkQueryPool*>( &queryPool ) ) );
-
-    QueryPoolDeleter deleter( *this, allocator );
-    return createResultValue( result, queryPool, "VULKAN_HPP_NAMESPACE::Device::createQueryPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyQueryPool( m_device, static_cast<VkQueryPool>( queryPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, DeviceSize stride, QueryResultFlags flags ) const
-  {
-    return static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, dataSize, pData, stride, static_cast<VkQueryResultFlags>( flags ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename T>
-  VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, ArrayProxy<T> data, DeviceSize stride, QueryResultFlags flags ) const
-  {
-    Result result = static_cast<Result>( vkGetQueryPoolResults( m_device, static_cast<VkQueryPool>( queryPool ), firstQuery, queryCount, data.size() * sizeof( T ) , reinterpret_cast<void*>( data.data() ), stride, static_cast<VkQueryResultFlags>( flags ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Buffer* pBuffer ) const
-  {
-    return static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBuffer*>( pBuffer ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Buffer>::type Device::createBuffer( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Buffer buffer;
-    Result result = static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
-    return createResultValue( result, buffer, "VULKAN_HPP_NAMESPACE::Device::createBuffer" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueBuffer>::type Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Buffer buffer;
-    Result result = static_cast<Result>( vkCreateBuffer( m_device, reinterpret_cast<const VkBufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBuffer*>( &buffer ) ) );
-
-    BufferDeleter deleter( *this, allocator );
-    return createResultValue( result, buffer, "VULKAN_HPP_NAMESPACE::Device::createBufferUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyBuffer( m_device, static_cast<VkBuffer>( buffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, BufferView* pView ) const
-  {
-    return static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkBufferView*>( pView ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<BufferView>::type Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    BufferView view;
-    Result result = static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
-    return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createBufferView" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueBufferView>::type Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    BufferView view;
-    Result result = static_cast<Result>( vkCreateBufferView( m_device, reinterpret_cast<const VkBufferViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkBufferView*>( &view ) ) );
-
-    BufferViewDeleter deleter( *this, allocator );
-    return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createBufferViewUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyBufferView( BufferView bufferView, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyBufferView( m_device, static_cast<VkBufferView>( bufferView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Image* pImage ) const
-  {
-    return static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImage*>( pImage ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Image>::type Device::createImage( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Image image;
-    Result result = static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
-    return createResultValue( result, image, "VULKAN_HPP_NAMESPACE::Device::createImage" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueImage>::type Device::createImageUnique( const ImageCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Image image;
-    Result result = static_cast<Result>( vkCreateImage( m_device, reinterpret_cast<const VkImageCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImage*>( &image ) ) );
-
-    ImageDeleter deleter( *this, allocator );
-    return createResultValue( result, image, "VULKAN_HPP_NAMESPACE::Device::createImageUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyImage( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, const ImageSubresource* pSubresource, SubresourceLayout* pLayout ) const
-  {
-    vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( pSubresource ), reinterpret_cast<VkSubresourceLayout*>( pLayout ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, const ImageSubresource & subresource ) const
-  {
-    SubresourceLayout layout;
-    vkGetImageSubresourceLayout( m_device, static_cast<VkImage>( image ), reinterpret_cast<const VkImageSubresource*>( &subresource ), reinterpret_cast<VkSubresourceLayout*>( &layout ) );
-    return layout;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ImageView* pView ) const
-  {
-    return static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkImageView*>( pView ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ImageView>::type Device::createImageView( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ImageView view;
-    Result result = static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
-    return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createImageView" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueImageView>::type Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ImageView view;
-    Result result = static_cast<Result>( vkCreateImageView( m_device, reinterpret_cast<const VkImageViewCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkImageView*>( &view ) ) );
-
-    ImageViewDeleter deleter( *this, allocator );
-    return createResultValue( result, view, "VULKAN_HPP_NAMESPACE::Device::createImageViewUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyImageView( m_device, static_cast<VkImageView>( imageView ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, ShaderModule* pShaderModule ) const
-  {
-    return static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkShaderModule*>( pShaderModule ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ShaderModule>::type Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ShaderModule shaderModule;
-    Result result = static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
-    return createResultValue( result, shaderModule, "VULKAN_HPP_NAMESPACE::Device::createShaderModule" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueShaderModule>::type Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ShaderModule shaderModule;
-    Result result = static_cast<Result>( vkCreateShaderModule( m_device, reinterpret_cast<const VkShaderModuleCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkShaderModule*>( &shaderModule ) ) );
-
-    ShaderModuleDeleter deleter( *this, allocator );
-    return createResultValue( result, shaderModule, "VULKAN_HPP_NAMESPACE::Device::createShaderModuleUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyShaderModule( ShaderModule shaderModule, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyShaderModule( m_device, static_cast<VkShaderModule>( shaderModule ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineCache* pPipelineCache ) const
-  {
-    return static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineCache*>( pPipelineCache ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<PipelineCache>::type Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    PipelineCache pipelineCache;
-    Result result = static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
-    return createResultValue( result, pipelineCache, "VULKAN_HPP_NAMESPACE::Device::createPipelineCache" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniquePipelineCache>::type Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    PipelineCache pipelineCache;
-    Result result = static_cast<Result>( vkCreatePipelineCache( m_device, reinterpret_cast<const VkPipelineCacheCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineCache*>( &pipelineCache ) ) );
-
-    PipelineCacheDeleter deleter( *this, allocator );
-    return createResultValue( result, pipelineCache, "VULKAN_HPP_NAMESPACE::Device::createPipelineCacheUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyPipelineCache( PipelineCache pipelineCache, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyPipelineCache( m_device, static_cast<VkPipelineCache>( pipelineCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getPipelineCacheData( PipelineCache pipelineCache, size_t* pDataSize, void* pData ) const
-  {
-    return static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), pDataSize, pData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getPipelineCacheData( PipelineCache pipelineCache ) const
-  {
-    std::vector<uint8_t,Allocator> data;
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( vkGetPipelineCacheData( m_device, static_cast<VkPipelineCache>( pipelineCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( dataSize <= data.size() );
-    data.resize( dataSize );
-    return createResultValue( result, data, "VULKAN_HPP_NAMESPACE::Device::getPipelineCacheData" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, uint32_t srcCacheCount, const PipelineCache* pSrcCaches ) const
-  {
-    return static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCacheCount, reinterpret_cast<const VkPipelineCache*>( pSrcCaches ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy<const PipelineCache> srcCaches ) const
-  {
-    Result result = static_cast<Result>( vkMergePipelineCaches( m_device, static_cast<VkPipelineCache>( dstCache ), srcCaches.size() , reinterpret_cast<const VkPipelineCache*>( srcCaches.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::mergePipelineCaches" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const GraphicsPipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const
-  {
-    return static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createGraphicsPipelines( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelines" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createGraphicsPipeline( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-    return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipeline" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const GraphicsPipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-
-    PipelineDeleter deleter( *this, allocator );
-    std::vector<UniquePipeline> uniquePipelines;
-    uniquePipelines.reserve( pipelines.size() );
-    for ( auto const& pipeline : pipelines )
-    {
-      uniquePipelines.push_back( UniquePipeline( pipeline, deleter ) );
-    }
-
-    return createResultValue( result, uniquePipelines, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelinesUnique" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<UniquePipeline>::type Device::createGraphicsPipelineUnique( PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( vkCreateGraphicsPipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkGraphicsPipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-
-    PipelineDeleter deleter( *this, allocator );
-    return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createGraphicsPipelineUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, uint32_t createInfoCount, const ComputePipelineCreateInfo* pCreateInfos, const AllocationCallbacks* pAllocator, Pipeline* pPipelines ) const
-  {
-    return static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfoCount, reinterpret_cast<const VkComputePipelineCreateInfo*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipeline*>( pPipelines ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Pipeline,Allocator>>::type Device::createComputePipelines( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-    return createResultValue( result, pipelines, "VULKAN_HPP_NAMESPACE::Device::createComputePipelines" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<Pipeline>::type Device::createComputePipeline( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-    return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createComputePipeline" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniquePipeline,Allocator>>::type Device::createComputePipelinesUnique( PipelineCache pipelineCache, ArrayProxy<const ComputePipelineCreateInfo> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<Pipeline,Allocator> pipelines( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), createInfos.size() , reinterpret_cast<const VkComputePipelineCreateInfo*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( pipelines.data() ) ) );
-
-    PipelineDeleter deleter( *this, allocator );
-    std::vector<UniquePipeline> uniquePipelines;
-    uniquePipelines.reserve( pipelines.size() );
-    for ( auto const& pipeline : pipelines )
-    {
-      uniquePipelines.push_back( UniquePipeline( pipeline, deleter ) );
-    }
-
-    return createResultValue( result, uniquePipelines, "VULKAN_HPP_NAMESPACE::Device::createComputePipelinesUnique" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<UniquePipeline>::type Device::createComputePipelineUnique( PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Pipeline pipeline;
-    Result result = static_cast<Result>( vkCreateComputePipelines( m_device, static_cast<VkPipelineCache>( pipelineCache ), 1 , reinterpret_cast<const VkComputePipelineCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipeline*>( &pipeline ) ) );
-
-    PipelineDeleter deleter( *this, allocator );
-    return createResultValue( result, pipeline, "VULKAN_HPP_NAMESPACE::Device::createComputePipelineUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyPipeline( m_device, static_cast<VkPipeline>( pipeline ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, PipelineLayout* pPipelineLayout ) const
-  {
-    return static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkPipelineLayout*>( pPipelineLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<PipelineLayout>::type Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    PipelineLayout pipelineLayout;
-    Result result = static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
-    return createResultValue( result, pipelineLayout, "VULKAN_HPP_NAMESPACE::Device::createPipelineLayout" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniquePipelineLayout>::type Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    PipelineLayout pipelineLayout;
-    Result result = static_cast<Result>( vkCreatePipelineLayout( m_device, reinterpret_cast<const VkPipelineLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkPipelineLayout*>( &pipelineLayout ) ) );
-
-    PipelineLayoutDeleter deleter( *this, allocator );
-    return createResultValue( result, pipelineLayout, "VULKAN_HPP_NAMESPACE::Device::createPipelineLayoutUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyPipelineLayout( m_device, static_cast<VkPipelineLayout>( pipelineLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Sampler* pSampler ) const
-  {
-    return static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSampler*>( pSampler ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Sampler>::type Device::createSampler( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Sampler sampler;
-    Result result = static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
-    return createResultValue( result, sampler, "VULKAN_HPP_NAMESPACE::Device::createSampler" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSampler>::type Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Sampler sampler;
-    Result result = static_cast<Result>( vkCreateSampler( m_device, reinterpret_cast<const VkSamplerCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSampler*>( &sampler ) ) );
-
-    SamplerDeleter deleter( *this, allocator );
-    return createResultValue( result, sampler, "VULKAN_HPP_NAMESPACE::Device::createSamplerUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroySampler( m_device, static_cast<VkSampler>( sampler ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorSetLayout* pSetLayout ) const
-  {
-    return static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorSetLayout*>( pSetLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DescriptorSetLayout>::type Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorSetLayout setLayout;
-    Result result = static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
-    return createResultValue( result, setLayout, "VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayout" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorSetLayout>::type Device::createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorSetLayout setLayout;
-    Result result = static_cast<Result>( vkCreateDescriptorSetLayout( m_device, reinterpret_cast<const VkDescriptorSetLayoutCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorSetLayout*>( &setLayout ) ) );
-
-    DescriptorSetLayoutDeleter deleter( *this, allocator );
-    return createResultValue( result, setLayout, "VULKAN_HPP_NAMESPACE::Device::createDescriptorSetLayoutUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyDescriptorSetLayout( m_device, static_cast<VkDescriptorSetLayout>( descriptorSetLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorPool* pDescriptorPool ) const
-  {
-    return static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorPool*>( pDescriptorPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DescriptorPool>::type Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorPool descriptorPool;
-    Result result = static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
-    return createResultValue( result, descriptorPool, "VULKAN_HPP_NAMESPACE::Device::createDescriptorPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorPool>::type Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorPool descriptorPool;
-    Result result = static_cast<Result>( vkCreateDescriptorPool( m_device, reinterpret_cast<const VkDescriptorPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorPool*>( &descriptorPool ) ) );
-
-    DescriptorPoolDeleter deleter( *this, allocator );
-    return createResultValue( result, descriptorPool, "VULKAN_HPP_NAMESPACE::Device::createDescriptorPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const
-  {
-    return static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags ) const
-  {
-    Result result = static_cast<Result>( vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetDescriptorPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo* pAllocateInfo, DescriptorSet* pDescriptorSets ) const
-  {
-    return static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkDescriptorSet*>( pDescriptorSets ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DescriptorSet,Allocator>>::type Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo ) const
-  {
-    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result result = static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, descriptorSets, "VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSets" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueDescriptorSet,Allocator>>::type Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo ) const
-  {
-    std::vector<DescriptorSet,Allocator> descriptorSets( allocateInfo.descriptorSetCount );
-    Result result = static_cast<Result>( vkAllocateDescriptorSets( m_device, reinterpret_cast<const VkDescriptorSetAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkDescriptorSet*>( descriptorSets.data() ) ) );
-
-    DescriptorSetDeleter deleter( *this, allocateInfo.descriptorPool );
-    std::vector<UniqueDescriptorSet> uniqueDescriptorSets;
-    uniqueDescriptorSets.reserve( descriptorSets.size() );
-    for ( auto const& descriptorSet : descriptorSets )
-    {
-      uniqueDescriptorSets.push_back( UniqueDescriptorSet( descriptorSet, deleter ) );
-    }
-
-    return createResultValue( result, uniqueDescriptorSets, "VULKAN_HPP_NAMESPACE::Device::allocateDescriptorSetsUnique" );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, uint32_t descriptorSetCount, const DescriptorSet* pDescriptorSets ) const
-  {
-    return static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSetCount, reinterpret_cast<const VkDescriptorSet*>( pDescriptorSets ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> descriptorSets ) const
-  {
-    Result result = static_cast<Result>( vkFreeDescriptorSets( m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size() , reinterpret_cast<const VkDescriptorSet*>( descriptorSets.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::freeDescriptorSets" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, const WriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const CopyDescriptorSet* pDescriptorCopies ) const
-  {
-    vkUpdateDescriptorSets( m_device, descriptorWriteCount, reinterpret_cast<const VkWriteDescriptorSet*>( pDescriptorWrites ), descriptorCopyCount, reinterpret_cast<const VkCopyDescriptorSet*>( pDescriptorCopies ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy<const WriteDescriptorSet> descriptorWrites, ArrayProxy<const CopyDescriptorSet> descriptorCopies ) const
-  {
-    vkUpdateDescriptorSets( m_device, descriptorWrites.size() , reinterpret_cast<const VkWriteDescriptorSet*>( descriptorWrites.data() ), descriptorCopies.size() , reinterpret_cast<const VkCopyDescriptorSet*>( descriptorCopies.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Framebuffer* pFramebuffer ) const
-  {
-    return static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFramebuffer*>( pFramebuffer ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Framebuffer>::type Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Framebuffer framebuffer;
-    Result result = static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
-    return createResultValue( result, framebuffer, "VULKAN_HPP_NAMESPACE::Device::createFramebuffer" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueFramebuffer>::type Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Framebuffer framebuffer;
-    Result result = static_cast<Result>( vkCreateFramebuffer( m_device, reinterpret_cast<const VkFramebufferCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFramebuffer*>( &framebuffer ) ) );
-
-    FramebufferDeleter deleter( *this, allocator );
-    return createResultValue( result, framebuffer, "VULKAN_HPP_NAMESPACE::Device::createFramebufferUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyFramebuffer( Framebuffer framebuffer, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyFramebuffer( m_device, static_cast<VkFramebuffer>( framebuffer ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, RenderPass* pRenderPass ) const
-  {
-    return static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkRenderPass*>( pRenderPass ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<RenderPass>::type Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-    return createResultValue( result, renderPass, "VULKAN_HPP_NAMESPACE::Device::createRenderPass" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueRenderPass>::type Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    RenderPass renderPass;
-    Result result = static_cast<Result>( vkCreateRenderPass( m_device, reinterpret_cast<const VkRenderPassCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkRenderPass*>( &renderPass ) ) );
-
-    RenderPassDeleter deleter( *this, allocator );
-    return createResultValue( result, renderPass, "VULKAN_HPP_NAMESPACE::Device::createRenderPassUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyRenderPass( RenderPass renderPass, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyRenderPass( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D* pGranularity ) const
-  {
-    vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( pGranularity ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass ) const
-  {
-    Extent2D granularity;
-    vkGetRenderAreaGranularity( m_device, static_cast<VkRenderPass>( renderPass ), reinterpret_cast<VkExtent2D*>( &granularity ) );
-    return granularity;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, CommandPool* pCommandPool ) const
-  {
-    return static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkCommandPool*>( pCommandPool ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<CommandPool>::type Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    CommandPool commandPool;
-    Result result = static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
-    return createResultValue( result, commandPool, "VULKAN_HPP_NAMESPACE::Device::createCommandPool" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueCommandPool>::type Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    CommandPool commandPool;
-    Result result = static_cast<Result>( vkCreateCommandPool( m_device, reinterpret_cast<const VkCommandPoolCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkCommandPool*>( &commandPool ) ) );
-
-    CommandPoolDeleter deleter( *this, allocator );
-    return createResultValue( result, commandPool, "VULKAN_HPP_NAMESPACE::Device::createCommandPoolUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyCommandPool( CommandPool commandPool, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const
-  {
-    return static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags ) const
-  {
-    Result result = static_cast<Result>( vkResetCommandPool( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolResetFlags>( flags ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::resetCommandPool" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo* pAllocateInfo, CommandBuffer* pCommandBuffers ) const
-  {
-    return static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( pAllocateInfo ), reinterpret_cast<VkCommandBuffer*>( pCommandBuffers ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<CommandBuffer,Allocator>>::type Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo ) const
-  {
-    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result result = static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
-    return createResultValue( result, commandBuffers, "VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffers" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueCommandBuffer,Allocator>>::type Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo ) const
-  {
-    std::vector<CommandBuffer,Allocator> commandBuffers( allocateInfo.commandBufferCount );
-    Result result = static_cast<Result>( vkAllocateCommandBuffers( m_device, reinterpret_cast<const VkCommandBufferAllocateInfo*>( &allocateInfo ), reinterpret_cast<VkCommandBuffer*>( commandBuffers.data() ) ) );
-
-    CommandBufferDeleter deleter( *this, allocateInfo.commandPool );
-    std::vector<UniqueCommandBuffer> uniqueCommandBuffers;
-    uniqueCommandBuffers.reserve( commandBuffers.size() );
-    for ( auto const& commandBuffer : commandBuffers )
-    {
-      uniqueCommandBuffers.push_back( UniqueCommandBuffer( commandBuffer, deleter ) );
-    }
-
-    return createResultValue( result, uniqueCommandBuffers, "VULKAN_HPP_NAMESPACE::Device::allocateCommandBuffersUnique" );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, uint32_t commandBufferCount, const CommandBuffer* pCommandBuffers ) const
-  {
-    vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBufferCount, reinterpret_cast<const VkCommandBuffer*>( pCommandBuffers ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy<const CommandBuffer> commandBuffers ) const
-  {
-    vkFreeCommandBuffers( m_device, static_cast<VkCommandPool>( commandPool ), commandBuffers.size() , reinterpret_cast<const VkCommandBuffer*>( commandBuffers.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, const SwapchainCreateInfoKHR* pCreateInfos, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchains ) const
-  {
-    return static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, swapchainCount, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfos ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchains ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHR( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
-    return createResultValue( result, swapchains, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHR" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-    return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<UniqueSwapchainKHR,Allocator>>::type Device::createSharedSwapchainsKHRUnique( ArrayProxy<const SwapchainCreateInfoKHR> createInfos, Optional<const AllocationCallbacks> allocator ) const
-  {
-    std::vector<SwapchainKHR,Allocator> swapchains( createInfos.size() );
-    Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, createInfos.size() , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( createInfos.data() ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( swapchains.data() ) ) );
-
-    SwapchainKHRDeleter deleter( *this, allocator );
-    std::vector<UniqueSwapchainKHR> uniqueSwapchains;
-    uniqueSwapchains.reserve( swapchains.size() );
-    for ( auto const& swapchain : swapchains )
-    {
-      uniqueSwapchains.push_back( UniqueSwapchainKHR( swapchain, deleter ) );
-    }
-
-    return createResultValue( result, uniqueSwapchains, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainsKHRUnique" );
-  }
-  VULKAN_HPP_INLINE ResultValueType<UniqueSwapchainKHR>::type Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( vkCreateSharedSwapchainsKHR( m_device, 1 , reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-
-    SwapchainKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSharedSwapchainKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SwapchainKHR* pSwapchain ) const
-  {
-    return static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSwapchainKHR*>( pSwapchain ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SwapchainKHR>::type Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-    return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSwapchainKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSwapchainKHR>::type Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SwapchainKHR swapchain;
-    Result result = static_cast<Result>( vkCreateSwapchainKHR( m_device, reinterpret_cast<const VkSwapchainCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSwapchainKHR*>( &swapchain ) ) );
-
-    SwapchainKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, swapchain, "VULKAN_HPP_NAMESPACE::Device::createSwapchainKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroySwapchainKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, uint32_t* pSwapchainImageCount, Image* pSwapchainImages ) const
-  {
-    return static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), pSwapchainImageCount, reinterpret_cast<VkImage*>( pSwapchainImages ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Image,Allocator>>::type Device::getSwapchainImagesKHR( SwapchainKHR swapchain ) const
-  {
-    std::vector<Image,Allocator> swapchainImages;
-    uint32_t swapchainImageCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && swapchainImageCount )
-      {
-        swapchainImages.resize( swapchainImageCount );
-        result = static_cast<Result>( vkGetSwapchainImagesKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), &swapchainImageCount, reinterpret_cast<VkImage*>( swapchainImages.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( swapchainImageCount <= swapchainImages.size() );
-    swapchainImages.resize( swapchainImageCount );
-    return createResultValue( result, swapchainImages, "VULKAN_HPP_NAMESPACE::Device::getSwapchainImagesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t* pImageIndex ) const
-  {
-    return static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), pImageIndex ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence ) const
-  {
-    uint32_t imageIndex;
-    Result result = static_cast<Result>( vkAcquireNextImageKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ), timeout, static_cast<VkSemaphore>( semaphore ), static_cast<VkFence>( fence ), &imageIndex ) );
-    return createResultValue( result, imageIndex, "VULKAN_HPP_NAMESPACE::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT* pNameInfo ) const
-  {
-    return static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( pNameInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const
-  {
-    Result result = static_cast<Result>( vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectNameInfoEXT*>( &nameInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectNameEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT* pTagInfo ) const
-  {
-    return static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( pTagInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const
-  {
-    Result result = static_cast<Result>( vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast<const VkDebugMarkerObjectTagInfoEXT*>( &tagInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::debugMarkerSetObjectTagEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle ) const
-  {
-    return static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( vkGetMemoryWin32HandleNV( m_device, static_cast<VkDeviceMemory>( memory ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( handleType ), &handle ) );
-    return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandleNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, IndirectCommandsLayoutNVX* pIndirectCommandsLayout ) const
-  {
-    return static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( pIndirectCommandsLayout ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<IndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVX( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    Result result = static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
-    return createResultValue( result, indirectCommandsLayout, "VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNVX" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueIndirectCommandsLayoutNVX>::type Device::createIndirectCommandsLayoutNVXUnique( const IndirectCommandsLayoutCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    Result result = static_cast<Result>( vkCreateIndirectCommandsLayoutNVX( m_device, reinterpret_cast<const VkIndirectCommandsLayoutCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkIndirectCommandsLayoutNVX*>( &indirectCommandsLayout ) ) );
-
-    IndirectCommandsLayoutNVXDeleter deleter( *this, allocator );
-    return createResultValue( result, indirectCommandsLayout, "VULKAN_HPP_NAMESPACE::Device::createIndirectCommandsLayoutNVXUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNVX( IndirectCommandsLayoutNVX indirectCommandsLayout, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyIndirectCommandsLayoutNVX( m_device, static_cast<VkIndirectCommandsLayoutNVX>( indirectCommandsLayout ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createObjectTableNVX( const ObjectTableCreateInfoNVX* pCreateInfo, const AllocationCallbacks* pAllocator, ObjectTableNVX* pObjectTable ) const
-  {
-    return static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkObjectTableNVX*>( pObjectTable ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ObjectTableNVX>::type Device::createObjectTableNVX( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ObjectTableNVX objectTable;
-    Result result = static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
-    return createResultValue( result, objectTable, "VULKAN_HPP_NAMESPACE::Device::createObjectTableNVX" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueObjectTableNVX>::type Device::createObjectTableNVXUnique( const ObjectTableCreateInfoNVX & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ObjectTableNVX objectTable;
-    Result result = static_cast<Result>( vkCreateObjectTableNVX( m_device, reinterpret_cast<const VkObjectTableCreateInfoNVX*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkObjectTableNVX*>( &objectTable ) ) );
-
-    ObjectTableNVXDeleter deleter( *this, allocator );
-    return createResultValue( result, objectTable, "VULKAN_HPP_NAMESPACE::Device::createObjectTableNVXUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyObjectTableNVX( ObjectTableNVX objectTable, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyObjectTableNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::registerObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectTableEntryNVX* const* ppObjectTableEntries, const uint32_t* pObjectIndices ) const
-  {
-    return static_cast<Result>( vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectTableEntryNVX* const*>( ppObjectTableEntries ), pObjectIndices ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::registerObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectTableEntryNVX* const> pObjectTableEntries, ArrayProxy<const uint32_t> objectIndices ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( pObjectTableEntries.size() == objectIndices.size() );
-#else
-    if ( pObjectTableEntries.size() != objectIndices.size() )
-    {
-      throw LogicError( "VULKAN_HPP_NAMESPACE::Device::registerObjectsNVX: pObjectTableEntries.size() != objectIndices.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    Result result = static_cast<Result>( vkRegisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), pObjectTableEntries.size() , reinterpret_cast<const VkObjectTableEntryNVX* const*>( pObjectTableEntries.data() ), objectIndices.data() ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::registerObjectsNVX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::unregisterObjectsNVX( ObjectTableNVX objectTable, uint32_t objectCount, const ObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices ) const
-  {
-    return static_cast<Result>( vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectCount, reinterpret_cast<const VkObjectEntryTypeNVX*>( pObjectEntryTypes ), pObjectIndices ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::unregisterObjectsNVX( ObjectTableNVX objectTable, ArrayProxy<const ObjectEntryTypeNVX> objectEntryTypes, ArrayProxy<const uint32_t> objectIndices ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( objectEntryTypes.size() == objectIndices.size() );
-#else
-    if ( objectEntryTypes.size() != objectIndices.size() )
-    {
-      throw LogicError( "VULKAN_HPP_NAMESPACE::Device::unregisterObjectsNVX: objectEntryTypes.size() != objectIndices.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    Result result = static_cast<Result>( vkUnregisterObjectsNVX( m_device, static_cast<VkObjectTableNVX>( objectTable ), objectEntryTypes.size() , reinterpret_cast<const VkObjectEntryTypeNVX*>( objectEntryTypes.data() ), objectIndices.data() ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::unregisterObjectsNVX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlagsKHR flags ) const
-  {
-    vkTrimCommandPoolKHR( m_device, static_cast<VkCommandPool>( commandPool ), static_cast<VkCommandPoolTrimFlagsKHR>( flags ) );
-  }
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
-  {
-    return static_cast<Result>( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast<const VkMemoryGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, MemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties ) const
-  {
-    return static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( pMemoryWin32HandleProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<MemoryWin32HandlePropertiesKHR>::type Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle ) const
-  {
-    MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties;
-    Result result = static_cast<Result>( vkGetMemoryWin32HandlePropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), handle, reinterpret_cast<VkMemoryWin32HandlePropertiesKHR*>( &memoryWin32HandleProperties ) ) );
-    return createResultValue( result, memoryWin32HandleProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryWin32HandlePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR* pGetFdInfo, int* pFd ) const
-  {
-    return static_cast<Result>( vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( vkGetMemoryFdKHR( m_device, reinterpret_cast<const VkMemoryGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getMemoryFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, MemoryFdPropertiesKHR* pMemoryFdProperties ) const
-  {
-    return static_cast<Result>( vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( pMemoryFdProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<MemoryFdPropertiesKHR>::type Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBitsKHR handleType, int fd ) const
-  {
-    MemoryFdPropertiesKHR memoryFdProperties;
-    Result result = static_cast<Result>( vkGetMemoryFdPropertiesKHR( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), fd, reinterpret_cast<VkMemoryFdPropertiesKHR*>( &memoryFdProperties ) ) );
-    return createResultValue( result, memoryFdProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryFdPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
-  {
-    return static_cast<Result>( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkSemaphoreGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getSemaphoreWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo ) const
-  {
-    return static_cast<Result>( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( pImportSemaphoreWin32HandleInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const
-  {
-    Result result = static_cast<Result>( vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast<const VkImportSemaphoreWin32HandleInfoKHR*>( &importSemaphoreWin32HandleInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importSemaphoreWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd ) const
-  {
-    return static_cast<Result>( vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( vkGetSemaphoreFdKHR( m_device, reinterpret_cast<const VkSemaphoreGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo ) const
-  {
-    return static_cast<Result>( vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( pImportSemaphoreFdInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const
-  {
-    Result result = static_cast<Result>( vkImportSemaphoreFdKHR( m_device, reinterpret_cast<const VkImportSemaphoreFdInfoKHR*>( &importSemaphoreFdInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importSemaphoreFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle ) const
-  {
-    return static_cast<Result>( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( pGetWin32HandleInfo ), pHandle ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<HANDLE>::type Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const
-  {
-    HANDLE handle;
-    Result result = static_cast<Result>( vkGetFenceWin32HandleKHR( m_device, reinterpret_cast<const VkFenceGetWin32HandleInfoKHR*>( &getWin32HandleInfo ), &handle ) );
-    return createResultValue( result, handle, "VULKAN_HPP_NAMESPACE::Device::getFenceWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo ) const
-  {
-    return static_cast<Result>( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( pImportFenceWin32HandleInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const
-  {
-    Result result = static_cast<Result>( vkImportFenceWin32HandleKHR( m_device, reinterpret_cast<const VkImportFenceWin32HandleInfoKHR*>( &importFenceWin32HandleInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importFenceWin32HandleKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-  VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR* pGetFdInfo, int* pFd ) const
-  {
-    return static_cast<Result>( vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( pGetFdInfo ), pFd ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<int>::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const
-  {
-    int fd;
-    Result result = static_cast<Result>( vkGetFenceFdKHR( m_device, reinterpret_cast<const VkFenceGetFdInfoKHR*>( &getFdInfo ), &fd ) );
-    return createResultValue( result, fd, "VULKAN_HPP_NAMESPACE::Device::getFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR* pImportFenceFdInfo ) const
-  {
-    return static_cast<Result>( vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( pImportFenceFdInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const
-  {
-    Result result = static_cast<Result>( vkImportFenceFdKHR( m_device, reinterpret_cast<const VkImportFenceFdInfoKHR*>( &importFenceFdInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::importFenceFdKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT* pDisplayPowerInfo ) const
-  {
-    return static_cast<Result>( vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( pDisplayPowerInfo ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo ) const
-  {
-    Result result = static_cast<Result>( vkDisplayPowerControlEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayPowerInfoEXT*>( &displayPowerInfo ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::displayPowerControlEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT* pDeviceEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
-  {
-    return static_cast<Result>( vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( pDeviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( vkRegisterDeviceEventEXT( m_device, reinterpret_cast<const VkDeviceEventInfoEXT*>( &deviceEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::registerEventEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT* pDisplayEventInfo, const AllocationCallbacks* pAllocator, Fence* pFence ) const
-  {
-    return static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( pDisplayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkFence*>( pFence ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Fence>::type Device::registerDisplayEventEXT( DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Fence fence;
-    Result result = static_cast<Result>( vkRegisterDisplayEventEXT( m_device, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayEventInfoEXT*>( &displayEventInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkFence*>( &fence ) ) );
-    return createResultValue( result, fence, "VULKAN_HPP_NAMESPACE::Device::registerDisplayEventEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue ) const
-  {
-    return static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), pCounterValue ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValue<uint64_t> Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter ) const
-  {
-    uint64_t counterValue;
-    Result result = static_cast<Result>( vkGetSwapchainCounterEXT( m_device, static_cast<VkSwapchainKHR>( swapchain ), static_cast<VkSurfaceCounterFlagBitsEXT>( counter ), &counterValue ) );
-    return createResultValue( result, counterValue, "VULKAN_HPP_NAMESPACE::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorDeviceLost, Result::eErrorOutOfDateKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, PeerMemoryFeatureFlagsKHX* pPeerMemoryFeatures ) const
-  {
-    vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( pPeerMemoryFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PeerMemoryFeatureFlagsKHX Device::getGroupPeerMemoryFeaturesKHX( uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex ) const
-  {
-    PeerMemoryFeatureFlagsKHX peerMemoryFeatures;
-    vkGetDeviceGroupPeerMemoryFeaturesKHX( m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast<VkPeerMemoryFeatureFlagsKHX*>( &peerMemoryFeatures ) );
-    return peerMemoryFeatures;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, const BindBufferMemoryInfoKHR* pBindInfos ) const
-  {
-    return static_cast<Result>( vkBindBufferMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindBufferMemoryInfoKHR*>( pBindInfos ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindBufferMemory2KHR( ArrayProxy<const BindBufferMemoryInfoKHR> bindInfos ) const
-  {
-    Result result = static_cast<Result>( vkBindBufferMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindBufferMemoryInfoKHR*>( bindInfos.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindBufferMemory2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, const BindImageMemoryInfoKHR* pBindInfos ) const
-  {
-    return static_cast<Result>( vkBindImageMemory2KHR( m_device, bindInfoCount, reinterpret_cast<const VkBindImageMemoryInfoKHR*>( pBindInfos ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::bindImageMemory2KHR( ArrayProxy<const BindImageMemoryInfoKHR> bindInfos ) const
-  {
-    Result result = static_cast<Result>( vkBindImageMemory2KHR( m_device, bindInfos.size() , reinterpret_cast<const VkBindImageMemoryInfoKHR*>( bindInfos.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::bindImageMemory2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHX( DeviceGroupPresentCapabilitiesKHX* pDeviceGroupPresentCapabilities ) const
-  {
-    return static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( pDeviceGroupPresentCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentCapabilitiesKHX>::type Device::getGroupPresentCapabilitiesKHX() const
-  {
-    DeviceGroupPresentCapabilitiesKHX deviceGroupPresentCapabilities;
-    Result result = static_cast<Result>( vkGetDeviceGroupPresentCapabilitiesKHX( m_device, reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHX*>( &deviceGroupPresentCapabilities ) ) );
-    return createResultValue( result, deviceGroupPresentCapabilities, "VULKAN_HPP_NAMESPACE::Device::getGroupPresentCapabilitiesKHX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface, DeviceGroupPresentModeFlagsKHX* pModes ) const
-  {
-    return static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( pModes ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DeviceGroupPresentModeFlagsKHX>::type Device::getGroupSurfacePresentModesKHX( SurfaceKHR surface ) const
-  {
-    DeviceGroupPresentModeFlagsKHX modes;
-    Result result = static_cast<Result>( vkGetDeviceGroupSurfacePresentModesKHX( m_device, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkDeviceGroupPresentModeFlagsKHX*>( &modes ) ) );
-    return createResultValue( result, modes, "VULKAN_HPP_NAMESPACE::Device::getGroupSurfacePresentModesKHX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX* pAcquireInfo, uint32_t* pImageIndex ) const
-  {
-    return static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( pAcquireInfo ), pImageIndex ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValue<uint32_t> Device::acquireNextImage2KHX( const AcquireNextImageInfoKHX & acquireInfo ) const
-  {
-    uint32_t imageIndex;
-    Result result = static_cast<Result>( vkAcquireNextImage2KHX( m_device, reinterpret_cast<const VkAcquireNextImageInfoKHX*>( &acquireInfo ), &imageIndex ) );
-    return createResultValue( result, imageIndex, "VULKAN_HPP_NAMESPACE::Device::acquireNextImage2KHX", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate ) const
-  {
-    return static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( pDescriptorUpdateTemplate ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DescriptorUpdateTemplateKHR>::type Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorUpdateTemplateKHR descriptorUpdateTemplate;
-    Result result = static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( &descriptorUpdateTemplate ) ) );
-    return createResultValue( result, descriptorUpdateTemplate, "VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDescriptorUpdateTemplateKHR>::type Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DescriptorUpdateTemplateKHR descriptorUpdateTemplate;
-    Result result = static_cast<Result>( vkCreateDescriptorUpdateTemplateKHR( m_device, reinterpret_cast<const VkDescriptorUpdateTemplateCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDescriptorUpdateTemplateKHR*>( &descriptorUpdateTemplate ) ) );
-
-    DescriptorUpdateTemplateKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, descriptorUpdateTemplate, "VULKAN_HPP_NAMESPACE::Device::createDescriptorUpdateTemplateKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateKHR descriptorUpdateTemplate, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyDescriptorUpdateTemplateKHR( m_device, static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, DescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData ) const
-  {
-    vkUpdateDescriptorSetWithTemplateKHR( m_device, static_cast<VkDescriptorSet>( descriptorSet ), static_cast<VkDescriptorUpdateTemplateKHR>( descriptorUpdateTemplate ), pData );
-  }
-
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, const SwapchainKHR* pSwapchains, const HdrMetadataEXT* pMetadata ) const
-  {
-    vkSetHdrMetadataEXT( m_device, swapchainCount, reinterpret_cast<const VkSwapchainKHR*>( pSwapchains ), reinterpret_cast<const VkHdrMetadataEXT*>( pMetadata ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy<const SwapchainKHR> swapchains, ArrayProxy<const HdrMetadataEXT> metadata ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( swapchains.size() == metadata.size() );
-#else
-    if ( swapchains.size() != metadata.size() )
-    {
-      throw LogicError( "VULKAN_HPP_NAMESPACE::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    vkSetHdrMetadataEXT( m_device, swapchains.size() , reinterpret_cast<const VkSwapchainKHR*>( swapchains.data() ), reinterpret_cast<const VkHdrMetadataEXT*>( metadata.data() ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const
-  {
-    return static_cast<Result>( vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain ) const
-  {
-    Result result = static_cast<Result>( vkGetSwapchainStatusKHR( m_device, static_cast<VkSwapchainKHR>( swapchain ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, RefreshCycleDurationGOOGLE* pDisplayTimingProperties ) const
-  {
-    return static_cast<Result>( vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( pDisplayTimingProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<RefreshCycleDurationGOOGLE>::type Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain ) const
-  {
-    RefreshCycleDurationGOOGLE displayTimingProperties;
-    Result result = static_cast<Result>( vkGetRefreshCycleDurationGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<VkRefreshCycleDurationGOOGLE*>( &displayTimingProperties ) ) );
-    return createResultValue( result, displayTimingProperties, "VULKAN_HPP_NAMESPACE::Device::getRefreshCycleDurationGOOGLE" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, uint32_t* pPresentationTimingCount, PastPresentationTimingGOOGLE* pPresentationTimings ) const
-  {
-    return static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), pPresentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( pPresentationTimings ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PastPresentationTimingGOOGLE,Allocator>>::type Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain ) const
-  {
-    std::vector<PastPresentationTimingGOOGLE,Allocator> presentationTimings;
-    uint32_t presentationTimingCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentationTimingCount )
-      {
-        presentationTimings.resize( presentationTimingCount );
-        result = static_cast<Result>( vkGetPastPresentationTimingGOOGLE( m_device, static_cast<VkSwapchainKHR>( swapchain ), &presentationTimingCount, reinterpret_cast<VkPastPresentationTimingGOOGLE*>( presentationTimings.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( presentationTimingCount <= presentationTimings.size() );
-    presentationTimings.resize( presentationTimingCount );
-    return createResultValue( result, presentationTimings, "VULKAN_HPP_NAMESPACE::Device::getPastPresentationTimingGOOGLE" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const
-  {
-    vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const
-  {
-    MemoryRequirements2KHR memoryRequirements;
-    vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2KHR & info ) const
-  {
-    StructureChain<T...> structureChain;
-    MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
-    vkGetBufferMemoryRequirements2KHR( m_device, reinterpret_cast<const VkBufferMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR* pInfo, MemoryRequirements2KHR* pMemoryRequirements ) const
-  {
-    vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( pInfo ), reinterpret_cast<VkMemoryRequirements2KHR*>( pMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const
-  {
-    MemoryRequirements2KHR memoryRequirements;
-    vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
-    return memoryRequirements;
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE StructureChain<T...> Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2KHR & info ) const
-  {
-    StructureChain<T...> structureChain;
-    MemoryRequirements2KHR& memoryRequirements = structureChain.template get<MemoryRequirements2KHR>();
-    vkGetImageMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageMemoryRequirementsInfo2KHR*>( &info ), reinterpret_cast<VkMemoryRequirements2KHR*>( &memoryRequirements ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, SparseImageMemoryRequirements2KHR* pSparseMemoryRequirements ) const
-  {
-    vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( pInfo ), pSparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2KHR*>( pSparseMemoryRequirements ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<SparseImageMemoryRequirements2KHR,Allocator> Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2KHR & info ) const
-  {
-    std::vector<SparseImageMemoryRequirements2KHR,Allocator> sparseMemoryRequirements;
-    uint32_t sparseMemoryRequirementCount;
-    vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( &info ), &sparseMemoryRequirementCount, nullptr );
-    sparseMemoryRequirements.resize( sparseMemoryRequirementCount );
-    vkGetImageSparseMemoryRequirements2KHR( m_device, reinterpret_cast<const VkImageSparseMemoryRequirementsInfo2KHR*>( &info ), &sparseMemoryRequirementCount, reinterpret_cast<VkSparseImageMemoryRequirements2KHR*>( sparseMemoryRequirements.data() ) );
-    return sparseMemoryRequirements;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SamplerYcbcrConversionKHR* pYcbcrConversion ) const
-  {
-    return static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( pYcbcrConversion ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SamplerYcbcrConversionKHR>::type Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SamplerYcbcrConversionKHR ycbcrConversion;
-    Result result = static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( &ycbcrConversion ) ) );
-    return createResultValue( result, ycbcrConversion, "VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSamplerYcbcrConversionKHR>::type Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SamplerYcbcrConversionKHR ycbcrConversion;
-    Result result = static_cast<Result>( vkCreateSamplerYcbcrConversionKHR( m_device, reinterpret_cast<const VkSamplerYcbcrConversionCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSamplerYcbcrConversionKHR*>( &ycbcrConversion ) ) );
-
-    SamplerYcbcrConversionKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, ycbcrConversion, "VULKAN_HPP_NAMESPACE::Device::createSamplerYcbcrConversionKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversionKHR>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversionKHR ycbcrConversion, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroySamplerYcbcrConversionKHR( m_device, static_cast<VkSamplerYcbcrConversionKHR>( ycbcrConversion ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, ValidationCacheEXT* pValidationCache ) const
-  {
-    return static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkValidationCacheEXT*>( pValidationCache ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ValidationCacheEXT>::type Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ValidationCacheEXT validationCache;
-    Result result = static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
-    return createResultValue( result, validationCache, "VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXT" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueValidationCacheEXT>::type Device::createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    ValidationCacheEXT validationCache;
-    Result result = static_cast<Result>( vkCreateValidationCacheEXT( m_device, reinterpret_cast<const VkValidationCacheCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkValidationCacheEXT*>( &validationCache ) ) );
-
-    ValidationCacheEXTDeleter deleter( *this, allocator );
-    return createResultValue( result, validationCache, "VULKAN_HPP_NAMESPACE::Device::createValidationCacheEXTUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyValidationCacheEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t* pDataSize, void* pData ) const
-  {
-    return static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), pDataSize, pData ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache ) const
-  {
-    std::vector<uint8_t,Allocator> data;
-    size_t dataSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && dataSize )
-      {
-        data.resize( dataSize );
-        result = static_cast<Result>( vkGetValidationCacheDataEXT( m_device, static_cast<VkValidationCacheEXT>( validationCache ), &dataSize, reinterpret_cast<void*>( data.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( dataSize <= data.size() );
-    data.resize( dataSize );
-    return createResultValue( result, data, "VULKAN_HPP_NAMESPACE::Device::getValidationCacheDataEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, uint32_t srcCacheCount, const ValidationCacheEXT* pSrcCaches ) const
-  {
-    return static_cast<Result>( vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCacheCount, reinterpret_cast<const VkValidationCacheEXT*>( pSrcCaches ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<void>::type Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy<const ValidationCacheEXT> srcCaches ) const
-  {
-    Result result = static_cast<Result>( vkMergeValidationCachesEXT( m_device, static_cast<VkValidationCacheEXT>( dstCache ), srcCaches.size() , reinterpret_cast<const VkValidationCacheEXT*>( srcCaches.data() ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::Device::mergeValidationCachesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo ) const
-  {
-    return static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), pInfoSize, pInfo ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<uint8_t,Allocator>>::type Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType ) const
-  {
-    std::vector<uint8_t,Allocator> info;
-    size_t infoSize;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, nullptr ) );
-      if ( ( result == Result::eSuccess ) && infoSize )
-      {
-        info.resize( infoSize );
-        result = static_cast<Result>( vkGetShaderInfoAMD( m_device, static_cast<VkPipeline>( pipeline ), static_cast<VkShaderStageFlagBits>( shaderStage ), static_cast<VkShaderInfoTypeAMD>( infoType ), &infoSize, reinterpret_cast<void*>( info.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( infoSize <= info.size() );
-    info.resize( infoSize );
-    return createResultValue( result, info, "VULKAN_HPP_NAMESPACE::Device::getShaderInfoAMD" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, MemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties ) const
-  {
-    return static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( pMemoryHostPointerProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<MemoryHostPointerPropertiesEXT>::type Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer ) const
-  {
-    MemoryHostPointerPropertiesEXT memoryHostPointerProperties;
-    Result result = static_cast<Result>( vkGetMemoryHostPointerPropertiesEXT( m_device, static_cast<VkExternalMemoryHandleTypeFlagBitsKHR>( handleType ), pHostPointer, reinterpret_cast<VkMemoryHostPointerPropertiesEXT*>( &memoryHostPointerProperties ) ) );
-    return createResultValue( result, memoryHostPointerProperties, "VULKAN_HPP_NAMESPACE::Device::getMemoryHostPointerPropertiesEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class DeviceDeleter;
-  template <> class UniqueHandleTraits<Device> {public: using deleter = DeviceDeleter; };
-  using UniqueDevice = UniqueHandle<Device>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class PhysicalDevice
-  {
-  public:
-    PhysicalDevice()
-      : m_physicalDevice(VK_NULL_HANDLE)
-    {}
-
-    PhysicalDevice( std::nullptr_t )
-      : m_physicalDevice(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT PhysicalDevice( VkPhysicalDevice physicalDevice )
-      : m_physicalDevice( physicalDevice )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    PhysicalDevice & operator=(VkPhysicalDevice physicalDevice)
-    {
-      m_physicalDevice = physicalDevice;
-      return *this; 
-    }
-#endif
-
-    PhysicalDevice & operator=( std::nullptr_t )
-    {
-      m_physicalDevice = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice == rhs.m_physicalDevice;
-    }
-
-    bool operator!=(PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice != rhs.m_physicalDevice;
-    }
-
-    bool operator<(PhysicalDevice const & rhs ) const
-    {
-      return m_physicalDevice < rhs.m_physicalDevice;
-    }
-
-    void getProperties( PhysicalDeviceProperties* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceProperties getProperties() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties>> 
-    std::vector<QueueFamilyProperties,Allocator> getQueueFamilyProperties() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceMemoryProperties getMemoryProperties() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getFeatures( PhysicalDeviceFeatures* pFeatures ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceFeatures getFeatures() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getFormatProperties( Format format, FormatProperties* pFormatProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    FormatProperties getFormatProperties( Format format ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ImageFormatProperties>::type getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Device>::type createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDevice>::type createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<LayerProperties>> 
-    typename ResultValueType<std::vector<LayerProperties,Allocator>>::type enumerateDeviceLayerProperties() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<ExtensionProperties>> 
-    typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type enumerateDeviceExtensionProperties( Optional<const std::string> layerName = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties>> 
-    std::vector<SparseImageFormatProperties,Allocator> getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayPropertiesKHR>> 
-    typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type getDisplayPropertiesKHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayPlanePropertiesKHR>> 
-    typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type getDisplayPlanePropertiesKHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayKHR>> 
-    typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<DisplayModePropertiesKHR>> 
-    typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type getDisplayModePropertiesKHR( DisplayKHR display ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DisplayModeKHR>::type createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DisplayPlaneCapabilitiesKHR>::type getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Bool32 getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-    Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Bool32>::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceCapabilitiesKHR>::type getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SurfaceFormatKHR>> 
-    typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type getSurfaceFormatsKHR( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PresentModeKHR>> 
-    typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type getSurfacePresentModesKHR( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const;
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-    Result getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ExternalImageFormatPropertiesNV>::type getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    DeviceGeneratedCommandsLimitsNVX getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceFeatures2KHR getFeatures2KHR() const;
-    template <typename ...T>
-    StructureChain<T...> getFeatures2KHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceProperties2KHR getProperties2KHR() const;
-    template <typename ...T>
-    StructureChain<T...> getProperties2KHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    FormatProperties2KHR getFormatProperties2KHR( Format format ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<ImageFormatProperties2KHR>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const;
-    template <typename ...T>
-    typename ResultValueType<StructureChain<T...>>::type getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<QueueFamilyProperties2KHR>> 
-    std::vector<QueueFamilyProperties2KHR,Allocator> getQueueFamilyProperties2KHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PhysicalDeviceMemoryProperties2KHR getMemoryProperties2KHR() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SparseImageFormatProperties2KHR>> 
-    std::vector<SparseImageFormatProperties2KHR,Allocator> getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ExternalBufferPropertiesKHR getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ExternalSemaphorePropertiesKHR getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ExternalFencePropertiesKHR getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    Result releaseDisplayEXT( DisplayKHR display ) const;
-#else
-    ResultValueType<void>::type releaseDisplayEXT( DisplayKHR display ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    Result acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<Display>::type acquireXlibDisplayEXT( DisplayKHR display ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-    Result getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DisplayKHR>::type getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-    Result getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceCapabilities2EXT>::type getSurfaceCapabilities2EXT( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<Rect2D>> 
-    typename ResultValueType<std::vector<Rect2D,Allocator>>::type getPresentRectanglesKHX( SurfaceKHR surface ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceCapabilities2KHR>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
-    template <typename ...T>
-    typename ResultValueType<StructureChain<T...>>::type getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<SurfaceFormat2KHR>> 
-    typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPhysicalDevice() const
-    {
-      return m_physicalDevice;
-    }
-
-    explicit operator bool() const
-    {
-      return m_physicalDevice != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_physicalDevice == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkPhysicalDevice m_physicalDevice;
-  };
-
-  static_assert( sizeof( PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" );
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class DeviceDeleter
-  {
-  public:
-    DeviceDeleter( Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_allocator( allocator )
-    {}
-
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Device device )
-    {
-      device.destroy( m_allocator );
-    }
-
-  private:
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties* pProperties ) const
-  {
-    vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties() const
-  {
-    PhysicalDeviceProperties properties;
-    vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties*>( &properties ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties* pQueueFamilyProperties ) const
-  {
-    vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( pQueueFamilyProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties,Allocator> PhysicalDevice::getQueueFamilyProperties() const
-  {
-    std::vector<QueueFamilyProperties,Allocator> queueFamilyProperties;
-    uint32_t queueFamilyPropertyCount;
-    vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties* pMemoryProperties ) const
-  {
-    vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( pMemoryProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const
-  {
-    PhysicalDeviceMemoryProperties memoryProperties;
-    vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties*>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures* pFeatures ) const
-  {
-    vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( pFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures() const
-  {
-    PhysicalDeviceFeatures features;
-    vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures*>( &features ) );
-    return features;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties( Format format, FormatProperties* pFormatProperties ) const
-  {
-    vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( pFormatProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format ) const
-  {
-    FormatProperties formatProperties;
-    vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties*>( &formatProperties ) );
-    return formatProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ImageFormatProperties* pImageFormatProperties ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( pImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties>::type PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const
-  {
-    ImageFormatProperties imageFormatProperties;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), reinterpret_cast<VkImageFormatProperties*>( &imageFormatProperties ) ) );
-    return createResultValue( result, imageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Device* pDevice ) const
-  {
-    return static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDevice*>( pDevice ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Device>::type PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Device device;
-    Result result = static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
-    return createResultValue( result, device, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDevice" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDevice>::type PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    Device device;
-    Result result = static_cast<Result>( vkCreateDevice( m_physicalDevice, reinterpret_cast<const VkDeviceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDevice*>( &device ) ) );
-
-    DeviceDeleter deleter( allocator );
-    return createResultValue( result, device, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDeviceUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t* pPropertyCount, LayerProperties* pProperties ) const
-  {
-    return static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, pPropertyCount, reinterpret_cast<VkLayerProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<LayerProperties,Allocator>>::type PhysicalDevice::enumerateDeviceLayerProperties() const
-  {
-    std::vector<LayerProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast<VkLayerProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceLayerProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, ExtensionProperties* pProperties ) const
-  {
-    return static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, pLayerName, pPropertyCount, reinterpret_cast<VkExtensionProperties*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<ExtensionProperties,Allocator>>::type PhysicalDevice::enumerateDeviceExtensionProperties( Optional<const std::string> layerName ) const
-  {
-    std::vector<ExtensionProperties,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast<VkExtensionProperties*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::enumerateDeviceExtensionProperties" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, uint32_t* pPropertyCount, SparseImageFormatProperties* pProperties ) const
-  {
-    vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties,Allocator> PhysicalDevice::getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const
-  {
-    std::vector<SparseImageFormatProperties,Allocator> properties;
-    uint32_t propertyCount;
-    vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkSampleCountFlagBits>( samples ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageTiling>( tiling ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties*>( properties.data() ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t* pPropertyCount, DisplayPropertiesKHR* pProperties ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPropertiesKHR() const
-  {
-    std::vector<DisplayPropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t* pPropertyCount, DisplayPlanePropertiesKHR* pProperties ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, pPropertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayPlanePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayPlanePropertiesKHR() const
-  {
-    std::vector<DisplayPlanePropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast<VkDisplayPlanePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlanePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, uint32_t* pDisplayCount, DisplayKHR* pDisplays ) const
-  {
-    return static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, pDisplayCount, reinterpret_cast<VkDisplayKHR*>( pDisplays ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayKHR,Allocator>>::type PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const
-  {
-    std::vector<DisplayKHR,Allocator> displays;
-    uint32_t displayCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && displayCount )
-      {
-        displays.resize( displayCount );
-        result = static_cast<Result>( vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast<VkDisplayKHR*>( displays.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( displayCount <= displays.size() );
-    displays.resize( displayCount );
-    return createResultValue( result, displays, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, uint32_t* pPropertyCount, DisplayModePropertiesKHR* pProperties ) const
-  {
-    return static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), pPropertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( pProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<DisplayModePropertiesKHR,Allocator>>::type PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display ) const
-  {
-    std::vector<DisplayModePropertiesKHR,Allocator> properties;
-    uint32_t propertyCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && propertyCount )
-      {
-        properties.resize( propertyCount );
-        result = static_cast<Result>( vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), &propertyCount, reinterpret_cast<VkDisplayModePropertiesKHR*>( properties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( propertyCount <= properties.size() );
-    properties.resize( propertyCount );
-    return createResultValue( result, properties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayModePropertiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, DisplayModeKHR* pMode ) const
-  {
-    return static_cast<Result>( vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDisplayModeKHR*>( pMode ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DisplayModeKHR>::type PhysicalDevice::createDisplayModeKHR( DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DisplayModeKHR mode;
-    Result result = static_cast<Result>( vkCreateDisplayModeKHR( m_physicalDevice, static_cast<VkDisplayKHR>( display ), reinterpret_cast<const VkDisplayModeCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDisplayModeKHR*>( &mode ) ) );
-    return createResultValue( result, mode, "VULKAN_HPP_NAMESPACE::PhysicalDevice::createDisplayModeKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, DisplayPlaneCapabilitiesKHR* pCapabilities ) const
-  {
-    return static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( pCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DisplayPlaneCapabilitiesKHR>::type PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex ) const
-  {
-    DisplayPlaneCapabilitiesKHR capabilities;
-    Result result = static_cast<Result>( vkGetDisplayPlaneCapabilitiesKHR( m_physicalDevice, static_cast<VkDisplayModeKHR>( mode ), planeIndex, reinterpret_cast<VkDisplayPlaneCapabilitiesKHR*>( &capabilities ) ) );
-    return createResultValue( result, capabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection* connection ) const
-  {
-    return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getMirPresentationSupportKHR( uint32_t queueFamilyIndex, MirConnection & connection ) const
-  {
-    return vkGetPhysicalDeviceMirPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32* pSupported ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), pSupported ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Bool32>::type PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface ) const
-  {
-    Bool32 supported;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceSupportKHR( m_physicalDevice, queueFamilyIndex, static_cast<VkSurfaceKHR>( surface ), &supported ) );
-    return createResultValue( result, supported, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceSupportKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, SurfaceCapabilitiesKHR* pSurfaceCapabilities ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( pSurfaceCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilitiesKHR>::type PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface ) const
-  {
-    SurfaceCapabilitiesKHR surfaceCapabilities;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilitiesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilitiesKHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilitiesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, uint32_t* pSurfaceFormatCount, SurfaceFormatKHR* pSurfaceFormats ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( pSurfaceFormats ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormatKHR,Allocator>>::type PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface ) const
-  {
-    std::vector<SurfaceFormatKHR,Allocator> surfaceFormats;
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormatKHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( surfaceFormatCount <= surfaceFormats.size() );
-    surfaceFormats.resize( surfaceFormatCount );
-    return createResultValue( result, surfaceFormats, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormatsKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, uint32_t* pPresentModeCount, PresentModeKHR* pPresentModes ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pPresentModeCount, reinterpret_cast<VkPresentModeKHR*>( pPresentModes ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PresentModeKHR,Allocator>>::type PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface ) const
-  {
-    std::vector<PresentModeKHR,Allocator> presentModes;
-    uint32_t presentModeCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && presentModeCount )
-      {
-        presentModes.resize( presentModeCount );
-        result = static_cast<Result>( vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &presentModeCount, reinterpret_cast<VkPresentModeKHR*>( presentModes.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( presentModeCount <= presentModes.size() );
-    presentModes.resize( presentModeCount );
-    return createResultValue( result, presentModes, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfacePresentModesKHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display* display ) const
-  {
-    return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, display );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const
-  {
-    return vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const
-  {
-    return vkGetPhysicalDeviceWin32PresentationSupportKHR( m_physicalDevice, queueFamilyIndex );
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display* dpy, VisualID visualID ) const
-  {
-    return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, dpy, visualID );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const
-  {
-    return vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id ) const
-  {
-    return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, connection, visual_id );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, xcb_connection_t & connection, xcb_visualid_t visual_id ) const
-  {
-    return vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType, ExternalImageFormatPropertiesNV* pExternalImageFormatProperties ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( pExternalImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ExternalImageFormatPropertiesNV>::type PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, ExternalMemoryHandleTypeFlagsNV externalHandleType ) const
-  {
-    ExternalImageFormatPropertiesNV externalImageFormatProperties;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, static_cast<VkFormat>( format ), static_cast<VkImageType>( type ), static_cast<VkImageTiling>( tiling ), static_cast<VkImageUsageFlags>( usage ), static_cast<VkImageCreateFlags>( flags ), static_cast<VkExternalMemoryHandleTypeFlagsNV>( externalHandleType ), reinterpret_cast<VkExternalImageFormatPropertiesNV*>( &externalImageFormatProperties ) ) );
-    return createResultValue( result, externalImageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getExternalImageFormatPropertiesNV" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX* pFeatures, DeviceGeneratedCommandsLimitsNVX* pLimits ) const
-  {
-    vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( pFeatures ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( pLimits ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE DeviceGeneratedCommandsLimitsNVX PhysicalDevice::getGeneratedCommandsPropertiesNVX( DeviceGeneratedCommandsFeaturesNVX & features ) const
-  {
-    DeviceGeneratedCommandsLimitsNVX limits;
-    vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX( m_physicalDevice, reinterpret_cast<VkDeviceGeneratedCommandsFeaturesNVX*>( &features ), reinterpret_cast<VkDeviceGeneratedCommandsLimitsNVX*>( &limits ) );
-    return limits;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2KHR* pFeatures ) const
-  {
-    vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( pFeatures ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceFeatures2KHR PhysicalDevice::getFeatures2KHR() const
-  {
-    PhysicalDeviceFeatures2KHR features;
-    vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) );
-    return features;
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getFeatures2KHR() const
-  {
-    StructureChain<T...> structureChain;
-    PhysicalDeviceFeatures2KHR& features = structureChain.template get<PhysicalDeviceFeatures2KHR>();
-    vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceFeatures2KHR*>( &features ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2KHR* pProperties ) const
-  {
-    vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceProperties2KHR PhysicalDevice::getProperties2KHR() const
-  {
-    PhysicalDeviceProperties2KHR properties;
-    vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) );
-    return properties;
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE StructureChain<T...> PhysicalDevice::getProperties2KHR() const
-  {
-    StructureChain<T...> structureChain;
-    PhysicalDeviceProperties2KHR& properties = structureChain.template get<PhysicalDeviceProperties2KHR>();
-    vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceProperties2KHR*>( &properties ) );
-    return structureChain;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2KHR* pFormatProperties ) const
-  {
-    vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( pFormatProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE FormatProperties2KHR PhysicalDevice::getFormatProperties2KHR( Format format ) const
-  {
-    FormatProperties2KHR formatProperties;
-    vkGetPhysicalDeviceFormatProperties2KHR( m_physicalDevice, static_cast<VkFormat>( format ), reinterpret_cast<VkFormatProperties2KHR*>( &formatProperties ) );
-    return formatProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, ImageFormatProperties2KHR* pImageFormatProperties ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( pImageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( pImageFormatProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<ImageFormatProperties2KHR>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const
-  {
-    ImageFormatProperties2KHR imageFormatProperties;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) );
-    return createResultValue( result, imageFormatProperties, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2KHR & imageFormatInfo ) const
-  {
-    StructureChain<T...> structureChain;
-    ImageFormatProperties2KHR& imageFormatProperties = structureChain.template get<ImageFormatProperties2KHR>();
-    Result result = static_cast<Result>( vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceImageFormatInfo2KHR*>( &imageFormatInfo ), reinterpret_cast<VkImageFormatProperties2KHR*>( &imageFormatProperties ) ) );
-    return createResultValue( result, structureChain, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getImageFormatProperties2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t* pQueueFamilyPropertyCount, QueueFamilyProperties2KHR* pQueueFamilyProperties ) const
-  {
-    vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, pQueueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( pQueueFamilyProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<QueueFamilyProperties2KHR,Allocator> PhysicalDevice::getQueueFamilyProperties2KHR() const
-  {
-    std::vector<QueueFamilyProperties2KHR,Allocator> queueFamilyProperties;
-    uint32_t queueFamilyPropertyCount;
-    vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr );
-    queueFamilyProperties.resize( queueFamilyPropertyCount );
-    vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast<VkQueueFamilyProperties2KHR*>( queueFamilyProperties.data() ) );
-    return queueFamilyProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2KHR* pMemoryProperties ) const
-  {
-    vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( pMemoryProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2KHR PhysicalDevice::getMemoryProperties2KHR() const
-  {
-    PhysicalDeviceMemoryProperties2KHR memoryProperties;
-    vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast<VkPhysicalDeviceMemoryProperties2KHR*>( &memoryProperties ) );
-    return memoryProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, SparseImageFormatProperties2KHR* pProperties ) const
-  {
-    vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( pFormatInfo ), pPropertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( pProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE std::vector<SparseImageFormatProperties2KHR,Allocator> PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2KHR & formatInfo ) const
-  {
-    std::vector<SparseImageFormatProperties2KHR,Allocator> properties;
-    uint32_t propertyCount;
-    vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, nullptr );
-    properties.resize( propertyCount );
-    vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSparseImageFormatInfo2KHR*>( &formatInfo ), &propertyCount, reinterpret_cast<VkSparseImageFormatProperties2KHR*>( properties.data() ) );
-    return properties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, ExternalBufferPropertiesKHR* pExternalBufferProperties ) const
-  {
-    vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>( pExternalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHR*>( pExternalBufferProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ExternalBufferPropertiesKHR PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfoKHR & externalBufferInfo ) const
-  {
-    ExternalBufferPropertiesKHR externalBufferProperties;
-    vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalBufferInfoKHR*>( &externalBufferInfo ), reinterpret_cast<VkExternalBufferPropertiesKHR*>( &externalBufferProperties ) );
-    return externalBufferProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, ExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties ) const
-  {
-    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>( pExternalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHR*>( pExternalSemaphoreProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ExternalSemaphorePropertiesKHR PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfoKHR & externalSemaphoreInfo ) const
-  {
-    ExternalSemaphorePropertiesKHR externalSemaphoreProperties;
-    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalSemaphoreInfoKHR*>( &externalSemaphoreInfo ), reinterpret_cast<VkExternalSemaphorePropertiesKHR*>( &externalSemaphoreProperties ) );
-    return externalSemaphoreProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, ExternalFencePropertiesKHR* pExternalFenceProperties ) const
-  {
-    vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>( pExternalFenceInfo ), reinterpret_cast<VkExternalFencePropertiesKHR*>( pExternalFenceProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ExternalFencePropertiesKHR PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfoKHR & externalFenceInfo ) const
-  {
-    ExternalFencePropertiesKHR externalFenceProperties;
-    vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceExternalFenceInfoKHR*>( &externalFenceInfo ), reinterpret_cast<VkExternalFencePropertiesKHR*>( &externalFenceProperties ) );
-    return externalFenceProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
-  {
-    return static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-  }
-#else
-  VULKAN_HPP_INLINE ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display ) const
-  {
-    Result result = static_cast<Result>( vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, "VULKAN_HPP_NAMESPACE::PhysicalDevice::releaseDisplayEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-  VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display* dpy, DisplayKHR display ) const
-  {
-    return static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, dpy, static_cast<VkDisplayKHR>( display ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Display>::type PhysicalDevice::acquireXlibDisplayEXT( DisplayKHR display ) const
-  {
-    Display dpy;
-    Result result = static_cast<Result>( vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast<VkDisplayKHR>( display ) ) );
-    return createResultValue( result, dpy, "VULKAN_HPP_NAMESPACE::PhysicalDevice::acquireXlibDisplayEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
-  VULKAN_HPP_INLINE Result PhysicalDevice::getRandROutputDisplayEXT( Display* dpy, RROutput rrOutput, DisplayKHR* pDisplay ) const
-  {
-    return static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( pDisplay ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DisplayKHR>::type PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const
-  {
-    DisplayKHR display;
-    Result result = static_cast<Result>( vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast<VkDisplayKHR*>( &display ) ) );
-    return createResultValue( result, display, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getRandROutputDisplayEXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, SurfaceCapabilities2EXT* pSurfaceCapabilities ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( pSurfaceCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2EXT>::type PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface ) const
-  {
-    SurfaceCapabilities2EXT surfaceCapabilities;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2EXT( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<VkSurfaceCapabilities2EXT*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2EXT" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface, uint32_t* pRectCount, Rect2D* pRects ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), pRectCount, reinterpret_cast<VkRect2D*>( pRects ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<Rect2D,Allocator>>::type PhysicalDevice::getPresentRectanglesKHX( SurfaceKHR surface ) const
-  {
-    std::vector<Rect2D,Allocator> rects;
-    uint32_t rectCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && rectCount )
-      {
-        rects.resize( rectCount );
-        result = static_cast<Result>( vkGetPhysicalDevicePresentRectanglesKHX( m_physicalDevice, static_cast<VkSurfaceKHR>( surface ), &rectCount, reinterpret_cast<VkRect2D*>( rects.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( rectCount <= rects.size() );
-    rects.resize( rectCount );
-    return createResultValue( result, rects, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getPresentRectanglesKHX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, MultisamplePropertiesEXT* pMultisampleProperties ) const
-  {
-    vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( pMultisampleProperties ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const
-  {
-    MultisamplePropertiesEXT multisampleProperties;
-    vkGetPhysicalDeviceMultisamplePropertiesEXT( m_physicalDevice, static_cast<VkSampleCountFlagBits>( samples ), reinterpret_cast<VkMultisamplePropertiesEXT*>( &multisampleProperties ) );
-    return multisampleProperties;
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, SurfaceCapabilities2KHR* pSurfaceCapabilities ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( pSurfaceCapabilities ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceCapabilities2KHR>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
-  {
-    SurfaceCapabilities2KHR surfaceCapabilities;
-    Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, surfaceCapabilities, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-  template <typename ...T>
-  VULKAN_HPP_INLINE typename ResultValueType<StructureChain<T...>>::type PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
-  {
-    StructureChain<T...> structureChain;
-    SurfaceCapabilities2KHR& surfaceCapabilities = structureChain.template get<SurfaceCapabilities2KHR>();
-    Result result = static_cast<Result>( vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), reinterpret_cast<VkSurfaceCapabilities2KHR*>( &surfaceCapabilities ) ) );
-    return createResultValue( result, structureChain, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceCapabilities2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, SurfaceFormat2KHR* pSurfaceFormats ) const
-  {
-    return static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( pSurfaceInfo ), pSurfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( pSurfaceFormats ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<SurfaceFormat2KHR,Allocator>>::type PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const
-  {
-    std::vector<SurfaceFormat2KHR,Allocator> surfaceFormats;
-    uint32_t surfaceFormatCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && surfaceFormatCount )
-      {
-        surfaceFormats.resize( surfaceFormatCount );
-        result = static_cast<Result>( vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, reinterpret_cast<const VkPhysicalDeviceSurfaceInfo2KHR*>( &surfaceInfo ), &surfaceFormatCount, reinterpret_cast<VkSurfaceFormat2KHR*>( surfaceFormats.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( surfaceFormatCount <= surfaceFormats.size() );
-    surfaceFormats.resize( surfaceFormatCount );
-    return createResultValue( result, surfaceFormats, "VULKAN_HPP_NAMESPACE::PhysicalDevice::getSurfaceFormats2KHR" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  struct CmdProcessCommandsInfoNVX
-  {
-    CmdProcessCommandsInfoNVX( ObjectTableNVX objectTable_ = ObjectTableNVX(), IndirectCommandsLayoutNVX indirectCommandsLayout_ = IndirectCommandsLayoutNVX(), uint32_t indirectCommandsTokenCount_ = 0, const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ = nullptr, uint32_t maxSequencesCount_ = 0, CommandBuffer targetCommandBuffer_ = CommandBuffer(), Buffer sequencesCountBuffer_ = Buffer(), DeviceSize sequencesCountOffset_ = 0, Buffer sequencesIndexBuffer_ = Buffer(), DeviceSize sequencesIndexOffset_ = 0 )
-      : objectTable( objectTable_ )
-      , indirectCommandsLayout( indirectCommandsLayout_ )
-      , indirectCommandsTokenCount( indirectCommandsTokenCount_ )
-      , pIndirectCommandsTokens( pIndirectCommandsTokens_ )
-      , maxSequencesCount( maxSequencesCount_ )
-      , targetCommandBuffer( targetCommandBuffer_ )
-      , sequencesCountBuffer( sequencesCountBuffer_ )
-      , sequencesCountOffset( sequencesCountOffset_ )
-      , sequencesIndexBuffer( sequencesIndexBuffer_ )
-      , sequencesIndexOffset( sequencesIndexOffset_ )
-    {
-    }
-
-    CmdProcessCommandsInfoNVX( VkCmdProcessCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
-    }
-
-    CmdProcessCommandsInfoNVX& operator=( VkCmdProcessCommandsInfoNVX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( CmdProcessCommandsInfoNVX ) );
-      return *this;
-    }
-    CmdProcessCommandsInfoNVX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setObjectTable( ObjectTableNVX objectTable_ )
-    {
-      objectTable = objectTable_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setIndirectCommandsLayout( IndirectCommandsLayoutNVX indirectCommandsLayout_ )
-    {
-      indirectCommandsLayout = indirectCommandsLayout_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setIndirectCommandsTokenCount( uint32_t indirectCommandsTokenCount_ )
-    {
-      indirectCommandsTokenCount = indirectCommandsTokenCount_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setPIndirectCommandsTokens( const IndirectCommandsTokenNVX* pIndirectCommandsTokens_ )
-    {
-      pIndirectCommandsTokens = pIndirectCommandsTokens_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setMaxSequencesCount( uint32_t maxSequencesCount_ )
-    {
-      maxSequencesCount = maxSequencesCount_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setTargetCommandBuffer( CommandBuffer targetCommandBuffer_ )
-    {
-      targetCommandBuffer = targetCommandBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesCountBuffer( Buffer sequencesCountBuffer_ )
-    {
-      sequencesCountBuffer = sequencesCountBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesCountOffset( DeviceSize sequencesCountOffset_ )
-    {
-      sequencesCountOffset = sequencesCountOffset_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ )
-    {
-      sequencesIndexBuffer = sequencesIndexBuffer_;
-      return *this;
-    }
-
-    CmdProcessCommandsInfoNVX& setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ )
-    {
-      sequencesIndexOffset = sequencesIndexOffset_;
-      return *this;
-    }
-
-    operator const VkCmdProcessCommandsInfoNVX&() const
-    {
-      return *reinterpret_cast<const VkCmdProcessCommandsInfoNVX*>(this);
-    }
-
-    bool operator==( CmdProcessCommandsInfoNVX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( objectTable == rhs.objectTable )
-          && ( indirectCommandsLayout == rhs.indirectCommandsLayout )
-          && ( indirectCommandsTokenCount == rhs.indirectCommandsTokenCount )
-          && ( pIndirectCommandsTokens == rhs.pIndirectCommandsTokens )
-          && ( maxSequencesCount == rhs.maxSequencesCount )
-          && ( targetCommandBuffer == rhs.targetCommandBuffer )
-          && ( sequencesCountBuffer == rhs.sequencesCountBuffer )
-          && ( sequencesCountOffset == rhs.sequencesCountOffset )
-          && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer )
-          && ( sequencesIndexOffset == rhs.sequencesIndexOffset );
-    }
-
-    bool operator!=( CmdProcessCommandsInfoNVX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eCmdProcessCommandsInfoNVX;
-
-  public:
-    const void* pNext = nullptr;
-    ObjectTableNVX objectTable;
-    IndirectCommandsLayoutNVX indirectCommandsLayout;
-    uint32_t indirectCommandsTokenCount;
-    const IndirectCommandsTokenNVX* pIndirectCommandsTokens;
-    uint32_t maxSequencesCount;
-    CommandBuffer targetCommandBuffer;
-    Buffer sequencesCountBuffer;
-    DeviceSize sequencesCountOffset;
-    Buffer sequencesIndexBuffer;
-    DeviceSize sequencesIndexOffset;
-  };
-  static_assert( sizeof( CmdProcessCommandsInfoNVX ) == sizeof( VkCmdProcessCommandsInfoNVX ), "struct and wrapper have different size!" );
-
-  struct PhysicalDeviceGroupPropertiesKHX
-  {
-    operator const VkPhysicalDeviceGroupPropertiesKHX&() const
-    {
-      return *reinterpret_cast<const VkPhysicalDeviceGroupPropertiesKHX*>(this);
-    }
-
-    bool operator==( PhysicalDeviceGroupPropertiesKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( physicalDeviceCount == rhs.physicalDeviceCount )
-          && ( memcmp( physicalDevices, rhs.physicalDevices, VK_MAX_DEVICE_GROUP_SIZE_KHX * sizeof( PhysicalDevice ) ) == 0 )
-          && ( subsetAllocation == rhs.subsetAllocation );
-    }
-
-    bool operator!=( PhysicalDeviceGroupPropertiesKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::ePhysicalDeviceGroupPropertiesKHX;
-
-  public:
-    void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    PhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE_KHX];
-    Bool32 subsetAllocation;
-  };
-  static_assert( sizeof( PhysicalDeviceGroupPropertiesKHX ) == sizeof( VkPhysicalDeviceGroupPropertiesKHX ), "struct and wrapper have different size!" );
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class DebugReportCallbackEXTDeleter;
-  template <> class UniqueHandleTraits<DebugReportCallbackEXT> {public: using deleter = DebugReportCallbackEXTDeleter; };
-  using UniqueDebugReportCallbackEXT = UniqueHandle<DebugReportCallbackEXT>;
-  class SurfaceKHRDeleter;
-  template <> class UniqueHandleTraits<SurfaceKHR> {public: using deleter = SurfaceKHRDeleter; };
-  using UniqueSurfaceKHR = UniqueHandle<SurfaceKHR>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  class Instance
-  {
-  public:
-    Instance()
-      : m_instance(VK_NULL_HANDLE)
-    {}
-
-    Instance( std::nullptr_t )
-      : m_instance(VK_NULL_HANDLE)
-    {}
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT Instance( VkInstance instance )
-      : m_instance( instance )
-    {}
-
-#if defined(VULKAN_HPP_TYPESAFE_CONVERSION)
-    Instance & operator=(VkInstance instance)
-    {
-      m_instance = instance;
-      return *this; 
-    }
-#endif
-
-    Instance & operator=( std::nullptr_t )
-    {
-      m_instance = VK_NULL_HANDLE;
-      return *this;
-    }
-
-    bool operator==( Instance const & rhs ) const
-    {
-      return m_instance == rhs.m_instance;
-    }
-
-    bool operator!=(Instance const & rhs ) const
-    {
-      return m_instance != rhs.m_instance;
-    }
-
-    bool operator<(Instance const & rhs ) const
-    {
-      return m_instance < rhs.m_instance;
-    }
-
-    void destroy( const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroy( Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PhysicalDevice>> 
-    typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type enumeratePhysicalDevices() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    PFN_vkVoidFunction getProcAddr( const char* pName ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    PFN_vkVoidFunction getProcAddr( const std::string & name ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-    Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-    Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-    Result createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-    void destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-    Result createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-    Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-    Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-    Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-    Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-    Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<DebugReportCallbackEXT>::type createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueDebugReportCallbackEXT>::type createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    void debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-    Result enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Allocator = std::allocator<PhysicalDeviceGroupPropertiesKHX>> 
-    typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type enumeratePhysicalDeviceGroupsKHX() const;
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const;
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    ResultValueType<SurfaceKHR>::type createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-    ResultValueType<UniqueSurfaceKHR>::type createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator = nullptr ) const;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-
-
-    VULKAN_HPP_TYPESAFE_EXPLICIT operator VkInstance() const
-    {
-      return m_instance;
-    }
-
-    explicit operator bool() const
-    {
-      return m_instance != VK_NULL_HANDLE;
-    }
-
-    bool operator!() const
-    {
-      return m_instance == VK_NULL_HANDLE;
-    }
-
-  private:
-    VkInstance m_instance;
-  };
-
-  static_assert( sizeof( Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" );
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class DebugReportCallbackEXTDeleter
-  {
-  public:
-    DebugReportCallbackEXTDeleter( Instance instance = Instance(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_instance( instance )
-      , m_allocator( allocator )
-    {}
-
-    Instance getInstance() const { return m_instance; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( DebugReportCallbackEXT debugReportCallbackEXT )
-    {
-      m_instance.destroyDebugReportCallbackEXT( debugReportCallbackEXT, m_allocator );
-    }
-
-  private:
-    Instance m_instance;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-
-  class SurfaceKHRDeleter
-  {
-  public:
-    SurfaceKHRDeleter( Instance instance = Instance(), Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_instance( instance )
-      , m_allocator( allocator )
-    {}
-
-    Instance getInstance() const { return m_instance; }
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( SurfaceKHR surfaceKHR )
-    {
-      m_instance.destroySurfaceKHR( surfaceKHR, m_allocator );
-    }
-
-  private:
-    Instance m_instance;
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Instance::destroy( Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyInstance( m_instance, reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t* pPhysicalDeviceCount, PhysicalDevice* pPhysicalDevices ) const
-  {
-    return static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, pPhysicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( pPhysicalDevices ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDevice,Allocator>>::type Instance::enumeratePhysicalDevices() const
-  {
-    std::vector<PhysicalDevice,Allocator> physicalDevices;
-    uint32_t physicalDeviceCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceCount )
-      {
-        physicalDevices.resize( physicalDeviceCount );
-        result = static_cast<Result>( vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast<VkPhysicalDevice*>( physicalDevices.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( physicalDeviceCount <= physicalDevices.size() );
-    physicalDevices.resize( physicalDeviceCount );
-    return createResultValue( result, physicalDevices, "VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDevices" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char* pName ) const
-  {
-    return vkGetInstanceProcAddr( m_instance, pName );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const std::string & name ) const
-  {
-    return vkGetInstanceProcAddr( m_instance, name.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createAndroidSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateAndroidSurfaceKHR( m_instance, reinterpret_cast<const VkAndroidSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createAndroidSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-  VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateDisplayPlaneSurfaceKHR( m_instance, reinterpret_cast<const VkDisplaySurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createDisplayPlaneSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VULKAN_HPP_INLINE Result Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMirSurfaceKHR( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMirSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createMirSurfaceKHRUnique( const MirSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateMirSurfaceKHR( m_instance, reinterpret_cast<const VkMirSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMirSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroySurfaceKHR( m_instance, static_cast<VkSurfaceKHR>( surface ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createViSurfaceNN" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateViSurfaceNN( m_instance, reinterpret_cast<const VkViSurfaceCreateInfoNN*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createViSurfaceNNUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWaylandSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateWaylandSurfaceKHR( m_instance, reinterpret_cast<const VkWaylandSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWaylandSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWin32SurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateWin32SurfaceKHR( m_instance, reinterpret_cast<const VkWin32SurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createWin32SurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXlibSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateXlibSurfaceKHR( m_instance, reinterpret_cast<const VkXlibSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXlibSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXcbSurfaceKHR" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateXcbSurfaceKHR( m_instance, reinterpret_cast<const VkXcbSurfaceCreateInfoKHR*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createXcbSurfaceKHRUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-  VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT* pCreateInfo, const AllocationCallbacks* pAllocator, DebugReportCallbackEXT* pCallback ) const
-  {
-    return static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkDebugReportCallbackEXT*>( pCallback ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<DebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DebugReportCallbackEXT callback;
-    Result result = static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
-    return createResultValue( result, callback, "VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXT" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueDebugReportCallbackEXT>::type Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    DebugReportCallbackEXT callback;
-    Result result = static_cast<Result>( vkCreateDebugReportCallbackEXT( m_instance, reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkDebugReportCallbackEXT*>( &callback ) ) );
-
-    DebugReportCallbackEXTDeleter deleter( *this, allocator );
-    return createResultValue( result, callback, "VULKAN_HPP_NAMESPACE::Instance::createDebugReportCallbackEXTUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, const AllocationCallbacks* pAllocator ) const
-  {
-    vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, Optional<const AllocationCallbacks> allocator ) const
-  {
-    vkDestroyDebugReportCallbackEXT( m_instance, static_cast<VkDebugReportCallbackEXT>( callback ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ) );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage ) const
-  {
-    vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, pLayerPrefix, pMessage );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, DebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const std::string & layerPrefix, const std::string & message ) const
-  {
-#ifdef VULKAN_HPP_NO_EXCEPTIONS
-    assert( layerPrefix.size() == message.size() );
-#else
-    if ( layerPrefix.size() != message.size() )
-    {
-      throw LogicError( "VULKAN_HPP_NAMESPACE::Instance::debugReportMessageEXT: layerPrefix.size() != message.size()" );
-    }
-#endif  // VULKAN_HPP_NO_EXCEPTIONS
-    vkDebugReportMessageEXT( m_instance, static_cast<VkDebugReportFlagsEXT>( flags ), static_cast<VkDebugReportObjectTypeEXT>( objectType ), object, location, messageCode, layerPrefix.c_str(), message.c_str() );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-  VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHX( uint32_t* pPhysicalDeviceGroupCount, PhysicalDeviceGroupPropertiesKHX* pPhysicalDeviceGroupProperties ) const
-  {
-    return static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, pPhysicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( pPhysicalDeviceGroupProperties ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Allocator> 
-  VULKAN_HPP_INLINE typename ResultValueType<std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator>>::type Instance::enumeratePhysicalDeviceGroupsKHX() const
-  {
-    std::vector<PhysicalDeviceGroupPropertiesKHX,Allocator> physicalDeviceGroupProperties;
-    uint32_t physicalDeviceGroupCount;
-    Result result;
-    do
-    {
-      result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, nullptr ) );
-      if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount )
-      {
-        physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-        result = static_cast<Result>( vkEnumeratePhysicalDeviceGroupsKHX( m_instance, &physicalDeviceGroupCount, reinterpret_cast<VkPhysicalDeviceGroupPropertiesKHX*>( physicalDeviceGroupProperties.data() ) ) );
-      }
-    } while ( result == Result::eIncomplete );
-    assert( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() );
-    physicalDeviceGroupProperties.resize( physicalDeviceGroupCount );
-    return createResultValue( result, physicalDeviceGroupProperties, "VULKAN_HPP_NAMESPACE::Instance::enumeratePhysicalDeviceGroupsKHX" );
-  }
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createIOSSurfaceMVK" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateIOSSurfaceMVK( m_instance, reinterpret_cast<const VkIOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createIOSSurfaceMVKUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK* pCreateInfo, const AllocationCallbacks* pAllocator, SurfaceKHR* pSurface ) const
-  {
-    return static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkSurfaceKHR*>( pSurface ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<SurfaceKHR>::type Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMacOSSurfaceMVK" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueSurfaceKHR>::type Instance::createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, Optional<const AllocationCallbacks> allocator ) const
-  {
-    SurfaceKHR surface;
-    Result result = static_cast<Result>( vkCreateMacOSSurfaceMVK( m_instance, reinterpret_cast<const VkMacOSSurfaceCreateInfoMVK*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkSurfaceKHR*>( &surface ) ) );
-
-    SurfaceKHRDeleter deleter( *this, allocator );
-    return createResultValue( result, surface, "VULKAN_HPP_NAMESPACE::Instance::createMacOSSurfaceMVKUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  struct DeviceGroupDeviceCreateInfoKHX
-  {
-    DeviceGroupDeviceCreateInfoKHX( uint32_t physicalDeviceCount_ = 0, const PhysicalDevice* pPhysicalDevices_ = nullptr )
-      : physicalDeviceCount( physicalDeviceCount_ )
-      , pPhysicalDevices( pPhysicalDevices_ )
-    {
-    }
-
-    DeviceGroupDeviceCreateInfoKHX( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) );
-    }
-
-    DeviceGroupDeviceCreateInfoKHX& operator=( VkDeviceGroupDeviceCreateInfoKHX const & rhs )
-    {
-      memcpy( this, &rhs, sizeof( DeviceGroupDeviceCreateInfoKHX ) );
-      return *this;
-    }
-    DeviceGroupDeviceCreateInfoKHX& setPNext( const void* pNext_ )
-    {
-      pNext = pNext_;
-      return *this;
-    }
-
-    DeviceGroupDeviceCreateInfoKHX& setPhysicalDeviceCount( uint32_t physicalDeviceCount_ )
-    {
-      physicalDeviceCount = physicalDeviceCount_;
-      return *this;
-    }
-
-    DeviceGroupDeviceCreateInfoKHX& setPPhysicalDevices( const PhysicalDevice* pPhysicalDevices_ )
-    {
-      pPhysicalDevices = pPhysicalDevices_;
-      return *this;
-    }
-
-    operator const VkDeviceGroupDeviceCreateInfoKHX&() const
-    {
-      return *reinterpret_cast<const VkDeviceGroupDeviceCreateInfoKHX*>(this);
-    }
-
-    bool operator==( DeviceGroupDeviceCreateInfoKHX const& rhs ) const
-    {
-      return ( sType == rhs.sType )
-          && ( pNext == rhs.pNext )
-          && ( physicalDeviceCount == rhs.physicalDeviceCount )
-          && ( pPhysicalDevices == rhs.pPhysicalDevices );
-    }
-
-    bool operator!=( DeviceGroupDeviceCreateInfoKHX const& rhs ) const
-    {
-      return !operator==( rhs );
-    }
-
-  private:
-    StructureType sType = StructureType::eDeviceGroupDeviceCreateInfoKHX;
-
-  public:
-    const void* pNext = nullptr;
-    uint32_t physicalDeviceCount;
-    const PhysicalDevice* pPhysicalDevices;
-  };
-  static_assert( sizeof( DeviceGroupDeviceCreateInfoKHX ) == sizeof( VkDeviceGroupDeviceCreateInfoKHX ), "struct and wrapper have different size!" );
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class InstanceDeleter;
-  template <> class UniqueHandleTraits<Instance> {public: using deleter = InstanceDeleter; };
-  using UniqueInstance = UniqueHandle<Instance>;
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance );
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  ResultValueType<UniqueInstance>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator = nullptr );
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  class InstanceDeleter
-  {
-  public:
-    InstanceDeleter( Optional<const AllocationCallbacks> allocator = nullptr )
-      : m_allocator( allocator )
-    {}
-
-    Optional<const AllocationCallbacks> getAllocator() const { return m_allocator; }
-
-  protected:
-    void destroy( Instance instance )
-    {
-      instance.destroy( m_allocator );
-    }
-
-  private:
-    Optional<const AllocationCallbacks> m_allocator;
-  };
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-
-  VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo* pCreateInfo, const AllocationCallbacks* pAllocator, Instance* pInstance )
-  {
-    return static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( pCreateInfo ), reinterpret_cast<const VkAllocationCallbacks*>( pAllocator ), reinterpret_cast<VkInstance*>( pInstance ) ) );
-  }
-#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  VULKAN_HPP_INLINE ResultValueType<Instance>::type createInstance( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator )
-  {
-    Instance instance;
-    Result result = static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
-    return createResultValue( result, instance, "VULKAN_HPP_NAMESPACE::createInstance" );
-  }
-#ifndef VULKAN_HPP_NO_SMART_HANDLE
-  VULKAN_HPP_INLINE ResultValueType<UniqueInstance>::type createInstanceUnique( const InstanceCreateInfo & createInfo, Optional<const AllocationCallbacks> allocator )
-  {
-    Instance instance;
-    Result result = static_cast<Result>( vkCreateInstance( reinterpret_cast<const VkInstanceCreateInfo*>( &createInfo ), reinterpret_cast<const VkAllocationCallbacks*>( static_cast<const AllocationCallbacks*>( allocator ) ), reinterpret_cast<VkInstance*>( &instance ) ) );
-
-    InstanceDeleter deleter( allocator );
-    return createResultValue( result, instance, "VULKAN_HPP_NAMESPACE::createInstanceUnique", deleter );
-  }
-#endif /*VULKAN_HPP_NO_SMART_HANDLE*/
-#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
-
-
-  template <> struct isStructureChainValid<PresentInfoKHR, DisplayPresentInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, DedicatedAllocationImageCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BufferCreateInfo, DedicatedAllocationBufferCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, DedicatedAllocationMemoryAllocateInfoNV>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoNV>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoNV>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceFeatures2KHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDevicePushDescriptorPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, PresentRegionsKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceVariablePointerFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceVariablePointerFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceIDPropertiesKHR>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, Win32KeyedMutexAcquireReleaseInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<SubmitInfo, D3D12FenceSubmitInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceMultiviewFeaturesKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceMultiviewFeaturesKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceMultiviewPropertiesKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassMultiviewCreateInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindBufferMemoryInfoKHR, BindBufferMemoryDeviceGroupInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImageMemoryDeviceGroupInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassBeginInfo, DeviceGroupRenderPassBeginInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<CommandBufferBeginInfo, DeviceGroupCommandBufferBeginInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SubmitInfo, DeviceGroupSubmitInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindSparseInfo, DeviceGroupBindSparseInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageSwapchainCreateInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImageMemorySwapchainInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, PresentTimesInfoGOOGLE>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportWScalingStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceDiscardRectanglePropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDevice16BitStorageFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDevice16BitStorageFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryRequirements2KHR, MemoryDedicatedRequirementsKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryDedicatedAllocateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerYcbcrConversionInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageViewCreateInfo, SamplerYcbcrConversionInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2KHR, SamplerYcbcrConversionImageFormatPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2KHR, TextureLODGatherFormatPropertiesAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageToColorStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceFeatures2KHR, PhysicalDeviceBlendOperationAdvancedFeaturesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceBlendOperationAdvancedPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ImageFormatListCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ShaderModuleCreateInfo, ShaderModuleValidationCacheCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceExternalMemoryHostPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceConservativeRasterizationPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SurfaceCapabilities2KHR, SharedPresentSurfaceCapabilitiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageViewCreateInfo, ImageViewUsageCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassCreateInfo, RenderPassInputAttachmentAspectCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BindImageMemoryInfoKHR, BindImagePlaneMemoryInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageMemoryRequirementsInfo2KHR, ImagePlaneMemoryRequirementsInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageMemoryBarrier, SampleLocationsInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<RenderPassBeginInfo, RenderPassSampleLocationsBeginInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineSampleLocationsStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDeviceSampleLocationsPropertiesEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<InstanceCreateInfo, DebugReportCallbackCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationStateRasterizationOrderAMD>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoNV>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoNV>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<InstanceCreateInfo, ValidationFlagsEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceImageFormatInfo2KHR, PhysicalDeviceExternalImageFormatInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageCreateInfo, ExternalMemoryImageCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<BufferCreateInfo, ExternalMemoryBufferCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ExportMemoryAllocateInfoKHR>{ enum { value = true }; };
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryWin32HandleInfoKHR>{ enum { value = true }; };
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryFdInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, ImportMemoryHostPointerInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<ImageFormatProperties2KHR, ExternalImageFormatPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SemaphoreCreateInfo, ExportSemaphoreCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<FenceCreateInfo, ExportFenceCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, SwapchainCounterCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<MemoryAllocateInfo, MemoryAllocateFlagsInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PresentInfoKHR, DeviceGroupPresentInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SwapchainCreateInfoKHR, DeviceGroupSwapchainCreateInfoKHX>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineViewportStateCreateInfo, PipelineViewportSwizzleStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<GraphicsPipelineCreateInfo, PipelineDiscardRectangleStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PhysicalDeviceProperties2KHR, PhysicalDevicePointClippingPropertiesKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<SamplerCreateInfo, SamplerReductionModeCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineTessellationStateCreateInfo, PipelineTessellationDomainOriginStateCreateInfoKHR>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineColorBlendStateCreateInfo, PipelineColorBlendAdvancedStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineMultisampleStateCreateInfo, PipelineCoverageModulationStateCreateInfoNV>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceQueueCreateInfo, DeviceQueueGlobalPriorityCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<PipelineRasterizationStateCreateInfo, PipelineRasterizationConservativeStateCreateInfoEXT>{ enum { value = true }; };
-  template <> struct isStructureChainValid<DeviceCreateInfo, DeviceGroupDeviceCreateInfoKHX>{ enum { value = true }; };
-  VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FramebufferCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPoolCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RenderPassCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineLayoutCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDepthStencilStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDynamicStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineColorBlendStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineMultisampleStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineTessellationStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineInputAssemblyStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineVertexInputStateCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineShaderStageCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferViewCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InstanceCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceQueueCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderModuleCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(EventCreateFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(EventCreateFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryMapFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryMapFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlagBits)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolResetFlags)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateCreateFlagsKHR)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayModeCreateFlagsKHR)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplaySurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
-  VULKAN_HPP_INLINE std::string to_string(AndroidSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_ANDROID_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_MIR_KHR
-  VULKAN_HPP_INLINE std::string to_string(MirSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_MIR_KHR*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagBitsNN)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_VI_NN
-  VULKAN_HPP_INLINE std::string to_string(ViSurfaceCreateFlagsNN)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_VI_NN*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WAYLAND_KHR
-  VULKAN_HPP_INLINE std::string to_string(WaylandSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR
-  VULKAN_HPP_INLINE std::string to_string(Win32SurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_WIN32_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XLIB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XlibSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_XLIB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagBitsKHR)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_XCB_KHR
-  VULKAN_HPP_INLINE std::string to_string(XcbSurfaceCreateFlagsKHR)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_XCB_KHR*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagBitsMVK)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_IOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(IOSSurfaceCreateFlagsMVK)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_IOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagBitsMVK)
-  {
-    return "(void)";
-  }
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-  VULKAN_HPP_INLINE std::string to_string(MacOSSurfaceCreateFlagsMVK)
-  {
-    return "{}";
-  }
-#endif /*VK_USE_PLATFORM_MACOS_MVK*/
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagBitsKHR)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolTrimFlagsKHR)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineViewportSwizzleStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineDiscardRectangleStateCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageToColorStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagBitsNV)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCoverageModulationStateCreateFlagsNV)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagBitsEXT)
-  {
-    return "(void)";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineRasterizationConservativeStateCreateFlagsEXT)
-  {
-    return "{}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageLayout value)
-  {
-    switch (value)
-    {
-    case ImageLayout::eUndefined: return "Undefined";
-    case ImageLayout::eGeneral: return "General";
-    case ImageLayout::eColorAttachmentOptimal: return "ColorAttachmentOptimal";
-    case ImageLayout::eDepthStencilAttachmentOptimal: return "DepthStencilAttachmentOptimal";
-    case ImageLayout::eDepthStencilReadOnlyOptimal: return "DepthStencilReadOnlyOptimal";
-    case ImageLayout::eShaderReadOnlyOptimal: return "ShaderReadOnlyOptimal";
-    case ImageLayout::eTransferSrcOptimal: return "TransferSrcOptimal";
-    case ImageLayout::eTransferDstOptimal: return "TransferDstOptimal";
-    case ImageLayout::ePreinitialized: return "Preinitialized";
-    case ImageLayout::ePresentSrcKHR: return "PresentSrcKHR";
-    case ImageLayout::eSharedPresentKHR: return "SharedPresentKHR";
-    case ImageLayout::eDepthReadOnlyStencilAttachmentOptimalKHR: return "DepthReadOnlyStencilAttachmentOptimalKHR";
-    case ImageLayout::eDepthAttachmentStencilReadOnlyOptimalKHR: return "DepthAttachmentStencilReadOnlyOptimalKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentLoadOp value)
-  {
-    switch (value)
-    {
-    case AttachmentLoadOp::eLoad: return "Load";
-    case AttachmentLoadOp::eClear: return "Clear";
-    case AttachmentLoadOp::eDontCare: return "DontCare";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentStoreOp value)
-  {
-    switch (value)
-    {
-    case AttachmentStoreOp::eStore: return "Store";
-    case AttachmentStoreOp::eDontCare: return "DontCare";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageType value)
-  {
-    switch (value)
-    {
-    case ImageType::e1D: return "1D";
-    case ImageType::e2D: return "2D";
-    case ImageType::e3D: return "3D";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageTiling value)
-  {
-    switch (value)
-    {
-    case ImageTiling::eOptimal: return "Optimal";
-    case ImageTiling::eLinear: return "Linear";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageViewType value)
-  {
-    switch (value)
-    {
-    case ImageViewType::e1D: return "1D";
-    case ImageViewType::e2D: return "2D";
-    case ImageViewType::e3D: return "3D";
-    case ImageViewType::eCube: return "Cube";
-    case ImageViewType::e1DArray: return "1DArray";
-    case ImageViewType::e2DArray: return "2DArray";
-    case ImageViewType::eCubeArray: return "CubeArray";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferLevel value)
-  {
-    switch (value)
-    {
-    case CommandBufferLevel::ePrimary: return "Primary";
-    case CommandBufferLevel::eSecondary: return "Secondary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ComponentSwizzle value)
-  {
-    switch (value)
-    {
-    case ComponentSwizzle::eIdentity: return "Identity";
-    case ComponentSwizzle::eZero: return "Zero";
-    case ComponentSwizzle::eOne: return "One";
-    case ComponentSwizzle::eR: return "R";
-    case ComponentSwizzle::eG: return "G";
-    case ComponentSwizzle::eB: return "B";
-    case ComponentSwizzle::eA: return "A";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorType value)
-  {
-    switch (value)
-    {
-    case DescriptorType::eSampler: return "Sampler";
-    case DescriptorType::eCombinedImageSampler: return "CombinedImageSampler";
-    case DescriptorType::eSampledImage: return "SampledImage";
-    case DescriptorType::eStorageImage: return "StorageImage";
-    case DescriptorType::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case DescriptorType::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case DescriptorType::eUniformBuffer: return "UniformBuffer";
-    case DescriptorType::eStorageBuffer: return "StorageBuffer";
-    case DescriptorType::eUniformBufferDynamic: return "UniformBufferDynamic";
-    case DescriptorType::eStorageBufferDynamic: return "StorageBufferDynamic";
-    case DescriptorType::eInputAttachment: return "InputAttachment";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryType value)
-  {
-    switch (value)
-    {
-    case QueryType::eOcclusion: return "Occlusion";
-    case QueryType::ePipelineStatistics: return "PipelineStatistics";
-    case QueryType::eTimestamp: return "Timestamp";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BorderColor value)
-  {
-    switch (value)
-    {
-    case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack";
-    case BorderColor::eIntTransparentBlack: return "IntTransparentBlack";
-    case BorderColor::eFloatOpaqueBlack: return "FloatOpaqueBlack";
-    case BorderColor::eIntOpaqueBlack: return "IntOpaqueBlack";
-    case BorderColor::eFloatOpaqueWhite: return "FloatOpaqueWhite";
-    case BorderColor::eIntOpaqueWhite: return "IntOpaqueWhite";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineBindPoint value)
-  {
-    switch (value)
-    {
-    case PipelineBindPoint::eGraphics: return "Graphics";
-    case PipelineBindPoint::eCompute: return "Compute";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCacheHeaderVersion value)
-  {
-    switch (value)
-    {
-    case PipelineCacheHeaderVersion::eOne: return "One";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PrimitiveTopology value)
-  {
-    switch (value)
-    {
-    case PrimitiveTopology::ePointList: return "PointList";
-    case PrimitiveTopology::eLineList: return "LineList";
-    case PrimitiveTopology::eLineStrip: return "LineStrip";
-    case PrimitiveTopology::eTriangleList: return "TriangleList";
-    case PrimitiveTopology::eTriangleStrip: return "TriangleStrip";
-    case PrimitiveTopology::eTriangleFan: return "TriangleFan";
-    case PrimitiveTopology::eLineListWithAdjacency: return "LineListWithAdjacency";
-    case PrimitiveTopology::eLineStripWithAdjacency: return "LineStripWithAdjacency";
-    case PrimitiveTopology::eTriangleListWithAdjacency: return "TriangleListWithAdjacency";
-    case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency";
-    case PrimitiveTopology::ePatchList: return "PatchList";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SharingMode value)
-  {
-    switch (value)
-    {
-    case SharingMode::eExclusive: return "Exclusive";
-    case SharingMode::eConcurrent: return "Concurrent";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndexType value)
-  {
-    switch (value)
-    {
-    case IndexType::eUint16: return "Uint16";
-    case IndexType::eUint32: return "Uint32";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(Filter value)
-  {
-    switch (value)
-    {
-    case Filter::eNearest: return "Nearest";
-    case Filter::eLinear: return "Linear";
-    case Filter::eCubicIMG: return "CubicIMG";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerMipmapMode value)
-  {
-    switch (value)
-    {
-    case SamplerMipmapMode::eNearest: return "Nearest";
-    case SamplerMipmapMode::eLinear: return "Linear";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerAddressMode value)
-  {
-    switch (value)
-    {
-    case SamplerAddressMode::eRepeat: return "Repeat";
-    case SamplerAddressMode::eMirroredRepeat: return "MirroredRepeat";
-    case SamplerAddressMode::eClampToEdge: return "ClampToEdge";
-    case SamplerAddressMode::eClampToBorder: return "ClampToBorder";
-    case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompareOp value)
-  {
-    switch (value)
-    {
-    case CompareOp::eNever: return "Never";
-    case CompareOp::eLess: return "Less";
-    case CompareOp::eEqual: return "Equal";
-    case CompareOp::eLessOrEqual: return "LessOrEqual";
-    case CompareOp::eGreater: return "Greater";
-    case CompareOp::eNotEqual: return "NotEqual";
-    case CompareOp::eGreaterOrEqual: return "GreaterOrEqual";
-    case CompareOp::eAlways: return "Always";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PolygonMode value)
-  {
-    switch (value)
-    {
-    case PolygonMode::eFill: return "Fill";
-    case PolygonMode::eLine: return "Line";
-    case PolygonMode::ePoint: return "Point";
-    case PolygonMode::eFillRectangleNV: return "FillRectangleNV";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CullModeFlagBits value)
-  {
-    switch (value)
-    {
-    case CullModeFlagBits::eNone: return "None";
-    case CullModeFlagBits::eFront: return "Front";
-    case CullModeFlagBits::eBack: return "Back";
-    case CullModeFlagBits::eFrontAndBack: return "FrontAndBack";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CullModeFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CullModeFlagBits::eNone) result += "None | ";
-    if (value & CullModeFlagBits::eFront) result += "Front | ";
-    if (value & CullModeFlagBits::eBack) result += "Back | ";
-    if (value & CullModeFlagBits::eFrontAndBack) result += "FrontAndBack | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FrontFace value)
-  {
-    switch (value)
-    {
-    case FrontFace::eCounterClockwise: return "CounterClockwise";
-    case FrontFace::eClockwise: return "Clockwise";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendFactor value)
-  {
-    switch (value)
-    {
-    case BlendFactor::eZero: return "Zero";
-    case BlendFactor::eOne: return "One";
-    case BlendFactor::eSrcColor: return "SrcColor";
-    case BlendFactor::eOneMinusSrcColor: return "OneMinusSrcColor";
-    case BlendFactor::eDstColor: return "DstColor";
-    case BlendFactor::eOneMinusDstColor: return "OneMinusDstColor";
-    case BlendFactor::eSrcAlpha: return "SrcAlpha";
-    case BlendFactor::eOneMinusSrcAlpha: return "OneMinusSrcAlpha";
-    case BlendFactor::eDstAlpha: return "DstAlpha";
-    case BlendFactor::eOneMinusDstAlpha: return "OneMinusDstAlpha";
-    case BlendFactor::eConstantColor: return "ConstantColor";
-    case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor";
-    case BlendFactor::eConstantAlpha: return "ConstantAlpha";
-    case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha";
-    case BlendFactor::eSrcAlphaSaturate: return "SrcAlphaSaturate";
-    case BlendFactor::eSrc1Color: return "Src1Color";
-    case BlendFactor::eOneMinusSrc1Color: return "OneMinusSrc1Color";
-    case BlendFactor::eSrc1Alpha: return "Src1Alpha";
-    case BlendFactor::eOneMinusSrc1Alpha: return "OneMinusSrc1Alpha";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendOp value)
-  {
-    switch (value)
-    {
-    case BlendOp::eAdd: return "Add";
-    case BlendOp::eSubtract: return "Subtract";
-    case BlendOp::eReverseSubtract: return "ReverseSubtract";
-    case BlendOp::eMin: return "Min";
-    case BlendOp::eMax: return "Max";
-    case BlendOp::eZeroEXT: return "ZeroEXT";
-    case BlendOp::eSrcEXT: return "SrcEXT";
-    case BlendOp::eDstEXT: return "DstEXT";
-    case BlendOp::eSrcOverEXT: return "SrcOverEXT";
-    case BlendOp::eDstOverEXT: return "DstOverEXT";
-    case BlendOp::eSrcInEXT: return "SrcInEXT";
-    case BlendOp::eDstInEXT: return "DstInEXT";
-    case BlendOp::eSrcOutEXT: return "SrcOutEXT";
-    case BlendOp::eDstOutEXT: return "DstOutEXT";
-    case BlendOp::eSrcAtopEXT: return "SrcAtopEXT";
-    case BlendOp::eDstAtopEXT: return "DstAtopEXT";
-    case BlendOp::eXorEXT: return "XorEXT";
-    case BlendOp::eMultiplyEXT: return "MultiplyEXT";
-    case BlendOp::eScreenEXT: return "ScreenEXT";
-    case BlendOp::eOverlayEXT: return "OverlayEXT";
-    case BlendOp::eDarkenEXT: return "DarkenEXT";
-    case BlendOp::eLightenEXT: return "LightenEXT";
-    case BlendOp::eColordodgeEXT: return "ColordodgeEXT";
-    case BlendOp::eColorburnEXT: return "ColorburnEXT";
-    case BlendOp::eHardlightEXT: return "HardlightEXT";
-    case BlendOp::eSoftlightEXT: return "SoftlightEXT";
-    case BlendOp::eDifferenceEXT: return "DifferenceEXT";
-    case BlendOp::eExclusionEXT: return "ExclusionEXT";
-    case BlendOp::eInvertEXT: return "InvertEXT";
-    case BlendOp::eInvertRgbEXT: return "InvertRgbEXT";
-    case BlendOp::eLineardodgeEXT: return "LineardodgeEXT";
-    case BlendOp::eLinearburnEXT: return "LinearburnEXT";
-    case BlendOp::eVividlightEXT: return "VividlightEXT";
-    case BlendOp::eLinearlightEXT: return "LinearlightEXT";
-    case BlendOp::ePinlightEXT: return "PinlightEXT";
-    case BlendOp::eHardmixEXT: return "HardmixEXT";
-    case BlendOp::eHslHueEXT: return "HslHueEXT";
-    case BlendOp::eHslSaturationEXT: return "HslSaturationEXT";
-    case BlendOp::eHslColorEXT: return "HslColorEXT";
-    case BlendOp::eHslLuminosityEXT: return "HslLuminosityEXT";
-    case BlendOp::ePlusEXT: return "PlusEXT";
-    case BlendOp::ePlusClampedEXT: return "PlusClampedEXT";
-    case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT";
-    case BlendOp::ePlusDarkerEXT: return "PlusDarkerEXT";
-    case BlendOp::eMinusEXT: return "MinusEXT";
-    case BlendOp::eMinusClampedEXT: return "MinusClampedEXT";
-    case BlendOp::eContrastEXT: return "ContrastEXT";
-    case BlendOp::eInvertOvgEXT: return "InvertOvgEXT";
-    case BlendOp::eRedEXT: return "RedEXT";
-    case BlendOp::eGreenEXT: return "GreenEXT";
-    case BlendOp::eBlueEXT: return "BlueEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilOp value)
-  {
-    switch (value)
-    {
-    case StencilOp::eKeep: return "Keep";
-    case StencilOp::eZero: return "Zero";
-    case StencilOp::eReplace: return "Replace";
-    case StencilOp::eIncrementAndClamp: return "IncrementAndClamp";
-    case StencilOp::eDecrementAndClamp: return "DecrementAndClamp";
-    case StencilOp::eInvert: return "Invert";
-    case StencilOp::eIncrementAndWrap: return "IncrementAndWrap";
-    case StencilOp::eDecrementAndWrap: return "DecrementAndWrap";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(LogicOp value)
-  {
-    switch (value)
-    {
-    case LogicOp::eClear: return "Clear";
-    case LogicOp::eAnd: return "And";
-    case LogicOp::eAndReverse: return "AndReverse";
-    case LogicOp::eCopy: return "Copy";
-    case LogicOp::eAndInverted: return "AndInverted";
-    case LogicOp::eNoOp: return "NoOp";
-    case LogicOp::eXor: return "Xor";
-    case LogicOp::eOr: return "Or";
-    case LogicOp::eNor: return "Nor";
-    case LogicOp::eEquivalent: return "Equivalent";
-    case LogicOp::eInvert: return "Invert";
-    case LogicOp::eOrReverse: return "OrReverse";
-    case LogicOp::eCopyInverted: return "CopyInverted";
-    case LogicOp::eOrInverted: return "OrInverted";
-    case LogicOp::eNand: return "Nand";
-    case LogicOp::eSet: return "Set";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(InternalAllocationType value)
-  {
-    switch (value)
-    {
-    case InternalAllocationType::eExecutable: return "Executable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SystemAllocationScope value)
-  {
-    switch (value)
-    {
-    case SystemAllocationScope::eCommand: return "Command";
-    case SystemAllocationScope::eObject: return "Object";
-    case SystemAllocationScope::eCache: return "Cache";
-    case SystemAllocationScope::eDevice: return "Device";
-    case SystemAllocationScope::eInstance: return "Instance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PhysicalDeviceType value)
-  {
-    switch (value)
-    {
-    case PhysicalDeviceType::eOther: return "Other";
-    case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu";
-    case PhysicalDeviceType::eDiscreteGpu: return "DiscreteGpu";
-    case PhysicalDeviceType::eVirtualGpu: return "VirtualGpu";
-    case PhysicalDeviceType::eCpu: return "Cpu";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(VertexInputRate value)
-  {
-    switch (value)
-    {
-    case VertexInputRate::eVertex: return "Vertex";
-    case VertexInputRate::eInstance: return "Instance";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(Format value)
-  {
-    switch (value)
-    {
-    case Format::eUndefined: return "Undefined";
-    case Format::eR4G4UnormPack8: return "R4G4UnormPack8";
-    case Format::eR4G4B4A4UnormPack16: return "R4G4B4A4UnormPack16";
-    case Format::eB4G4R4A4UnormPack16: return "B4G4R4A4UnormPack16";
-    case Format::eR5G6B5UnormPack16: return "R5G6B5UnormPack16";
-    case Format::eB5G6R5UnormPack16: return "B5G6R5UnormPack16";
-    case Format::eR5G5B5A1UnormPack16: return "R5G5B5A1UnormPack16";
-    case Format::eB5G5R5A1UnormPack16: return "B5G5R5A1UnormPack16";
-    case Format::eA1R5G5B5UnormPack16: return "A1R5G5B5UnormPack16";
-    case Format::eR8Unorm: return "R8Unorm";
-    case Format::eR8Snorm: return "R8Snorm";
-    case Format::eR8Uscaled: return "R8Uscaled";
-    case Format::eR8Sscaled: return "R8Sscaled";
-    case Format::eR8Uint: return "R8Uint";
-    case Format::eR8Sint: return "R8Sint";
-    case Format::eR8Srgb: return "R8Srgb";
-    case Format::eR8G8Unorm: return "R8G8Unorm";
-    case Format::eR8G8Snorm: return "R8G8Snorm";
-    case Format::eR8G8Uscaled: return "R8G8Uscaled";
-    case Format::eR8G8Sscaled: return "R8G8Sscaled";
-    case Format::eR8G8Uint: return "R8G8Uint";
-    case Format::eR8G8Sint: return "R8G8Sint";
-    case Format::eR8G8Srgb: return "R8G8Srgb";
-    case Format::eR8G8B8Unorm: return "R8G8B8Unorm";
-    case Format::eR8G8B8Snorm: return "R8G8B8Snorm";
-    case Format::eR8G8B8Uscaled: return "R8G8B8Uscaled";
-    case Format::eR8G8B8Sscaled: return "R8G8B8Sscaled";
-    case Format::eR8G8B8Uint: return "R8G8B8Uint";
-    case Format::eR8G8B8Sint: return "R8G8B8Sint";
-    case Format::eR8G8B8Srgb: return "R8G8B8Srgb";
-    case Format::eB8G8R8Unorm: return "B8G8R8Unorm";
-    case Format::eB8G8R8Snorm: return "B8G8R8Snorm";
-    case Format::eB8G8R8Uscaled: return "B8G8R8Uscaled";
-    case Format::eB8G8R8Sscaled: return "B8G8R8Sscaled";
-    case Format::eB8G8R8Uint: return "B8G8R8Uint";
-    case Format::eB8G8R8Sint: return "B8G8R8Sint";
-    case Format::eB8G8R8Srgb: return "B8G8R8Srgb";
-    case Format::eR8G8B8A8Unorm: return "R8G8B8A8Unorm";
-    case Format::eR8G8B8A8Snorm: return "R8G8B8A8Snorm";
-    case Format::eR8G8B8A8Uscaled: return "R8G8B8A8Uscaled";
-    case Format::eR8G8B8A8Sscaled: return "R8G8B8A8Sscaled";
-    case Format::eR8G8B8A8Uint: return "R8G8B8A8Uint";
-    case Format::eR8G8B8A8Sint: return "R8G8B8A8Sint";
-    case Format::eR8G8B8A8Srgb: return "R8G8B8A8Srgb";
-    case Format::eB8G8R8A8Unorm: return "B8G8R8A8Unorm";
-    case Format::eB8G8R8A8Snorm: return "B8G8R8A8Snorm";
-    case Format::eB8G8R8A8Uscaled: return "B8G8R8A8Uscaled";
-    case Format::eB8G8R8A8Sscaled: return "B8G8R8A8Sscaled";
-    case Format::eB8G8R8A8Uint: return "B8G8R8A8Uint";
-    case Format::eB8G8R8A8Sint: return "B8G8R8A8Sint";
-    case Format::eB8G8R8A8Srgb: return "B8G8R8A8Srgb";
-    case Format::eA8B8G8R8UnormPack32: return "A8B8G8R8UnormPack32";
-    case Format::eA8B8G8R8SnormPack32: return "A8B8G8R8SnormPack32";
-    case Format::eA8B8G8R8UscaledPack32: return "A8B8G8R8UscaledPack32";
-    case Format::eA8B8G8R8SscaledPack32: return "A8B8G8R8SscaledPack32";
-    case Format::eA8B8G8R8UintPack32: return "A8B8G8R8UintPack32";
-    case Format::eA8B8G8R8SintPack32: return "A8B8G8R8SintPack32";
-    case Format::eA8B8G8R8SrgbPack32: return "A8B8G8R8SrgbPack32";
-    case Format::eA2R10G10B10UnormPack32: return "A2R10G10B10UnormPack32";
-    case Format::eA2R10G10B10SnormPack32: return "A2R10G10B10SnormPack32";
-    case Format::eA2R10G10B10UscaledPack32: return "A2R10G10B10UscaledPack32";
-    case Format::eA2R10G10B10SscaledPack32: return "A2R10G10B10SscaledPack32";
-    case Format::eA2R10G10B10UintPack32: return "A2R10G10B10UintPack32";
-    case Format::eA2R10G10B10SintPack32: return "A2R10G10B10SintPack32";
-    case Format::eA2B10G10R10UnormPack32: return "A2B10G10R10UnormPack32";
-    case Format::eA2B10G10R10SnormPack32: return "A2B10G10R10SnormPack32";
-    case Format::eA2B10G10R10UscaledPack32: return "A2B10G10R10UscaledPack32";
-    case Format::eA2B10G10R10SscaledPack32: return "A2B10G10R10SscaledPack32";
-    case Format::eA2B10G10R10UintPack32: return "A2B10G10R10UintPack32";
-    case Format::eA2B10G10R10SintPack32: return "A2B10G10R10SintPack32";
-    case Format::eR16Unorm: return "R16Unorm";
-    case Format::eR16Snorm: return "R16Snorm";
-    case Format::eR16Uscaled: return "R16Uscaled";
-    case Format::eR16Sscaled: return "R16Sscaled";
-    case Format::eR16Uint: return "R16Uint";
-    case Format::eR16Sint: return "R16Sint";
-    case Format::eR16Sfloat: return "R16Sfloat";
-    case Format::eR16G16Unorm: return "R16G16Unorm";
-    case Format::eR16G16Snorm: return "R16G16Snorm";
-    case Format::eR16G16Uscaled: return "R16G16Uscaled";
-    case Format::eR16G16Sscaled: return "R16G16Sscaled";
-    case Format::eR16G16Uint: return "R16G16Uint";
-    case Format::eR16G16Sint: return "R16G16Sint";
-    case Format::eR16G16Sfloat: return "R16G16Sfloat";
-    case Format::eR16G16B16Unorm: return "R16G16B16Unorm";
-    case Format::eR16G16B16Snorm: return "R16G16B16Snorm";
-    case Format::eR16G16B16Uscaled: return "R16G16B16Uscaled";
-    case Format::eR16G16B16Sscaled: return "R16G16B16Sscaled";
-    case Format::eR16G16B16Uint: return "R16G16B16Uint";
-    case Format::eR16G16B16Sint: return "R16G16B16Sint";
-    case Format::eR16G16B16Sfloat: return "R16G16B16Sfloat";
-    case Format::eR16G16B16A16Unorm: return "R16G16B16A16Unorm";
-    case Format::eR16G16B16A16Snorm: return "R16G16B16A16Snorm";
-    case Format::eR16G16B16A16Uscaled: return "R16G16B16A16Uscaled";
-    case Format::eR16G16B16A16Sscaled: return "R16G16B16A16Sscaled";
-    case Format::eR16G16B16A16Uint: return "R16G16B16A16Uint";
-    case Format::eR16G16B16A16Sint: return "R16G16B16A16Sint";
-    case Format::eR16G16B16A16Sfloat: return "R16G16B16A16Sfloat";
-    case Format::eR32Uint: return "R32Uint";
-    case Format::eR32Sint: return "R32Sint";
-    case Format::eR32Sfloat: return "R32Sfloat";
-    case Format::eR32G32Uint: return "R32G32Uint";
-    case Format::eR32G32Sint: return "R32G32Sint";
-    case Format::eR32G32Sfloat: return "R32G32Sfloat";
-    case Format::eR32G32B32Uint: return "R32G32B32Uint";
-    case Format::eR32G32B32Sint: return "R32G32B32Sint";
-    case Format::eR32G32B32Sfloat: return "R32G32B32Sfloat";
-    case Format::eR32G32B32A32Uint: return "R32G32B32A32Uint";
-    case Format::eR32G32B32A32Sint: return "R32G32B32A32Sint";
-    case Format::eR32G32B32A32Sfloat: return "R32G32B32A32Sfloat";
-    case Format::eR64Uint: return "R64Uint";
-    case Format::eR64Sint: return "R64Sint";
-    case Format::eR64Sfloat: return "R64Sfloat";
-    case Format::eR64G64Uint: return "R64G64Uint";
-    case Format::eR64G64Sint: return "R64G64Sint";
-    case Format::eR64G64Sfloat: return "R64G64Sfloat";
-    case Format::eR64G64B64Uint: return "R64G64B64Uint";
-    case Format::eR64G64B64Sint: return "R64G64B64Sint";
-    case Format::eR64G64B64Sfloat: return "R64G64B64Sfloat";
-    case Format::eR64G64B64A64Uint: return "R64G64B64A64Uint";
-    case Format::eR64G64B64A64Sint: return "R64G64B64A64Sint";
-    case Format::eR64G64B64A64Sfloat: return "R64G64B64A64Sfloat";
-    case Format::eB10G11R11UfloatPack32: return "B10G11R11UfloatPack32";
-    case Format::eE5B9G9R9UfloatPack32: return "E5B9G9R9UfloatPack32";
-    case Format::eD16Unorm: return "D16Unorm";
-    case Format::eX8D24UnormPack32: return "X8D24UnormPack32";
-    case Format::eD32Sfloat: return "D32Sfloat";
-    case Format::eS8Uint: return "S8Uint";
-    case Format::eD16UnormS8Uint: return "D16UnormS8Uint";
-    case Format::eD24UnormS8Uint: return "D24UnormS8Uint";
-    case Format::eD32SfloatS8Uint: return "D32SfloatS8Uint";
-    case Format::eBc1RgbUnormBlock: return "Bc1RgbUnormBlock";
-    case Format::eBc1RgbSrgbBlock: return "Bc1RgbSrgbBlock";
-    case Format::eBc1RgbaUnormBlock: return "Bc1RgbaUnormBlock";
-    case Format::eBc1RgbaSrgbBlock: return "Bc1RgbaSrgbBlock";
-    case Format::eBc2UnormBlock: return "Bc2UnormBlock";
-    case Format::eBc2SrgbBlock: return "Bc2SrgbBlock";
-    case Format::eBc3UnormBlock: return "Bc3UnormBlock";
-    case Format::eBc3SrgbBlock: return "Bc3SrgbBlock";
-    case Format::eBc4UnormBlock: return "Bc4UnormBlock";
-    case Format::eBc4SnormBlock: return "Bc4SnormBlock";
-    case Format::eBc5UnormBlock: return "Bc5UnormBlock";
-    case Format::eBc5SnormBlock: return "Bc5SnormBlock";
-    case Format::eBc6HUfloatBlock: return "Bc6HUfloatBlock";
-    case Format::eBc6HSfloatBlock: return "Bc6HSfloatBlock";
-    case Format::eBc7UnormBlock: return "Bc7UnormBlock";
-    case Format::eBc7SrgbBlock: return "Bc7SrgbBlock";
-    case Format::eEtc2R8G8B8UnormBlock: return "Etc2R8G8B8UnormBlock";
-    case Format::eEtc2R8G8B8SrgbBlock: return "Etc2R8G8B8SrgbBlock";
-    case Format::eEtc2R8G8B8A1UnormBlock: return "Etc2R8G8B8A1UnormBlock";
-    case Format::eEtc2R8G8B8A1SrgbBlock: return "Etc2R8G8B8A1SrgbBlock";
-    case Format::eEtc2R8G8B8A8UnormBlock: return "Etc2R8G8B8A8UnormBlock";
-    case Format::eEtc2R8G8B8A8SrgbBlock: return "Etc2R8G8B8A8SrgbBlock";
-    case Format::eEacR11UnormBlock: return "EacR11UnormBlock";
-    case Format::eEacR11SnormBlock: return "EacR11SnormBlock";
-    case Format::eEacR11G11UnormBlock: return "EacR11G11UnormBlock";
-    case Format::eEacR11G11SnormBlock: return "EacR11G11SnormBlock";
-    case Format::eAstc4x4UnormBlock: return "Astc4x4UnormBlock";
-    case Format::eAstc4x4SrgbBlock: return "Astc4x4SrgbBlock";
-    case Format::eAstc5x4UnormBlock: return "Astc5x4UnormBlock";
-    case Format::eAstc5x4SrgbBlock: return "Astc5x4SrgbBlock";
-    case Format::eAstc5x5UnormBlock: return "Astc5x5UnormBlock";
-    case Format::eAstc5x5SrgbBlock: return "Astc5x5SrgbBlock";
-    case Format::eAstc6x5UnormBlock: return "Astc6x5UnormBlock";
-    case Format::eAstc6x5SrgbBlock: return "Astc6x5SrgbBlock";
-    case Format::eAstc6x6UnormBlock: return "Astc6x6UnormBlock";
-    case Format::eAstc6x6SrgbBlock: return "Astc6x6SrgbBlock";
-    case Format::eAstc8x5UnormBlock: return "Astc8x5UnormBlock";
-    case Format::eAstc8x5SrgbBlock: return "Astc8x5SrgbBlock";
-    case Format::eAstc8x6UnormBlock: return "Astc8x6UnormBlock";
-    case Format::eAstc8x6SrgbBlock: return "Astc8x6SrgbBlock";
-    case Format::eAstc8x8UnormBlock: return "Astc8x8UnormBlock";
-    case Format::eAstc8x8SrgbBlock: return "Astc8x8SrgbBlock";
-    case Format::eAstc10x5UnormBlock: return "Astc10x5UnormBlock";
-    case Format::eAstc10x5SrgbBlock: return "Astc10x5SrgbBlock";
-    case Format::eAstc10x6UnormBlock: return "Astc10x6UnormBlock";
-    case Format::eAstc10x6SrgbBlock: return "Astc10x6SrgbBlock";
-    case Format::eAstc10x8UnormBlock: return "Astc10x8UnormBlock";
-    case Format::eAstc10x8SrgbBlock: return "Astc10x8SrgbBlock";
-    case Format::eAstc10x10UnormBlock: return "Astc10x10UnormBlock";
-    case Format::eAstc10x10SrgbBlock: return "Astc10x10SrgbBlock";
-    case Format::eAstc12x10UnormBlock: return "Astc12x10UnormBlock";
-    case Format::eAstc12x10SrgbBlock: return "Astc12x10SrgbBlock";
-    case Format::eAstc12x12UnormBlock: return "Astc12x12UnormBlock";
-    case Format::eAstc12x12SrgbBlock: return "Astc12x12SrgbBlock";
-    case Format::ePvrtc12BppUnormBlockIMG: return "Pvrtc12BppUnormBlockIMG";
-    case Format::ePvrtc14BppUnormBlockIMG: return "Pvrtc14BppUnormBlockIMG";
-    case Format::ePvrtc22BppUnormBlockIMG: return "Pvrtc22BppUnormBlockIMG";
-    case Format::ePvrtc24BppUnormBlockIMG: return "Pvrtc24BppUnormBlockIMG";
-    case Format::ePvrtc12BppSrgbBlockIMG: return "Pvrtc12BppSrgbBlockIMG";
-    case Format::ePvrtc14BppSrgbBlockIMG: return "Pvrtc14BppSrgbBlockIMG";
-    case Format::ePvrtc22BppSrgbBlockIMG: return "Pvrtc22BppSrgbBlockIMG";
-    case Format::ePvrtc24BppSrgbBlockIMG: return "Pvrtc24BppSrgbBlockIMG";
-    case Format::eG8B8G8R8422UnormKHR: return "G8B8G8R8422UnormKHR";
-    case Format::eB8G8R8G8422UnormKHR: return "B8G8R8G8422UnormKHR";
-    case Format::eG8B8R83Plane420UnormKHR: return "G8B8R83Plane420UnormKHR";
-    case Format::eG8B8R82Plane420UnormKHR: return "G8B8R82Plane420UnormKHR";
-    case Format::eG8B8R83Plane422UnormKHR: return "G8B8R83Plane422UnormKHR";
-    case Format::eG8B8R82Plane422UnormKHR: return "G8B8R82Plane422UnormKHR";
-    case Format::eG8B8R83Plane444UnormKHR: return "G8B8R83Plane444UnormKHR";
-    case Format::eR10X6UnormPack16KHR: return "R10X6UnormPack16KHR";
-    case Format::eR10X6G10X6Unorm2Pack16KHR: return "R10X6G10X6Unorm2Pack16KHR";
-    case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16KHR: return "R10X6G10X6B10X6A10X6Unorm4Pack16KHR";
-    case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR: return "G10X6B10X6G10X6R10X6422Unorm4Pack16KHR";
-    case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR: return "B10X6G10X6R10X6G10X6422Unorm4Pack16KHR";
-    case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane420Unorm3Pack16KHR";
-    case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16KHR: return "G10X6B10X6R10X62Plane420Unorm3Pack16KHR";
-    case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane422Unorm3Pack16KHR";
-    case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16KHR: return "G10X6B10X6R10X62Plane422Unorm3Pack16KHR";
-    case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16KHR: return "G10X6B10X6R10X63Plane444Unorm3Pack16KHR";
-    case Format::eR12X4UnormPack16KHR: return "R12X4UnormPack16KHR";
-    case Format::eR12X4G12X4Unorm2Pack16KHR: return "R12X4G12X4Unorm2Pack16KHR";
-    case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16KHR: return "R12X4G12X4B12X4A12X4Unorm4Pack16KHR";
-    case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR: return "G12X4B12X4G12X4R12X4422Unorm4Pack16KHR";
-    case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR: return "B12X4G12X4R12X4G12X4422Unorm4Pack16KHR";
-    case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane420Unorm3Pack16KHR";
-    case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16KHR: return "G12X4B12X4R12X42Plane420Unorm3Pack16KHR";
-    case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane422Unorm3Pack16KHR";
-    case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16KHR: return "G12X4B12X4R12X42Plane422Unorm3Pack16KHR";
-    case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16KHR: return "G12X4B12X4R12X43Plane444Unorm3Pack16KHR";
-    case Format::eG16B16G16R16422UnormKHR: return "G16B16G16R16422UnormKHR";
-    case Format::eB16G16R16G16422UnormKHR: return "B16G16R16G16422UnormKHR";
-    case Format::eG16B16R163Plane420UnormKHR: return "G16B16R163Plane420UnormKHR";
-    case Format::eG16B16R162Plane420UnormKHR: return "G16B16R162Plane420UnormKHR";
-    case Format::eG16B16R163Plane422UnormKHR: return "G16B16R163Plane422UnormKHR";
-    case Format::eG16B16R162Plane422UnormKHR: return "G16B16R162Plane422UnormKHR";
-    case Format::eG16B16R163Plane444UnormKHR: return "G16B16R163Plane444UnormKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StructureType value)
-  {
-    switch (value)
-    {
-    case StructureType::eApplicationInfo: return "ApplicationInfo";
-    case StructureType::eInstanceCreateInfo: return "InstanceCreateInfo";
-    case StructureType::eDeviceQueueCreateInfo: return "DeviceQueueCreateInfo";
-    case StructureType::eDeviceCreateInfo: return "DeviceCreateInfo";
-    case StructureType::eSubmitInfo: return "SubmitInfo";
-    case StructureType::eMemoryAllocateInfo: return "MemoryAllocateInfo";
-    case StructureType::eMappedMemoryRange: return "MappedMemoryRange";
-    case StructureType::eBindSparseInfo: return "BindSparseInfo";
-    case StructureType::eFenceCreateInfo: return "FenceCreateInfo";
-    case StructureType::eSemaphoreCreateInfo: return "SemaphoreCreateInfo";
-    case StructureType::eEventCreateInfo: return "EventCreateInfo";
-    case StructureType::eQueryPoolCreateInfo: return "QueryPoolCreateInfo";
-    case StructureType::eBufferCreateInfo: return "BufferCreateInfo";
-    case StructureType::eBufferViewCreateInfo: return "BufferViewCreateInfo";
-    case StructureType::eImageCreateInfo: return "ImageCreateInfo";
-    case StructureType::eImageViewCreateInfo: return "ImageViewCreateInfo";
-    case StructureType::eShaderModuleCreateInfo: return "ShaderModuleCreateInfo";
-    case StructureType::ePipelineCacheCreateInfo: return "PipelineCacheCreateInfo";
-    case StructureType::ePipelineShaderStageCreateInfo: return "PipelineShaderStageCreateInfo";
-    case StructureType::ePipelineVertexInputStateCreateInfo: return "PipelineVertexInputStateCreateInfo";
-    case StructureType::ePipelineInputAssemblyStateCreateInfo: return "PipelineInputAssemblyStateCreateInfo";
-    case StructureType::ePipelineTessellationStateCreateInfo: return "PipelineTessellationStateCreateInfo";
-    case StructureType::ePipelineViewportStateCreateInfo: return "PipelineViewportStateCreateInfo";
-    case StructureType::ePipelineRasterizationStateCreateInfo: return "PipelineRasterizationStateCreateInfo";
-    case StructureType::ePipelineMultisampleStateCreateInfo: return "PipelineMultisampleStateCreateInfo";
-    case StructureType::ePipelineDepthStencilStateCreateInfo: return "PipelineDepthStencilStateCreateInfo";
-    case StructureType::ePipelineColorBlendStateCreateInfo: return "PipelineColorBlendStateCreateInfo";
-    case StructureType::ePipelineDynamicStateCreateInfo: return "PipelineDynamicStateCreateInfo";
-    case StructureType::eGraphicsPipelineCreateInfo: return "GraphicsPipelineCreateInfo";
-    case StructureType::eComputePipelineCreateInfo: return "ComputePipelineCreateInfo";
-    case StructureType::ePipelineLayoutCreateInfo: return "PipelineLayoutCreateInfo";
-    case StructureType::eSamplerCreateInfo: return "SamplerCreateInfo";
-    case StructureType::eDescriptorSetLayoutCreateInfo: return "DescriptorSetLayoutCreateInfo";
-    case StructureType::eDescriptorPoolCreateInfo: return "DescriptorPoolCreateInfo";
-    case StructureType::eDescriptorSetAllocateInfo: return "DescriptorSetAllocateInfo";
-    case StructureType::eWriteDescriptorSet: return "WriteDescriptorSet";
-    case StructureType::eCopyDescriptorSet: return "CopyDescriptorSet";
-    case StructureType::eFramebufferCreateInfo: return "FramebufferCreateInfo";
-    case StructureType::eRenderPassCreateInfo: return "RenderPassCreateInfo";
-    case StructureType::eCommandPoolCreateInfo: return "CommandPoolCreateInfo";
-    case StructureType::eCommandBufferAllocateInfo: return "CommandBufferAllocateInfo";
-    case StructureType::eCommandBufferInheritanceInfo: return "CommandBufferInheritanceInfo";
-    case StructureType::eCommandBufferBeginInfo: return "CommandBufferBeginInfo";
-    case StructureType::eRenderPassBeginInfo: return "RenderPassBeginInfo";
-    case StructureType::eBufferMemoryBarrier: return "BufferMemoryBarrier";
-    case StructureType::eImageMemoryBarrier: return "ImageMemoryBarrier";
-    case StructureType::eMemoryBarrier: return "MemoryBarrier";
-    case StructureType::eLoaderInstanceCreateInfo: return "LoaderInstanceCreateInfo";
-    case StructureType::eLoaderDeviceCreateInfo: return "LoaderDeviceCreateInfo";
-    case StructureType::eSwapchainCreateInfoKHR: return "SwapchainCreateInfoKHR";
-    case StructureType::ePresentInfoKHR: return "PresentInfoKHR";
-    case StructureType::eDisplayModeCreateInfoKHR: return "DisplayModeCreateInfoKHR";
-    case StructureType::eDisplaySurfaceCreateInfoKHR: return "DisplaySurfaceCreateInfoKHR";
-    case StructureType::eDisplayPresentInfoKHR: return "DisplayPresentInfoKHR";
-    case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR";
-    case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR";
-    case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR";
-    case StructureType::eMirSurfaceCreateInfoKHR: return "MirSurfaceCreateInfoKHR";
-    case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR";
-    case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR";
-    case StructureType::eDebugReportCallbackCreateInfoEXT: return "DebugReportCallbackCreateInfoEXT";
-    case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD";
-    case StructureType::eDebugMarkerObjectNameInfoEXT: return "DebugMarkerObjectNameInfoEXT";
-    case StructureType::eDebugMarkerObjectTagInfoEXT: return "DebugMarkerObjectTagInfoEXT";
-    case StructureType::eDebugMarkerMarkerInfoEXT: return "DebugMarkerMarkerInfoEXT";
-    case StructureType::eDedicatedAllocationImageCreateInfoNV: return "DedicatedAllocationImageCreateInfoNV";
-    case StructureType::eDedicatedAllocationBufferCreateInfoNV: return "DedicatedAllocationBufferCreateInfoNV";
-    case StructureType::eDedicatedAllocationMemoryAllocateInfoNV: return "DedicatedAllocationMemoryAllocateInfoNV";
-    case StructureType::eTextureLodGatherFormatPropertiesAMD: return "TextureLodGatherFormatPropertiesAMD";
-    case StructureType::eRenderPassMultiviewCreateInfoKHX: return "RenderPassMultiviewCreateInfoKHX";
-    case StructureType::ePhysicalDeviceMultiviewFeaturesKHX: return "PhysicalDeviceMultiviewFeaturesKHX";
-    case StructureType::ePhysicalDeviceMultiviewPropertiesKHX: return "PhysicalDeviceMultiviewPropertiesKHX";
-    case StructureType::eExternalMemoryImageCreateInfoNV: return "ExternalMemoryImageCreateInfoNV";
-    case StructureType::eExportMemoryAllocateInfoNV: return "ExportMemoryAllocateInfoNV";
-    case StructureType::eImportMemoryWin32HandleInfoNV: return "ImportMemoryWin32HandleInfoNV";
-    case StructureType::eExportMemoryWin32HandleInfoNV: return "ExportMemoryWin32HandleInfoNV";
-    case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV";
-    case StructureType::ePhysicalDeviceFeatures2KHR: return "PhysicalDeviceFeatures2KHR";
-    case StructureType::ePhysicalDeviceProperties2KHR: return "PhysicalDeviceProperties2KHR";
-    case StructureType::eFormatProperties2KHR: return "FormatProperties2KHR";
-    case StructureType::eImageFormatProperties2KHR: return "ImageFormatProperties2KHR";
-    case StructureType::ePhysicalDeviceImageFormatInfo2KHR: return "PhysicalDeviceImageFormatInfo2KHR";
-    case StructureType::eQueueFamilyProperties2KHR: return "QueueFamilyProperties2KHR";
-    case StructureType::ePhysicalDeviceMemoryProperties2KHR: return "PhysicalDeviceMemoryProperties2KHR";
-    case StructureType::eSparseImageFormatProperties2KHR: return "SparseImageFormatProperties2KHR";
-    case StructureType::ePhysicalDeviceSparseImageFormatInfo2KHR: return "PhysicalDeviceSparseImageFormatInfo2KHR";
-    case StructureType::eMemoryAllocateFlagsInfoKHX: return "MemoryAllocateFlagsInfoKHX";
-    case StructureType::eDeviceGroupRenderPassBeginInfoKHX: return "DeviceGroupRenderPassBeginInfoKHX";
-    case StructureType::eDeviceGroupCommandBufferBeginInfoKHX: return "DeviceGroupCommandBufferBeginInfoKHX";
-    case StructureType::eDeviceGroupSubmitInfoKHX: return "DeviceGroupSubmitInfoKHX";
-    case StructureType::eDeviceGroupBindSparseInfoKHX: return "DeviceGroupBindSparseInfoKHX";
-    case StructureType::eAcquireNextImageInfoKHX: return "AcquireNextImageInfoKHX";
-    case StructureType::eBindBufferMemoryDeviceGroupInfoKHX: return "BindBufferMemoryDeviceGroupInfoKHX";
-    case StructureType::eBindImageMemoryDeviceGroupInfoKHX: return "BindImageMemoryDeviceGroupInfoKHX";
-    case StructureType::eDeviceGroupPresentCapabilitiesKHX: return "DeviceGroupPresentCapabilitiesKHX";
-    case StructureType::eImageSwapchainCreateInfoKHX: return "ImageSwapchainCreateInfoKHX";
-    case StructureType::eBindImageMemorySwapchainInfoKHX: return "BindImageMemorySwapchainInfoKHX";
-    case StructureType::eDeviceGroupPresentInfoKHX: return "DeviceGroupPresentInfoKHX";
-    case StructureType::eDeviceGroupSwapchainCreateInfoKHX: return "DeviceGroupSwapchainCreateInfoKHX";
-    case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT";
-    case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN";
-    case StructureType::ePhysicalDeviceGroupPropertiesKHX: return "PhysicalDeviceGroupPropertiesKHX";
-    case StructureType::eDeviceGroupDeviceCreateInfoKHX: return "DeviceGroupDeviceCreateInfoKHX";
-    case StructureType::ePhysicalDeviceExternalImageFormatInfoKHR: return "PhysicalDeviceExternalImageFormatInfoKHR";
-    case StructureType::eExternalImageFormatPropertiesKHR: return "ExternalImageFormatPropertiesKHR";
-    case StructureType::ePhysicalDeviceExternalBufferInfoKHR: return "PhysicalDeviceExternalBufferInfoKHR";
-    case StructureType::eExternalBufferPropertiesKHR: return "ExternalBufferPropertiesKHR";
-    case StructureType::ePhysicalDeviceIdPropertiesKHR: return "PhysicalDeviceIdPropertiesKHR";
-    case StructureType::eExternalMemoryBufferCreateInfoKHR: return "ExternalMemoryBufferCreateInfoKHR";
-    case StructureType::eExternalMemoryImageCreateInfoKHR: return "ExternalMemoryImageCreateInfoKHR";
-    case StructureType::eExportMemoryAllocateInfoKHR: return "ExportMemoryAllocateInfoKHR";
-    case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR";
-    case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR";
-    case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR";
-    case StructureType::eMemoryGetWin32HandleInfoKHR: return "MemoryGetWin32HandleInfoKHR";
-    case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR";
-    case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR";
-    case StructureType::eMemoryGetFdInfoKHR: return "MemoryGetFdInfoKHR";
-    case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR";
-    case StructureType::ePhysicalDeviceExternalSemaphoreInfoKHR: return "PhysicalDeviceExternalSemaphoreInfoKHR";
-    case StructureType::eExternalSemaphorePropertiesKHR: return "ExternalSemaphorePropertiesKHR";
-    case StructureType::eExportSemaphoreCreateInfoKHR: return "ExportSemaphoreCreateInfoKHR";
-    case StructureType::eImportSemaphoreWin32HandleInfoKHR: return "ImportSemaphoreWin32HandleInfoKHR";
-    case StructureType::eExportSemaphoreWin32HandleInfoKHR: return "ExportSemaphoreWin32HandleInfoKHR";
-    case StructureType::eD3D12FenceSubmitInfoKHR: return "D3D12FenceSubmitInfoKHR";
-    case StructureType::eSemaphoreGetWin32HandleInfoKHR: return "SemaphoreGetWin32HandleInfoKHR";
-    case StructureType::eImportSemaphoreFdInfoKHR: return "ImportSemaphoreFdInfoKHR";
-    case StructureType::eSemaphoreGetFdInfoKHR: return "SemaphoreGetFdInfoKHR";
-    case StructureType::ePhysicalDevicePushDescriptorPropertiesKHR: return "PhysicalDevicePushDescriptorPropertiesKHR";
-    case StructureType::ePhysicalDevice16BitStorageFeaturesKHR: return "PhysicalDevice16BitStorageFeaturesKHR";
-    case StructureType::ePresentRegionsKHR: return "PresentRegionsKHR";
-    case StructureType::eDescriptorUpdateTemplateCreateInfoKHR: return "DescriptorUpdateTemplateCreateInfoKHR";
-    case StructureType::eObjectTableCreateInfoNVX: return "ObjectTableCreateInfoNVX";
-    case StructureType::eIndirectCommandsLayoutCreateInfoNVX: return "IndirectCommandsLayoutCreateInfoNVX";
-    case StructureType::eCmdProcessCommandsInfoNVX: return "CmdProcessCommandsInfoNVX";
-    case StructureType::eCmdReserveSpaceForCommandsInfoNVX: return "CmdReserveSpaceForCommandsInfoNVX";
-    case StructureType::eDeviceGeneratedCommandsLimitsNVX: return "DeviceGeneratedCommandsLimitsNVX";
-    case StructureType::eDeviceGeneratedCommandsFeaturesNVX: return "DeviceGeneratedCommandsFeaturesNVX";
-    case StructureType::ePipelineViewportWScalingStateCreateInfoNV: return "PipelineViewportWScalingStateCreateInfoNV";
-    case StructureType::eSurfaceCapabilities2EXT: return "SurfaceCapabilities2EXT";
-    case StructureType::eDisplayPowerInfoEXT: return "DisplayPowerInfoEXT";
-    case StructureType::eDeviceEventInfoEXT: return "DeviceEventInfoEXT";
-    case StructureType::eDisplayEventInfoEXT: return "DisplayEventInfoEXT";
-    case StructureType::eSwapchainCounterCreateInfoEXT: return "SwapchainCounterCreateInfoEXT";
-    case StructureType::ePresentTimesInfoGOOGLE: return "PresentTimesInfoGOOGLE";
-    case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX";
-    case StructureType::ePipelineViewportSwizzleStateCreateInfoNV: return "PipelineViewportSwizzleStateCreateInfoNV";
-    case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT: return "PhysicalDeviceDiscardRectanglePropertiesEXT";
-    case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT: return "PipelineDiscardRectangleStateCreateInfoEXT";
-    case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT: return "PhysicalDeviceConservativeRasterizationPropertiesEXT";
-    case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT: return "PipelineRasterizationConservativeStateCreateInfoEXT";
-    case StructureType::eHdrMetadataEXT: return "HdrMetadataEXT";
-    case StructureType::eSharedPresentSurfaceCapabilitiesKHR: return "SharedPresentSurfaceCapabilitiesKHR";
-    case StructureType::ePhysicalDeviceExternalFenceInfoKHR: return "PhysicalDeviceExternalFenceInfoKHR";
-    case StructureType::eExternalFencePropertiesKHR: return "ExternalFencePropertiesKHR";
-    case StructureType::eExportFenceCreateInfoKHR: return "ExportFenceCreateInfoKHR";
-    case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR";
-    case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR";
-    case StructureType::eFenceGetWin32HandleInfoKHR: return "FenceGetWin32HandleInfoKHR";
-    case StructureType::eImportFenceFdInfoKHR: return "ImportFenceFdInfoKHR";
-    case StructureType::eFenceGetFdInfoKHR: return "FenceGetFdInfoKHR";
-    case StructureType::ePhysicalDevicePointClippingPropertiesKHR: return "PhysicalDevicePointClippingPropertiesKHR";
-    case StructureType::eRenderPassInputAttachmentAspectCreateInfoKHR: return "RenderPassInputAttachmentAspectCreateInfoKHR";
-    case StructureType::eImageViewUsageCreateInfoKHR: return "ImageViewUsageCreateInfoKHR";
-    case StructureType::ePipelineTessellationDomainOriginStateCreateInfoKHR: return "PipelineTessellationDomainOriginStateCreateInfoKHR";
-    case StructureType::ePhysicalDeviceSurfaceInfo2KHR: return "PhysicalDeviceSurfaceInfo2KHR";
-    case StructureType::eSurfaceCapabilities2KHR: return "SurfaceCapabilities2KHR";
-    case StructureType::eSurfaceFormat2KHR: return "SurfaceFormat2KHR";
-    case StructureType::ePhysicalDeviceVariablePointerFeaturesKHR: return "PhysicalDeviceVariablePointerFeaturesKHR";
-    case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK";
-    case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK";
-    case StructureType::eMemoryDedicatedRequirementsKHR: return "MemoryDedicatedRequirementsKHR";
-    case StructureType::eMemoryDedicatedAllocateInfoKHR: return "MemoryDedicatedAllocateInfoKHR";
-    case StructureType::ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT: return "PhysicalDeviceSamplerFilterMinmaxPropertiesEXT";
-    case StructureType::eSamplerReductionModeCreateInfoEXT: return "SamplerReductionModeCreateInfoEXT";
-    case StructureType::eSampleLocationsInfoEXT: return "SampleLocationsInfoEXT";
-    case StructureType::eRenderPassSampleLocationsBeginInfoEXT: return "RenderPassSampleLocationsBeginInfoEXT";
-    case StructureType::ePipelineSampleLocationsStateCreateInfoEXT: return "PipelineSampleLocationsStateCreateInfoEXT";
-    case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT: return "PhysicalDeviceSampleLocationsPropertiesEXT";
-    case StructureType::eMultisamplePropertiesEXT: return "MultisamplePropertiesEXT";
-    case StructureType::eBufferMemoryRequirementsInfo2KHR: return "BufferMemoryRequirementsInfo2KHR";
-    case StructureType::eImageMemoryRequirementsInfo2KHR: return "ImageMemoryRequirementsInfo2KHR";
-    case StructureType::eImageSparseMemoryRequirementsInfo2KHR: return "ImageSparseMemoryRequirementsInfo2KHR";
-    case StructureType::eMemoryRequirements2KHR: return "MemoryRequirements2KHR";
-    case StructureType::eSparseImageMemoryRequirements2KHR: return "SparseImageMemoryRequirements2KHR";
-    case StructureType::eImageFormatListCreateInfoKHR: return "ImageFormatListCreateInfoKHR";
-    case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT: return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT";
-    case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT";
-    case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT: return "PipelineColorBlendAdvancedStateCreateInfoEXT";
-    case StructureType::ePipelineCoverageToColorStateCreateInfoNV: return "PipelineCoverageToColorStateCreateInfoNV";
-    case StructureType::ePipelineCoverageModulationStateCreateInfoNV: return "PipelineCoverageModulationStateCreateInfoNV";
-    case StructureType::eSamplerYcbcrConversionCreateInfoKHR: return "SamplerYcbcrConversionCreateInfoKHR";
-    case StructureType::eSamplerYcbcrConversionInfoKHR: return "SamplerYcbcrConversionInfoKHR";
-    case StructureType::eBindImagePlaneMemoryInfoKHR: return "BindImagePlaneMemoryInfoKHR";
-    case StructureType::eImagePlaneMemoryRequirementsInfoKHR: return "ImagePlaneMemoryRequirementsInfoKHR";
-    case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR: return "PhysicalDeviceSamplerYcbcrConversionFeaturesKHR";
-    case StructureType::eSamplerYcbcrConversionImageFormatPropertiesKHR: return "SamplerYcbcrConversionImageFormatPropertiesKHR";
-    case StructureType::eBindBufferMemoryInfoKHR: return "BindBufferMemoryInfoKHR";
-    case StructureType::eBindImageMemoryInfoKHR: return "BindImageMemoryInfoKHR";
-    case StructureType::eValidationCacheCreateInfoEXT: return "ValidationCacheCreateInfoEXT";
-    case StructureType::eShaderModuleValidationCacheCreateInfoEXT: return "ShaderModuleValidationCacheCreateInfoEXT";
-    case StructureType::eDeviceQueueGlobalPriorityCreateInfoEXT: return "DeviceQueueGlobalPriorityCreateInfoEXT";
-    case StructureType::eImportMemoryHostPointerInfoEXT: return "ImportMemoryHostPointerInfoEXT";
-    case StructureType::eMemoryHostPointerPropertiesEXT: return "MemoryHostPointerPropertiesEXT";
-    case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT: return "PhysicalDeviceExternalMemoryHostPropertiesEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassContents value)
-  {
-    switch (value)
-    {
-    case SubpassContents::eInline: return "Inline";
-    case SubpassContents::eSecondaryCommandBuffers: return "SecondaryCommandBuffers";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DynamicState value)
-  {
-    switch (value)
-    {
-    case DynamicState::eViewport: return "Viewport";
-    case DynamicState::eScissor: return "Scissor";
-    case DynamicState::eLineWidth: return "LineWidth";
-    case DynamicState::eDepthBias: return "DepthBias";
-    case DynamicState::eBlendConstants: return "BlendConstants";
-    case DynamicState::eDepthBounds: return "DepthBounds";
-    case DynamicState::eStencilCompareMask: return "StencilCompareMask";
-    case DynamicState::eStencilWriteMask: return "StencilWriteMask";
-    case DynamicState::eStencilReference: return "StencilReference";
-    case DynamicState::eViewportWScalingNV: return "ViewportWScalingNV";
-    case DynamicState::eDiscardRectangleEXT: return "DiscardRectangleEXT";
-    case DynamicState::eSampleLocationsEXT: return "SampleLocationsEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorUpdateTemplateTypeKHR value)
-  {
-    switch (value)
-    {
-    case DescriptorUpdateTemplateTypeKHR::eDescriptorSet: return "DescriptorSet";
-    case DescriptorUpdateTemplateTypeKHR::ePushDescriptors: return "PushDescriptors";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectType value)
-  {
-    switch (value)
-    {
-    case ObjectType::eUnknown: return "Unknown";
-    case ObjectType::eInstance: return "Instance";
-    case ObjectType::ePhysicalDevice: return "PhysicalDevice";
-    case ObjectType::eDevice: return "Device";
-    case ObjectType::eQueue: return "Queue";
-    case ObjectType::eSemaphore: return "Semaphore";
-    case ObjectType::eCommandBuffer: return "CommandBuffer";
-    case ObjectType::eFence: return "Fence";
-    case ObjectType::eDeviceMemory: return "DeviceMemory";
-    case ObjectType::eBuffer: return "Buffer";
-    case ObjectType::eImage: return "Image";
-    case ObjectType::eEvent: return "Event";
-    case ObjectType::eQueryPool: return "QueryPool";
-    case ObjectType::eBufferView: return "BufferView";
-    case ObjectType::eImageView: return "ImageView";
-    case ObjectType::eShaderModule: return "ShaderModule";
-    case ObjectType::ePipelineCache: return "PipelineCache";
-    case ObjectType::ePipelineLayout: return "PipelineLayout";
-    case ObjectType::eRenderPass: return "RenderPass";
-    case ObjectType::ePipeline: return "Pipeline";
-    case ObjectType::eDescriptorSetLayout: return "DescriptorSetLayout";
-    case ObjectType::eSampler: return "Sampler";
-    case ObjectType::eDescriptorPool: return "DescriptorPool";
-    case ObjectType::eDescriptorSet: return "DescriptorSet";
-    case ObjectType::eFramebuffer: return "Framebuffer";
-    case ObjectType::eCommandPool: return "CommandPool";
-    case ObjectType::eSurfaceKHR: return "SurfaceKHR";
-    case ObjectType::eSwapchainKHR: return "SwapchainKHR";
-    case ObjectType::eDisplayKHR: return "DisplayKHR";
-    case ObjectType::eDisplayModeKHR: return "DisplayModeKHR";
-    case ObjectType::eDebugReportCallbackEXT: return "DebugReportCallbackEXT";
-    case ObjectType::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR";
-    case ObjectType::eObjectTableNVX: return "ObjectTableNVX";
-    case ObjectType::eIndirectCommandsLayoutNVX: return "IndirectCommandsLayoutNVX";
-    case ObjectType::eSamplerYcbcrConversionKHR: return "SamplerYcbcrConversionKHR";
-    case ObjectType::eValidationCacheEXT: return "ValidationCacheEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueFlagBits value)
-  {
-    switch (value)
-    {
-    case QueueFlagBits::eGraphics: return "Graphics";
-    case QueueFlagBits::eCompute: return "Compute";
-    case QueueFlagBits::eTransfer: return "Transfer";
-    case QueueFlagBits::eSparseBinding: return "SparseBinding";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueueFlagBits::eGraphics) result += "Graphics | ";
-    if (value & QueueFlagBits::eCompute) result += "Compute | ";
-    if (value & QueueFlagBits::eTransfer) result += "Transfer | ";
-    if (value & QueueFlagBits::eSparseBinding) result += "SparseBinding | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlagBits value)
-  {
-    switch (value)
-    {
-    case MemoryPropertyFlagBits::eDeviceLocal: return "DeviceLocal";
-    case MemoryPropertyFlagBits::eHostVisible: return "HostVisible";
-    case MemoryPropertyFlagBits::eHostCoherent: return "HostCoherent";
-    case MemoryPropertyFlagBits::eHostCached: return "HostCached";
-    case MemoryPropertyFlagBits::eLazilyAllocated: return "LazilyAllocated";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryPropertyFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryPropertyFlagBits::eDeviceLocal) result += "DeviceLocal | ";
-    if (value & MemoryPropertyFlagBits::eHostVisible) result += "HostVisible | ";
-    if (value & MemoryPropertyFlagBits::eHostCoherent) result += "HostCoherent | ";
-    if (value & MemoryPropertyFlagBits::eHostCached) result += "HostCached | ";
-    if (value & MemoryPropertyFlagBits::eLazilyAllocated) result += "LazilyAllocated | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlagBits value)
-  {
-    switch (value)
-    {
-    case MemoryHeapFlagBits::eDeviceLocal: return "DeviceLocal";
-    case MemoryHeapFlagBits::eMultiInstanceKHX: return "MultiInstanceKHX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryHeapFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryHeapFlagBits::eDeviceLocal) result += "DeviceLocal | ";
-    if (value & MemoryHeapFlagBits::eMultiInstanceKHX) result += "MultiInstanceKHX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccessFlagBits value)
-  {
-    switch (value)
-    {
-    case AccessFlagBits::eIndirectCommandRead: return "IndirectCommandRead";
-    case AccessFlagBits::eIndexRead: return "IndexRead";
-    case AccessFlagBits::eVertexAttributeRead: return "VertexAttributeRead";
-    case AccessFlagBits::eUniformRead: return "UniformRead";
-    case AccessFlagBits::eInputAttachmentRead: return "InputAttachmentRead";
-    case AccessFlagBits::eShaderRead: return "ShaderRead";
-    case AccessFlagBits::eShaderWrite: return "ShaderWrite";
-    case AccessFlagBits::eColorAttachmentRead: return "ColorAttachmentRead";
-    case AccessFlagBits::eColorAttachmentWrite: return "ColorAttachmentWrite";
-    case AccessFlagBits::eDepthStencilAttachmentRead: return "DepthStencilAttachmentRead";
-    case AccessFlagBits::eDepthStencilAttachmentWrite: return "DepthStencilAttachmentWrite";
-    case AccessFlagBits::eTransferRead: return "TransferRead";
-    case AccessFlagBits::eTransferWrite: return "TransferWrite";
-    case AccessFlagBits::eHostRead: return "HostRead";
-    case AccessFlagBits::eHostWrite: return "HostWrite";
-    case AccessFlagBits::eMemoryRead: return "MemoryRead";
-    case AccessFlagBits::eMemoryWrite: return "MemoryWrite";
-    case AccessFlagBits::eCommandProcessReadNVX: return "CommandProcessReadNVX";
-    case AccessFlagBits::eCommandProcessWriteNVX: return "CommandProcessWriteNVX";
-    case AccessFlagBits::eColorAttachmentReadNoncoherentEXT: return "ColorAttachmentReadNoncoherentEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AccessFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & AccessFlagBits::eIndirectCommandRead) result += "IndirectCommandRead | ";
-    if (value & AccessFlagBits::eIndexRead) result += "IndexRead | ";
-    if (value & AccessFlagBits::eVertexAttributeRead) result += "VertexAttributeRead | ";
-    if (value & AccessFlagBits::eUniformRead) result += "UniformRead | ";
-    if (value & AccessFlagBits::eInputAttachmentRead) result += "InputAttachmentRead | ";
-    if (value & AccessFlagBits::eShaderRead) result += "ShaderRead | ";
-    if (value & AccessFlagBits::eShaderWrite) result += "ShaderWrite | ";
-    if (value & AccessFlagBits::eColorAttachmentRead) result += "ColorAttachmentRead | ";
-    if (value & AccessFlagBits::eColorAttachmentWrite) result += "ColorAttachmentWrite | ";
-    if (value & AccessFlagBits::eDepthStencilAttachmentRead) result += "DepthStencilAttachmentRead | ";
-    if (value & AccessFlagBits::eDepthStencilAttachmentWrite) result += "DepthStencilAttachmentWrite | ";
-    if (value & AccessFlagBits::eTransferRead) result += "TransferRead | ";
-    if (value & AccessFlagBits::eTransferWrite) result += "TransferWrite | ";
-    if (value & AccessFlagBits::eHostRead) result += "HostRead | ";
-    if (value & AccessFlagBits::eHostWrite) result += "HostWrite | ";
-    if (value & AccessFlagBits::eMemoryRead) result += "MemoryRead | ";
-    if (value & AccessFlagBits::eMemoryWrite) result += "MemoryWrite | ";
-    if (value & AccessFlagBits::eCommandProcessReadNVX) result += "CommandProcessReadNVX | ";
-    if (value & AccessFlagBits::eCommandProcessWriteNVX) result += "CommandProcessWriteNVX | ";
-    if (value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT) result += "ColorAttachmentReadNoncoherentEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case BufferUsageFlagBits::eTransferSrc: return "TransferSrc";
-    case BufferUsageFlagBits::eTransferDst: return "TransferDst";
-    case BufferUsageFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case BufferUsageFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case BufferUsageFlagBits::eUniformBuffer: return "UniformBuffer";
-    case BufferUsageFlagBits::eStorageBuffer: return "StorageBuffer";
-    case BufferUsageFlagBits::eIndexBuffer: return "IndexBuffer";
-    case BufferUsageFlagBits::eVertexBuffer: return "VertexBuffer";
-    case BufferUsageFlagBits::eIndirectBuffer: return "IndirectBuffer";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & BufferUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
-    if (value & BufferUsageFlagBits::eTransferDst) result += "TransferDst | ";
-    if (value & BufferUsageFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
-    if (value & BufferUsageFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
-    if (value & BufferUsageFlagBits::eUniformBuffer) result += "UniformBuffer | ";
-    if (value & BufferUsageFlagBits::eStorageBuffer) result += "StorageBuffer | ";
-    if (value & BufferUsageFlagBits::eIndexBuffer) result += "IndexBuffer | ";
-    if (value & BufferUsageFlagBits::eVertexBuffer) result += "VertexBuffer | ";
-    if (value & BufferUsageFlagBits::eIndirectBuffer) result += "IndirectBuffer | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case BufferCreateFlagBits::eSparseBinding: return "SparseBinding";
-    case BufferCreateFlagBits::eSparseResidency: return "SparseResidency";
-    case BufferCreateFlagBits::eSparseAliased: return "SparseAliased";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BufferCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & BufferCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
-    if (value & BufferCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
-    if (value & BufferCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderStageFlagBits value)
-  {
-    switch (value)
-    {
-    case ShaderStageFlagBits::eVertex: return "Vertex";
-    case ShaderStageFlagBits::eTessellationControl: return "TessellationControl";
-    case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation";
-    case ShaderStageFlagBits::eGeometry: return "Geometry";
-    case ShaderStageFlagBits::eFragment: return "Fragment";
-    case ShaderStageFlagBits::eCompute: return "Compute";
-    case ShaderStageFlagBits::eAllGraphics: return "AllGraphics";
-    case ShaderStageFlagBits::eAll: return "All";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderStageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ShaderStageFlagBits::eVertex) result += "Vertex | ";
-    if (value & ShaderStageFlagBits::eTessellationControl) result += "TessellationControl | ";
-    if (value & ShaderStageFlagBits::eTessellationEvaluation) result += "TessellationEvaluation | ";
-    if (value & ShaderStageFlagBits::eGeometry) result += "Geometry | ";
-    if (value & ShaderStageFlagBits::eFragment) result += "Fragment | ";
-    if (value & ShaderStageFlagBits::eCompute) result += "Compute | ";
-    if (value & ShaderStageFlagBits::eAllGraphics) result += "AllGraphics | ";
-    if (value & ShaderStageFlagBits::eAll) result += "All | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageUsageFlagBits::eTransferSrc: return "TransferSrc";
-    case ImageUsageFlagBits::eTransferDst: return "TransferDst";
-    case ImageUsageFlagBits::eSampled: return "Sampled";
-    case ImageUsageFlagBits::eStorage: return "Storage";
-    case ImageUsageFlagBits::eColorAttachment: return "ColorAttachment";
-    case ImageUsageFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
-    case ImageUsageFlagBits::eTransientAttachment: return "TransientAttachment";
-    case ImageUsageFlagBits::eInputAttachment: return "InputAttachment";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageUsageFlagBits::eTransferSrc) result += "TransferSrc | ";
-    if (value & ImageUsageFlagBits::eTransferDst) result += "TransferDst | ";
-    if (value & ImageUsageFlagBits::eSampled) result += "Sampled | ";
-    if (value & ImageUsageFlagBits::eStorage) result += "Storage | ";
-    if (value & ImageUsageFlagBits::eColorAttachment) result += "ColorAttachment | ";
-    if (value & ImageUsageFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
-    if (value & ImageUsageFlagBits::eTransientAttachment) result += "TransientAttachment | ";
-    if (value & ImageUsageFlagBits::eInputAttachment) result += "InputAttachment | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageCreateFlagBits::eSparseBinding: return "SparseBinding";
-    case ImageCreateFlagBits::eSparseResidency: return "SparseResidency";
-    case ImageCreateFlagBits::eSparseAliased: return "SparseAliased";
-    case ImageCreateFlagBits::eMutableFormat: return "MutableFormat";
-    case ImageCreateFlagBits::eCubeCompatible: return "CubeCompatible";
-    case ImageCreateFlagBits::eBindSfrKHX: return "BindSfrKHX";
-    case ImageCreateFlagBits::e2DArrayCompatibleKHR: return "2DArrayCompatibleKHR";
-    case ImageCreateFlagBits::eBlockTexelViewCompatibleKHR: return "BlockTexelViewCompatibleKHR";
-    case ImageCreateFlagBits::eExtendedUsageKHR: return "ExtendedUsageKHR";
-    case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT: return "SampleLocationsCompatibleDepthEXT";
-    case ImageCreateFlagBits::eDisjointKHR: return "DisjointKHR";
-    case ImageCreateFlagBits::eAliasKHR: return "AliasKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageCreateFlagBits::eSparseBinding) result += "SparseBinding | ";
-    if (value & ImageCreateFlagBits::eSparseResidency) result += "SparseResidency | ";
-    if (value & ImageCreateFlagBits::eSparseAliased) result += "SparseAliased | ";
-    if (value & ImageCreateFlagBits::eMutableFormat) result += "MutableFormat | ";
-    if (value & ImageCreateFlagBits::eCubeCompatible) result += "CubeCompatible | ";
-    if (value & ImageCreateFlagBits::eBindSfrKHX) result += "BindSfrKHX | ";
-    if (value & ImageCreateFlagBits::e2DArrayCompatibleKHR) result += "2DArrayCompatibleKHR | ";
-    if (value & ImageCreateFlagBits::eBlockTexelViewCompatibleKHR) result += "BlockTexelViewCompatibleKHR | ";
-    if (value & ImageCreateFlagBits::eExtendedUsageKHR) result += "ExtendedUsageKHR | ";
-    if (value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT) result += "SampleLocationsCompatibleDepthEXT | ";
-    if (value & ImageCreateFlagBits::eDisjointKHR) result += "DisjointKHR | ";
-    if (value & ImageCreateFlagBits::eAliasKHR) result += "AliasKHR | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case PipelineCreateFlagBits::eDisableOptimization: return "DisableOptimization";
-    case PipelineCreateFlagBits::eAllowDerivatives: return "AllowDerivatives";
-    case PipelineCreateFlagBits::eDerivative: return "Derivative";
-    case PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX: return "ViewIndexFromDeviceIndexKHX";
-    case PipelineCreateFlagBits::eDispatchBaseKHX: return "DispatchBaseKHX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PipelineCreateFlagBits::eDisableOptimization) result += "DisableOptimization | ";
-    if (value & PipelineCreateFlagBits::eAllowDerivatives) result += "AllowDerivatives | ";
-    if (value & PipelineCreateFlagBits::eDerivative) result += "Derivative | ";
-    if (value & PipelineCreateFlagBits::eViewIndexFromDeviceIndexKHX) result += "ViewIndexFromDeviceIndexKHX | ";
-    if (value & PipelineCreateFlagBits::eDispatchBaseKHX) result += "DispatchBaseKHX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorComponentFlagBits value)
-  {
-    switch (value)
-    {
-    case ColorComponentFlagBits::eR: return "R";
-    case ColorComponentFlagBits::eG: return "G";
-    case ColorComponentFlagBits::eB: return "B";
-    case ColorComponentFlagBits::eA: return "A";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorComponentFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ColorComponentFlagBits::eR) result += "R | ";
-    if (value & ColorComponentFlagBits::eG) result += "G | ";
-    if (value & ColorComponentFlagBits::eB) result += "B | ";
-    if (value & ColorComponentFlagBits::eA) result += "A | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case FenceCreateFlagBits::eSignaled: return "Signaled";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FenceCreateFlagBits::eSignaled) result += "Signaled | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlagBits value)
-  {
-    switch (value)
-    {
-    case FormatFeatureFlagBits::eSampledImage: return "SampledImage";
-    case FormatFeatureFlagBits::eStorageImage: return "StorageImage";
-    case FormatFeatureFlagBits::eStorageImageAtomic: return "StorageImageAtomic";
-    case FormatFeatureFlagBits::eUniformTexelBuffer: return "UniformTexelBuffer";
-    case FormatFeatureFlagBits::eStorageTexelBuffer: return "StorageTexelBuffer";
-    case FormatFeatureFlagBits::eStorageTexelBufferAtomic: return "StorageTexelBufferAtomic";
-    case FormatFeatureFlagBits::eVertexBuffer: return "VertexBuffer";
-    case FormatFeatureFlagBits::eColorAttachment: return "ColorAttachment";
-    case FormatFeatureFlagBits::eColorAttachmentBlend: return "ColorAttachmentBlend";
-    case FormatFeatureFlagBits::eDepthStencilAttachment: return "DepthStencilAttachment";
-    case FormatFeatureFlagBits::eBlitSrc: return "BlitSrc";
-    case FormatFeatureFlagBits::eBlitDst: return "BlitDst";
-    case FormatFeatureFlagBits::eSampledImageFilterLinear: return "SampledImageFilterLinear";
-    case FormatFeatureFlagBits::eSampledImageFilterCubicIMG: return "SampledImageFilterCubicIMG";
-    case FormatFeatureFlagBits::eTransferSrcKHR: return "TransferSrcKHR";
-    case FormatFeatureFlagBits::eTransferDstKHR: return "TransferDstKHR";
-    case FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT: return "SampledImageFilterMinmaxEXT";
-    case FormatFeatureFlagBits::eMidpointChromaSamplesKHR: return "MidpointChromaSamplesKHR";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR: return "SampledImageYcbcrConversionLinearFilterKHR";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR: return "SampledImageYcbcrConversionSeparateReconstructionFilterKHR";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR: return "SampledImageYcbcrConversionChromaReconstructionExplicitKHR";
-    case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR: return "SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR";
-    case FormatFeatureFlagBits::eDisjointKHR: return "DisjointKHR";
-    case FormatFeatureFlagBits::eCositedChromaSamplesKHR: return "CositedChromaSamplesKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FormatFeatureFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FormatFeatureFlagBits::eSampledImage) result += "SampledImage | ";
-    if (value & FormatFeatureFlagBits::eStorageImage) result += "StorageImage | ";
-    if (value & FormatFeatureFlagBits::eStorageImageAtomic) result += "StorageImageAtomic | ";
-    if (value & FormatFeatureFlagBits::eUniformTexelBuffer) result += "UniformTexelBuffer | ";
-    if (value & FormatFeatureFlagBits::eStorageTexelBuffer) result += "StorageTexelBuffer | ";
-    if (value & FormatFeatureFlagBits::eStorageTexelBufferAtomic) result += "StorageTexelBufferAtomic | ";
-    if (value & FormatFeatureFlagBits::eVertexBuffer) result += "VertexBuffer | ";
-    if (value & FormatFeatureFlagBits::eColorAttachment) result += "ColorAttachment | ";
-    if (value & FormatFeatureFlagBits::eColorAttachmentBlend) result += "ColorAttachmentBlend | ";
-    if (value & FormatFeatureFlagBits::eDepthStencilAttachment) result += "DepthStencilAttachment | ";
-    if (value & FormatFeatureFlagBits::eBlitSrc) result += "BlitSrc | ";
-    if (value & FormatFeatureFlagBits::eBlitDst) result += "BlitDst | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterLinear) result += "SampledImageFilterLinear | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterCubicIMG) result += "SampledImageFilterCubicIMG | ";
-    if (value & FormatFeatureFlagBits::eTransferSrcKHR) result += "TransferSrcKHR | ";
-    if (value & FormatFeatureFlagBits::eTransferDstKHR) result += "TransferDstKHR | ";
-    if (value & FormatFeatureFlagBits::eSampledImageFilterMinmaxEXT) result += "SampledImageFilterMinmaxEXT | ";
-    if (value & FormatFeatureFlagBits::eMidpointChromaSamplesKHR) result += "MidpointChromaSamplesKHR | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilterKHR) result += "SampledImageYcbcrConversionLinearFilterKHR | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilterKHR) result += "SampledImageYcbcrConversionSeparateReconstructionFilterKHR | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitKHR) result += "SampledImageYcbcrConversionChromaReconstructionExplicitKHR | ";
-    if (value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR) result += "SampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR | ";
-    if (value & FormatFeatureFlagBits::eDisjointKHR) result += "DisjointKHR | ";
-    if (value & FormatFeatureFlagBits::eCositedChromaSamplesKHR) result += "CositedChromaSamplesKHR | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryControlFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryControlFlagBits::ePrecise: return "Precise";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryControlFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryControlFlagBits::ePrecise) result += "Precise | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryResultFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryResultFlagBits::e64: return "64";
-    case QueryResultFlagBits::eWait: return "Wait";
-    case QueryResultFlagBits::eWithAvailability: return "WithAvailability";
-    case QueryResultFlagBits::ePartial: return "Partial";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryResultFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryResultFlagBits::e64) result += "64 | ";
-    if (value & QueryResultFlagBits::eWait) result += "Wait | ";
-    if (value & QueryResultFlagBits::eWithAvailability) result += "WithAvailability | ";
-    if (value & QueryResultFlagBits::ePartial) result += "Partial | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandBufferUsageFlagBits::eOneTimeSubmit: return "OneTimeSubmit";
-    case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue";
-    case CommandBufferUsageFlagBits::eSimultaneousUse: return "SimultaneousUse";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferUsageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandBufferUsageFlagBits::eOneTimeSubmit) result += "OneTimeSubmit | ";
-    if (value & CommandBufferUsageFlagBits::eRenderPassContinue) result += "RenderPassContinue | ";
-    if (value & CommandBufferUsageFlagBits::eSimultaneousUse) result += "SimultaneousUse | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlagBits value)
-  {
-    switch (value)
-    {
-    case QueryPipelineStatisticFlagBits::eInputAssemblyVertices: return "InputAssemblyVertices";
-    case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives: return "InputAssemblyPrimitives";
-    case QueryPipelineStatisticFlagBits::eVertexShaderInvocations: return "VertexShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations: return "GeometryShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives: return "GeometryShaderPrimitives";
-    case QueryPipelineStatisticFlagBits::eClippingInvocations: return "ClippingInvocations";
-    case QueryPipelineStatisticFlagBits::eClippingPrimitives: return "ClippingPrimitives";
-    case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations: return "FragmentShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches: return "TessellationControlShaderPatches";
-    case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations";
-    case QueryPipelineStatisticFlagBits::eComputeShaderInvocations: return "ComputeShaderInvocations";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueryPipelineStatisticFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices) result += "InputAssemblyVertices | ";
-    if (value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives) result += "InputAssemblyPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations) result += "VertexShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations) result += "GeometryShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives) result += "GeometryShaderPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eClippingInvocations) result += "ClippingInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eClippingPrimitives) result += "ClippingPrimitives | ";
-    if (value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations) result += "FragmentShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches) result += "TessellationControlShaderPatches | ";
-    if (value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations) result += "TessellationEvaluationShaderInvocations | ";
-    if (value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations) result += "ComputeShaderInvocations | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageAspectFlagBits value)
-  {
-    switch (value)
-    {
-    case ImageAspectFlagBits::eColor: return "Color";
-    case ImageAspectFlagBits::eDepth: return "Depth";
-    case ImageAspectFlagBits::eStencil: return "Stencil";
-    case ImageAspectFlagBits::eMetadata: return "Metadata";
-    case ImageAspectFlagBits::ePlane0KHR: return "Plane0KHR";
-    case ImageAspectFlagBits::ePlane1KHR: return "Plane1KHR";
-    case ImageAspectFlagBits::ePlane2KHR: return "Plane2KHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ImageAspectFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ImageAspectFlagBits::eColor) result += "Color | ";
-    if (value & ImageAspectFlagBits::eDepth) result += "Depth | ";
-    if (value & ImageAspectFlagBits::eStencil) result += "Stencil | ";
-    if (value & ImageAspectFlagBits::eMetadata) result += "Metadata | ";
-    if (value & ImageAspectFlagBits::ePlane0KHR) result += "Plane0KHR | ";
-    if (value & ImageAspectFlagBits::ePlane1KHR) result += "Plane1KHR | ";
-    if (value & ImageAspectFlagBits::ePlane2KHR) result += "Plane2KHR | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlagBits value)
-  {
-    switch (value)
-    {
-    case SparseImageFormatFlagBits::eSingleMiptail: return "SingleMiptail";
-    case SparseImageFormatFlagBits::eAlignedMipSize: return "AlignedMipSize";
-    case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseImageFormatFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SparseImageFormatFlagBits::eSingleMiptail) result += "SingleMiptail | ";
-    if (value & SparseImageFormatFlagBits::eAlignedMipSize) result += "AlignedMipSize | ";
-    if (value & SparseImageFormatFlagBits::eNonstandardBlockSize) result += "NonstandardBlockSize | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlagBits value)
-  {
-    switch (value)
-    {
-    case SparseMemoryBindFlagBits::eMetadata: return "Metadata";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SparseMemoryBindFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SparseMemoryBindFlagBits::eMetadata) result += "Metadata | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineStageFlagBits value)
-  {
-    switch (value)
-    {
-    case PipelineStageFlagBits::eTopOfPipe: return "TopOfPipe";
-    case PipelineStageFlagBits::eDrawIndirect: return "DrawIndirect";
-    case PipelineStageFlagBits::eVertexInput: return "VertexInput";
-    case PipelineStageFlagBits::eVertexShader: return "VertexShader";
-    case PipelineStageFlagBits::eTessellationControlShader: return "TessellationControlShader";
-    case PipelineStageFlagBits::eTessellationEvaluationShader: return "TessellationEvaluationShader";
-    case PipelineStageFlagBits::eGeometryShader: return "GeometryShader";
-    case PipelineStageFlagBits::eFragmentShader: return "FragmentShader";
-    case PipelineStageFlagBits::eEarlyFragmentTests: return "EarlyFragmentTests";
-    case PipelineStageFlagBits::eLateFragmentTests: return "LateFragmentTests";
-    case PipelineStageFlagBits::eColorAttachmentOutput: return "ColorAttachmentOutput";
-    case PipelineStageFlagBits::eComputeShader: return "ComputeShader";
-    case PipelineStageFlagBits::eTransfer: return "Transfer";
-    case PipelineStageFlagBits::eBottomOfPipe: return "BottomOfPipe";
-    case PipelineStageFlagBits::eHost: return "Host";
-    case PipelineStageFlagBits::eAllGraphics: return "AllGraphics";
-    case PipelineStageFlagBits::eAllCommands: return "AllCommands";
-    case PipelineStageFlagBits::eCommandProcessNVX: return "CommandProcessNVX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PipelineStageFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PipelineStageFlagBits::eTopOfPipe) result += "TopOfPipe | ";
-    if (value & PipelineStageFlagBits::eDrawIndirect) result += "DrawIndirect | ";
-    if (value & PipelineStageFlagBits::eVertexInput) result += "VertexInput | ";
-    if (value & PipelineStageFlagBits::eVertexShader) result += "VertexShader | ";
-    if (value & PipelineStageFlagBits::eTessellationControlShader) result += "TessellationControlShader | ";
-    if (value & PipelineStageFlagBits::eTessellationEvaluationShader) result += "TessellationEvaluationShader | ";
-    if (value & PipelineStageFlagBits::eGeometryShader) result += "GeometryShader | ";
-    if (value & PipelineStageFlagBits::eFragmentShader) result += "FragmentShader | ";
-    if (value & PipelineStageFlagBits::eEarlyFragmentTests) result += "EarlyFragmentTests | ";
-    if (value & PipelineStageFlagBits::eLateFragmentTests) result += "LateFragmentTests | ";
-    if (value & PipelineStageFlagBits::eColorAttachmentOutput) result += "ColorAttachmentOutput | ";
-    if (value & PipelineStageFlagBits::eComputeShader) result += "ComputeShader | ";
-    if (value & PipelineStageFlagBits::eTransfer) result += "Transfer | ";
-    if (value & PipelineStageFlagBits::eBottomOfPipe) result += "BottomOfPipe | ";
-    if (value & PipelineStageFlagBits::eHost) result += "Host | ";
-    if (value & PipelineStageFlagBits::eAllGraphics) result += "AllGraphics | ";
-    if (value & PipelineStageFlagBits::eAllCommands) result += "AllCommands | ";
-    if (value & PipelineStageFlagBits::eCommandProcessNVX) result += "CommandProcessNVX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandPoolCreateFlagBits::eTransient: return "Transient";
-    case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandPoolCreateFlagBits::eTransient) result += "Transient | ";
-    if (value & CommandPoolCreateFlagBits::eResetCommandBuffer) result += "ResetCommandBuffer | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandPoolResetFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandPoolResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlagBits value)
-  {
-    switch (value)
-    {
-    case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CommandBufferResetFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CommandBufferResetFlagBits::eReleaseResources) result += "ReleaseResources | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SampleCountFlagBits value)
-  {
-    switch (value)
-    {
-    case SampleCountFlagBits::e1: return "1";
-    case SampleCountFlagBits::e2: return "2";
-    case SampleCountFlagBits::e4: return "4";
-    case SampleCountFlagBits::e8: return "8";
-    case SampleCountFlagBits::e16: return "16";
-    case SampleCountFlagBits::e32: return "32";
-    case SampleCountFlagBits::e64: return "64";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SampleCountFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SampleCountFlagBits::e1) result += "1 | ";
-    if (value & SampleCountFlagBits::e2) result += "2 | ";
-    if (value & SampleCountFlagBits::e4) result += "4 | ";
-    if (value & SampleCountFlagBits::e8) result += "8 | ";
-    if (value & SampleCountFlagBits::e16) result += "16 | ";
-    if (value & SampleCountFlagBits::e32) result += "32 | ";
-    if (value & SampleCountFlagBits::e64) result += "64 | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlagBits value)
-  {
-    switch (value)
-    {
-    case AttachmentDescriptionFlagBits::eMayAlias: return "MayAlias";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(AttachmentDescriptionFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & AttachmentDescriptionFlagBits::eMayAlias) result += "MayAlias | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilFaceFlagBits value)
-  {
-    switch (value)
-    {
-    case StencilFaceFlagBits::eFront: return "Front";
-    case StencilFaceFlagBits::eBack: return "Back";
-    case StencilFaceFlagBits::eVkStencilFrontAndBack: return "VkStencilFrontAndBack";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(StencilFaceFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & StencilFaceFlagBits::eFront) result += "Front | ";
-    if (value & StencilFaceFlagBits::eBack) result += "Back | ";
-    if (value & StencilFaceFlagBits::eVkStencilFrontAndBack) result += "VkStencilFrontAndBack | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case DescriptorPoolCreateFlagBits::eFreeDescriptorSet: return "FreeDescriptorSet";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorPoolCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet) result += "FreeDescriptorSet | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DependencyFlagBits value)
-  {
-    switch (value)
-    {
-    case DependencyFlagBits::eByRegion: return "ByRegion";
-    case DependencyFlagBits::eViewLocalKHX: return "ViewLocalKHX";
-    case DependencyFlagBits::eDeviceGroupKHX: return "DeviceGroupKHX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DependencyFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DependencyFlagBits::eByRegion) result += "ByRegion | ";
-    if (value & DependencyFlagBits::eViewLocalKHX) result += "ViewLocalKHX | ";
-    if (value & DependencyFlagBits::eDeviceGroupKHX) result += "DeviceGroupKHX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PresentModeKHR value)
-  {
-    switch (value)
-    {
-    case PresentModeKHR::eImmediate: return "Immediate";
-    case PresentModeKHR::eMailbox: return "Mailbox";
-    case PresentModeKHR::eFifo: return "Fifo";
-    case PresentModeKHR::eFifoRelaxed: return "FifoRelaxed";
-    case PresentModeKHR::eSharedDemandRefresh: return "SharedDemandRefresh";
-    case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ColorSpaceKHR value)
-  {
-    switch (value)
-    {
-    case ColorSpaceKHR::eSrgbNonlinear: return "SrgbNonlinear";
-    case ColorSpaceKHR::eDisplayP3NonlinearEXT: return "DisplayP3NonlinearEXT";
-    case ColorSpaceKHR::eExtendedSrgbLinearEXT: return "ExtendedSrgbLinearEXT";
-    case ColorSpaceKHR::eDciP3LinearEXT: return "DciP3LinearEXT";
-    case ColorSpaceKHR::eDciP3NonlinearEXT: return "DciP3NonlinearEXT";
-    case ColorSpaceKHR::eBt709LinearEXT: return "Bt709LinearEXT";
-    case ColorSpaceKHR::eBt709NonlinearEXT: return "Bt709NonlinearEXT";
-    case ColorSpaceKHR::eBt2020LinearEXT: return "Bt2020LinearEXT";
-    case ColorSpaceKHR::eHdr10St2084EXT: return "Hdr10St2084EXT";
-    case ColorSpaceKHR::eDolbyvisionEXT: return "DolbyvisionEXT";
-    case ColorSpaceKHR::eHdr10HlgEXT: return "Hdr10HlgEXT";
-    case ColorSpaceKHR::eAdobergbLinearEXT: return "AdobergbLinearEXT";
-    case ColorSpaceKHR::eAdobergbNonlinearEXT: return "AdobergbNonlinearEXT";
-    case ColorSpaceKHR::ePassThroughEXT: return "PassThroughEXT";
-    case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case DisplayPlaneAlphaFlagBitsKHR::eOpaque: return "Opaque";
-    case DisplayPlaneAlphaFlagBitsKHR::eGlobal: return "Global";
-    case DisplayPlaneAlphaFlagBitsKHR::ePerPixel: return "PerPixel";
-    case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPlaneAlphaFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DisplayPlaneAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::eGlobal) result += "Global | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel) result += "PerPixel | ";
-    if (value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied) result += "PerPixelPremultiplied | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case CompositeAlphaFlagBitsKHR::eOpaque: return "Opaque";
-    case CompositeAlphaFlagBitsKHR::ePreMultiplied: return "PreMultiplied";
-    case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied";
-    case CompositeAlphaFlagBitsKHR::eInherit: return "Inherit";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CompositeAlphaFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & CompositeAlphaFlagBitsKHR::eOpaque) result += "Opaque | ";
-    if (value & CompositeAlphaFlagBitsKHR::ePreMultiplied) result += "PreMultiplied | ";
-    if (value & CompositeAlphaFlagBitsKHR::ePostMultiplied) result += "PostMultiplied | ";
-    if (value & CompositeAlphaFlagBitsKHR::eInherit) result += "Inherit | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case SurfaceTransformFlagBitsKHR::eIdentity: return "Identity";
-    case SurfaceTransformFlagBitsKHR::eRotate90: return "Rotate90";
-    case SurfaceTransformFlagBitsKHR::eRotate180: return "Rotate180";
-    case SurfaceTransformFlagBitsKHR::eRotate270: return "Rotate270";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirror: return "HorizontalMirror";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90: return "HorizontalMirrorRotate90";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180";
-    case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270";
-    case SurfaceTransformFlagBitsKHR::eInherit: return "Inherit";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceTransformFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SurfaceTransformFlagBitsKHR::eIdentity) result += "Identity | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate90) result += "Rotate90 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate180) result += "Rotate180 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eRotate270) result += "Rotate270 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirror) result += "HorizontalMirror | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90) result += "HorizontalMirrorRotate90 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180) result += "HorizontalMirrorRotate180 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270) result += "HorizontalMirrorRotate270 | ";
-    if (value & SurfaceTransformFlagBitsKHR::eInherit) result += "Inherit | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case DebugReportFlagBitsEXT::eInformation: return "Information";
-    case DebugReportFlagBitsEXT::eWarning: return "Warning";
-    case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning";
-    case DebugReportFlagBitsEXT::eError: return "Error";
-    case DebugReportFlagBitsEXT::eDebug: return "Debug";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DebugReportFlagBitsEXT::eInformation) result += "Information | ";
-    if (value & DebugReportFlagBitsEXT::eWarning) result += "Warning | ";
-    if (value & DebugReportFlagBitsEXT::ePerformanceWarning) result += "PerformanceWarning | ";
-    if (value & DebugReportFlagBitsEXT::eError) result += "Error | ";
-    if (value & DebugReportFlagBitsEXT::eDebug) result += "Debug | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DebugReportObjectTypeEXT value)
-  {
-    switch (value)
-    {
-    case DebugReportObjectTypeEXT::eUnknown: return "Unknown";
-    case DebugReportObjectTypeEXT::eInstance: return "Instance";
-    case DebugReportObjectTypeEXT::ePhysicalDevice: return "PhysicalDevice";
-    case DebugReportObjectTypeEXT::eDevice: return "Device";
-    case DebugReportObjectTypeEXT::eQueue: return "Queue";
-    case DebugReportObjectTypeEXT::eSemaphore: return "Semaphore";
-    case DebugReportObjectTypeEXT::eCommandBuffer: return "CommandBuffer";
-    case DebugReportObjectTypeEXT::eFence: return "Fence";
-    case DebugReportObjectTypeEXT::eDeviceMemory: return "DeviceMemory";
-    case DebugReportObjectTypeEXT::eBuffer: return "Buffer";
-    case DebugReportObjectTypeEXT::eImage: return "Image";
-    case DebugReportObjectTypeEXT::eEvent: return "Event";
-    case DebugReportObjectTypeEXT::eQueryPool: return "QueryPool";
-    case DebugReportObjectTypeEXT::eBufferView: return "BufferView";
-    case DebugReportObjectTypeEXT::eImageView: return "ImageView";
-    case DebugReportObjectTypeEXT::eShaderModule: return "ShaderModule";
-    case DebugReportObjectTypeEXT::ePipelineCache: return "PipelineCache";
-    case DebugReportObjectTypeEXT::ePipelineLayout: return "PipelineLayout";
-    case DebugReportObjectTypeEXT::eRenderPass: return "RenderPass";
-    case DebugReportObjectTypeEXT::ePipeline: return "Pipeline";
-    case DebugReportObjectTypeEXT::eDescriptorSetLayout: return "DescriptorSetLayout";
-    case DebugReportObjectTypeEXT::eSampler: return "Sampler";
-    case DebugReportObjectTypeEXT::eDescriptorPool: return "DescriptorPool";
-    case DebugReportObjectTypeEXT::eDescriptorSet: return "DescriptorSet";
-    case DebugReportObjectTypeEXT::eFramebuffer: return "Framebuffer";
-    case DebugReportObjectTypeEXT::eCommandPool: return "CommandPool";
-    case DebugReportObjectTypeEXT::eSurfaceKhr: return "SurfaceKhr";
-    case DebugReportObjectTypeEXT::eSwapchainKhr: return "SwapchainKhr";
-    case DebugReportObjectTypeEXT::eDebugReportCallbackExt: return "DebugReportCallbackExt";
-    case DebugReportObjectTypeEXT::eDisplayKhr: return "DisplayKhr";
-    case DebugReportObjectTypeEXT::eDisplayModeKhr: return "DisplayModeKhr";
-    case DebugReportObjectTypeEXT::eObjectTableNvx: return "ObjectTableNvx";
-    case DebugReportObjectTypeEXT::eIndirectCommandsLayoutNvx: return "IndirectCommandsLayoutNvx";
-    case DebugReportObjectTypeEXT::eValidationCacheExt: return "ValidationCacheExt";
-    case DebugReportObjectTypeEXT::eDescriptorUpdateTemplateKHR: return "DescriptorUpdateTemplateKHR";
-    case DebugReportObjectTypeEXT::eSamplerYcbcrConversionKHR: return "SamplerYcbcrConversionKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(RasterizationOrderAMD value)
-  {
-    switch (value)
-    {
-    case RasterizationOrderAMD::eStrict: return "Strict";
-    case RasterizationOrderAMD::eRelaxed: return "Relaxed";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image: return "D3D11Image";
-    case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt: return "D3D11ImageKmt";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image) result += "D3D11Image | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt) result += "D3D11ImageKmt | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsNV value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly";
-    case ExternalMemoryFeatureFlagBitsNV::eExportable: return "Exportable";
-    case ExternalMemoryFeatureFlagBitsNV::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsNV value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly) result += "DedicatedOnly | ";
-    if (value & ExternalMemoryFeatureFlagBitsNV::eExportable) result += "Exportable | ";
-    if (value & ExternalMemoryFeatureFlagBitsNV::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCheckEXT value)
-  {
-    switch (value)
-    {
-    case ValidationCheckEXT::eAll: return "All";
-    case ValidationCheckEXT::eShaders: return "Shaders";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagBitsNVX value)
-  {
-    switch (value)
-    {
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences: return "UnorderedSequences";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences: return "SparseSequences";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions: return "EmptyExecutions";
-    case IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences: return "IndexedSequences";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsLayoutUsageFlagsNVX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eUnorderedSequences) result += "UnorderedSequences | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eSparseSequences) result += "SparseSequences | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eEmptyExecutions) result += "EmptyExecutions | ";
-    if (value & IndirectCommandsLayoutUsageFlagBitsNVX::eIndexedSequences) result += "IndexedSequences | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagBitsNVX value)
-  {
-    switch (value)
-    {
-    case ObjectEntryUsageFlagBitsNVX::eGraphics: return "Graphics";
-    case ObjectEntryUsageFlagBitsNVX::eCompute: return "Compute";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryUsageFlagsNVX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ObjectEntryUsageFlagBitsNVX::eGraphics) result += "Graphics | ";
-    if (value & ObjectEntryUsageFlagBitsNVX::eCompute) result += "Compute | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(IndirectCommandsTokenTypeNVX value)
-  {
-    switch (value)
-    {
-    case IndirectCommandsTokenTypeNVX::ePipeline: return "Pipeline";
-    case IndirectCommandsTokenTypeNVX::eDescriptorSet: return "DescriptorSet";
-    case IndirectCommandsTokenTypeNVX::eIndexBuffer: return "IndexBuffer";
-    case IndirectCommandsTokenTypeNVX::eVertexBuffer: return "VertexBuffer";
-    case IndirectCommandsTokenTypeNVX::ePushConstant: return "PushConstant";
-    case IndirectCommandsTokenTypeNVX::eDrawIndexed: return "DrawIndexed";
-    case IndirectCommandsTokenTypeNVX::eDraw: return "Draw";
-    case IndirectCommandsTokenTypeNVX::eDispatch: return "Dispatch";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ObjectEntryTypeNVX value)
-  {
-    switch (value)
-    {
-    case ObjectEntryTypeNVX::eDescriptorSet: return "DescriptorSet";
-    case ObjectEntryTypeNVX::ePipeline: return "Pipeline";
-    case ObjectEntryTypeNVX::eIndexBuffer: return "IndexBuffer";
-    case ObjectEntryTypeNVX::eVertexBuffer: return "VertexBuffer";
-    case ObjectEntryTypeNVX::ePushConstant: return "PushConstant";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlagBits value)
-  {
-    switch (value)
-    {
-    case DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR: return "PushDescriptorKHR";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DescriptorSetLayoutCreateFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR) result += "PushDescriptorKHR | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture: return "D3D11Texture";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt: return "D3D11TextureKmt";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap: return "D3D12Heap";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource: return "D3D12Resource";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT: return "DmaBufEXT";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT: return "HostAllocationEXT";
-    case ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryHandleTypeFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11Texture) result += "D3D11Texture | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D11TextureKmt) result += "D3D11TextureKmt | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Heap) result += "D3D12Heap | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eD3D12Resource) result += "D3D12Resource | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eDmaBufEXT) result += "DmaBufEXT | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostAllocationEXT) result += "HostAllocationEXT | ";
-    if (value & ExternalMemoryHandleTypeFlagBitsKHR::eHostMappedForeignMemoryEXT) result += "HostMappedForeignMemoryEXT | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly: return "DedicatedOnly";
-    case ExternalMemoryFeatureFlagBitsKHR::eExportable: return "Exportable";
-    case ExternalMemoryFeatureFlagBitsKHR::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalMemoryFeatureFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalMemoryFeatureFlagBitsKHR::eDedicatedOnly) result += "DedicatedOnly | ";
-    if (value & ExternalMemoryFeatureFlagBitsKHR::eExportable) result += "Exportable | ";
-    if (value & ExternalMemoryFeatureFlagBitsKHR::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd";
-    case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence: return "D3D12Fence";
-    case ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreHandleTypeFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eD3D12Fence) result += "D3D12Fence | ";
-    if (value & ExternalSemaphoreHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalSemaphoreFeatureFlagBitsKHR::eExportable: return "Exportable";
-    case ExternalSemaphoreFeatureFlagBitsKHR::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalSemaphoreFeatureFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalSemaphoreFeatureFlagBitsKHR::eExportable) result += "Exportable | ";
-    if (value & ExternalSemaphoreFeatureFlagBitsKHR::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case SemaphoreImportFlagBitsKHR::eTemporary: return "Temporary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SemaphoreImportFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SemaphoreImportFlagBitsKHR::eTemporary) result += "Temporary | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd: return "OpaqueFd";
-    case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32: return "OpaqueWin32";
-    case ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt: return "OpaqueWin32Kmt";
-    case ExternalFenceHandleTypeFlagBitsKHR::eSyncFd: return "SyncFd";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceHandleTypeFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueFd) result += "OpaqueFd | ";
-    if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32) result += "OpaqueWin32 | ";
-    if (value & ExternalFenceHandleTypeFlagBitsKHR::eOpaqueWin32Kmt) result += "OpaqueWin32Kmt | ";
-    if (value & ExternalFenceHandleTypeFlagBitsKHR::eSyncFd) result += "SyncFd | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case ExternalFenceFeatureFlagBitsKHR::eExportable: return "Exportable";
-    case ExternalFenceFeatureFlagBitsKHR::eImportable: return "Importable";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ExternalFenceFeatureFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & ExternalFenceFeatureFlagBitsKHR::eExportable) result += "Exportable | ";
-    if (value & ExternalFenceFeatureFlagBitsKHR::eImportable) result += "Importable | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceImportFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case FenceImportFlagBitsKHR::eTemporary: return "Temporary";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(FenceImportFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & FenceImportFlagBitsKHR::eTemporary) result += "Temporary | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagBitsEXT value)
-  {
-    switch (value)
-    {
-    case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SurfaceCounterFlagsEXT value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SurfaceCounterFlagBitsEXT::eVblank) result += "Vblank | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayPowerStateEXT value)
-  {
-    switch (value)
-    {
-    case DisplayPowerStateEXT::eOff: return "Off";
-    case DisplayPowerStateEXT::eSuspend: return "Suspend";
-    case DisplayPowerStateEXT::eOn: return "On";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceEventTypeEXT value)
-  {
-    switch (value)
-    {
-    case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DisplayEventTypeEXT value)
-  {
-    switch (value)
-    {
-    case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagBitsKHX value)
-  {
-    switch (value)
-    {
-    case PeerMemoryFeatureFlagBitsKHX::eCopySrc: return "CopySrc";
-    case PeerMemoryFeatureFlagBitsKHX::eCopyDst: return "CopyDst";
-    case PeerMemoryFeatureFlagBitsKHX::eGenericSrc: return "GenericSrc";
-    case PeerMemoryFeatureFlagBitsKHX::eGenericDst: return "GenericDst";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PeerMemoryFeatureFlagsKHX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & PeerMemoryFeatureFlagBitsKHX::eCopySrc) result += "CopySrc | ";
-    if (value & PeerMemoryFeatureFlagBitsKHX::eCopyDst) result += "CopyDst | ";
-    if (value & PeerMemoryFeatureFlagBitsKHX::eGenericSrc) result += "GenericSrc | ";
-    if (value & PeerMemoryFeatureFlagBitsKHX::eGenericDst) result += "GenericDst | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagBitsKHX value)
-  {
-    switch (value)
-    {
-    case MemoryAllocateFlagBitsKHX::eDeviceMask: return "DeviceMask";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(MemoryAllocateFlagsKHX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & MemoryAllocateFlagBitsKHX::eDeviceMask) result += "DeviceMask | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagBitsKHX value)
-  {
-    switch (value)
-    {
-    case DeviceGroupPresentModeFlagBitsKHX::eLocal: return "Local";
-    case DeviceGroupPresentModeFlagBitsKHX::eRemote: return "Remote";
-    case DeviceGroupPresentModeFlagBitsKHX::eSum: return "Sum";
-    case DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice: return "LocalMultiDevice";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DeviceGroupPresentModeFlagsKHX value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & DeviceGroupPresentModeFlagBitsKHX::eLocal) result += "Local | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHX::eRemote) result += "Remote | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHX::eSum) result += "Sum | ";
-    if (value & DeviceGroupPresentModeFlagBitsKHX::eLocalMultiDevice) result += "LocalMultiDevice | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagBitsKHR value)
-  {
-    switch (value)
-    {
-    case SwapchainCreateFlagBitsKHR::eBindSfrKHX: return "BindSfrKHX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SwapchainCreateFlagsKHR value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SwapchainCreateFlagBitsKHR::eBindSfrKHX) result += "BindSfrKHX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ViewportCoordinateSwizzleNV value)
-  {
-    switch (value)
-    {
-    case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX";
-    case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX";
-    case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY";
-    case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY";
-    case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ";
-    case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ";
-    case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW";
-    case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(DiscardRectangleModeEXT value)
-  {
-    switch (value)
-    {
-    case DiscardRectangleModeEXT::eInclusive: return "Inclusive";
-    case DiscardRectangleModeEXT::eExclusive: return "Exclusive";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlagBits value)
-  {
-    switch (value)
-    {
-    case SubpassDescriptionFlagBits::ePerViewAttributesNVX: return "PerViewAttributesNVX";
-    case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SubpassDescriptionFlags value)
-  {
-    if (!value) return "{}";
-    std::string result;
-    if (value & SubpassDescriptionFlagBits::ePerViewAttributesNVX) result += "PerViewAttributesNVX | ";
-    if (value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX) result += "PerViewPositionXOnlyNVX | ";
-    return "{" + result.substr(0, result.size() - 3) + "}";
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(PointClippingBehaviorKHR value)
-  {
-    switch (value)
-    {
-    case PointClippingBehaviorKHR::eAllClipPlanes: return "AllClipPlanes";
-    case PointClippingBehaviorKHR::eUserClipPlanesOnly: return "UserClipPlanesOnly";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerReductionModeEXT value)
-  {
-    switch (value)
-    {
-    case SamplerReductionModeEXT::eWeightedAverage: return "WeightedAverage";
-    case SamplerReductionModeEXT::eMin: return "Min";
-    case SamplerReductionModeEXT::eMax: return "Max";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(TessellationDomainOriginKHR value)
-  {
-    switch (value)
-    {
-    case TessellationDomainOriginKHR::eUpperLeft: return "UpperLeft";
-    case TessellationDomainOriginKHR::eLowerLeft: return "LowerLeft";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrModelConversionKHR value)
-  {
-    switch (value)
-    {
-    case SamplerYcbcrModelConversionKHR::eRgbIdentity: return "RgbIdentity";
-    case SamplerYcbcrModelConversionKHR::eYcbcrIdentity: return "YcbcrIdentity";
-    case SamplerYcbcrModelConversionKHR::eYcbcr709: return "Ycbcr709";
-    case SamplerYcbcrModelConversionKHR::eYcbcr601: return "Ycbcr601";
-    case SamplerYcbcrModelConversionKHR::eYcbcr2020: return "Ycbcr2020";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(SamplerYcbcrRangeKHR value)
-  {
-    switch (value)
-    {
-    case SamplerYcbcrRangeKHR::eItuFull: return "ItuFull";
-    case SamplerYcbcrRangeKHR::eItuNarrow: return "ItuNarrow";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ChromaLocationKHR value)
-  {
-    switch (value)
-    {
-    case ChromaLocationKHR::eCositedEven: return "CositedEven";
-    case ChromaLocationKHR::eMidpoint: return "Midpoint";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(BlendOverlapEXT value)
-  {
-    switch (value)
-    {
-    case BlendOverlapEXT::eUncorrelated: return "Uncorrelated";
-    case BlendOverlapEXT::eDisjoint: return "Disjoint";
-    case BlendOverlapEXT::eConjoint: return "Conjoint";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(CoverageModulationModeNV value)
-  {
-    switch (value)
-    {
-    case CoverageModulationModeNV::eNone: return "None";
-    case CoverageModulationModeNV::eRgb: return "Rgb";
-    case CoverageModulationModeNV::eAlpha: return "Alpha";
-    case CoverageModulationModeNV::eRgba: return "Rgba";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ValidationCacheHeaderVersionEXT value)
-  {
-    switch (value)
-    {
-    case ValidationCacheHeaderVersionEXT::eOne: return "One";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ShaderInfoTypeAMD value)
-  {
-    switch (value)
-    {
-    case ShaderInfoTypeAMD::eStatistics: return "Statistics";
-    case ShaderInfoTypeAMD::eBinary: return "Binary";
-    case ShaderInfoTypeAMD::eDisassembly: return "Disassembly";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(QueueGlobalPriorityEXT value)
-  {
-    switch (value)
-    {
-    case QueueGlobalPriorityEXT::eLow: return "Low";
-    case QueueGlobalPriorityEXT::eMedium: return "Medium";
-    case QueueGlobalPriorityEXT::eHigh: return "High";
-    case QueueGlobalPriorityEXT::eRealtime: return "Realtime";
-    default: return "invalid";
-    }
-  }
-
-  VULKAN_HPP_INLINE std::string to_string(ConservativeRasterizationModeEXT value)
-  {
-    switch (value)
-    {
-    case ConservativeRasterizationModeEXT::eDisabled: return "Disabled";
-    case ConservativeRasterizationModeEXT::eOverestimate: return "Overestimate";
-    case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate";
-    default: return "invalid";
-    }
-  }
-
-} // namespace VULKAN_HPP_NAMESPACE
-
-#endif
diff --git a/third_party/vulkan/vulkan_android.h b/third_party/vulkan/vulkan_android.h
new file mode 100644
index 000000000..07aaeda28
--- /dev/null
+++ b/third_party/vulkan/vulkan_android.h
@@ -0,0 +1,126 @@
+#ifndef VULKAN_ANDROID_H_
+#define VULKAN_ANDROID_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_android_surface 1
+struct ANativeWindow;
+
+#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
+#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"
+
+typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
+
+typedef struct VkAndroidSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkAndroidSurfaceCreateFlagsKHR    flags;
+    struct ANativeWindow*             window;
+} VkAndroidSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
+    VkInstance                                  instance,
+    const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#define VK_ANDROID_external_memory_android_hardware_buffer 1
+struct AHardwareBuffer;
+
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 3
+#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer"
+
+typedef struct VkAndroidHardwareBufferUsageANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           androidHardwareBufferUsage;
+} VkAndroidHardwareBufferUsageANDROID;
+
+typedef struct VkAndroidHardwareBufferPropertiesANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeBits;
+} VkAndroidHardwareBufferPropertiesANDROID;
+
+typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkFormat                         format;
+    uint64_t                         externalFormat;
+    VkFormatFeatureFlags             formatFeatures;
+    VkComponentMapping               samplerYcbcrConversionComponents;
+    VkSamplerYcbcrModelConversion    suggestedYcbcrModel;
+    VkSamplerYcbcrRange              suggestedYcbcrRange;
+    VkChromaLocation                 suggestedXChromaOffset;
+    VkChromaLocation                 suggestedYChromaOffset;
+} VkAndroidHardwareBufferFormatPropertiesANDROID;
+
+typedef struct VkImportAndroidHardwareBufferInfoANDROID {
+    VkStructureType            sType;
+    const void*                pNext;
+    struct AHardwareBuffer*    buffer;
+} VkImportAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+} VkMemoryGetAndroidHardwareBufferInfoANDROID;
+
+typedef struct VkExternalFormatANDROID {
+    VkStructureType    sType;
+    void*              pNext;
+    uint64_t           externalFormat;
+} VkExternalFormatANDROID;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID(
+    VkDevice                                    device,
+    const struct AHardwareBuffer*               buffer,
+    VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID(
+    VkDevice                                    device,
+    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
+    struct AHardwareBuffer**                    pBuffer);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_core.h b/third_party/vulkan/vulkan_core.h
new file mode 100644
index 000000000..9fefb4382
--- /dev/null
+++ b/third_party/vulkan/vulkan_core.h
@@ -0,0 +1,7470 @@
+#ifndef VULKAN_CORE_H_
+#define VULKAN_CORE_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_VERSION_1_0 1
+#include "vk_platform.h"
+
+#define VK_MAKE_VERSION(major, minor, patch) \
+    (((major) << 22) | ((minor) << 12) | (patch))
+
+// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.
+//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0
+
+// Vulkan 1.0 version number
+#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0)// Patch version should always be set to 0
+
+#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
+#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
+#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)
+// Version of this file
+#define VK_HEADER_VERSION 74
+
+
+#define VK_NULL_HANDLE 0
+        
+
+
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
+
+
+#if !defined(VK_DEFINE_NON_DISPATCHABLE_HANDLE)
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
+#else
+        #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
+#endif
+#endif
+        
+
+
+typedef uint32_t VkFlags;
+typedef uint32_t VkBool32;
+typedef uint64_t VkDeviceSize;
+typedef uint32_t VkSampleMask;
+
+VK_DEFINE_HANDLE(VkInstance)
+VK_DEFINE_HANDLE(VkPhysicalDevice)
+VK_DEFINE_HANDLE(VkDevice)
+VK_DEFINE_HANDLE(VkQueue)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+VK_DEFINE_HANDLE(VkCommandBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
+
+#define VK_LOD_CLAMP_NONE                 1000.0f
+#define VK_REMAINING_MIP_LEVELS           (~0U)
+#define VK_REMAINING_ARRAY_LAYERS         (~0U)
+#define VK_WHOLE_SIZE                     (~0ULL)
+#define VK_ATTACHMENT_UNUSED              (~0U)
+#define VK_TRUE                           1
+#define VK_FALSE                          0
+#define VK_QUEUE_FAMILY_IGNORED           (~0U)
+#define VK_SUBPASS_EXTERNAL               (~0U)
+#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
+#define VK_UUID_SIZE                      16
+#define VK_MAX_MEMORY_TYPES               32
+#define VK_MAX_MEMORY_HEAPS               16
+#define VK_MAX_EXTENSION_NAME_SIZE        256
+#define VK_MAX_DESCRIPTION_SIZE           256
+
+
+typedef enum VkPipelineCacheHeaderVersion {
+    VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
+    VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
+    VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
+    VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCacheHeaderVersion;
+
+typedef enum VkResult {
+    VK_SUCCESS = 0,
+    VK_NOT_READY = 1,
+    VK_TIMEOUT = 2,
+    VK_EVENT_SET = 3,
+    VK_EVENT_RESET = 4,
+    VK_INCOMPLETE = 5,
+    VK_ERROR_OUT_OF_HOST_MEMORY = -1,
+    VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
+    VK_ERROR_INITIALIZATION_FAILED = -3,
+    VK_ERROR_DEVICE_LOST = -4,
+    VK_ERROR_MEMORY_MAP_FAILED = -5,
+    VK_ERROR_LAYER_NOT_PRESENT = -6,
+    VK_ERROR_EXTENSION_NOT_PRESENT = -7,
+    VK_ERROR_FEATURE_NOT_PRESENT = -8,
+    VK_ERROR_INCOMPATIBLE_DRIVER = -9,
+    VK_ERROR_TOO_MANY_OBJECTS = -10,
+    VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
+    VK_ERROR_FRAGMENTED_POOL = -12,
+    VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
+    VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
+    VK_ERROR_SURFACE_LOST_KHR = -1000000000,
+    VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
+    VK_SUBOPTIMAL_KHR = 1000001003,
+    VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
+    VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
+    VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
+    VK_ERROR_INVALID_SHADER_NV = -1000012000,
+    VK_ERROR_FRAGMENTATION_EXT = -1000161000,
+    VK_ERROR_NOT_PERMITTED_EXT = -1000174001,
+    VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
+    VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
+    VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL,
+    VK_RESULT_END_RANGE = VK_INCOMPLETE,
+    VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1),
+    VK_RESULT_MAX_ENUM = 0x7FFFFFFF
+} VkResult;
+
+typedef enum VkStructureType {
+    VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
+    VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
+    VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
+    VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
+    VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
+    VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
+    VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
+    VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
+    VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
+    VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
+    VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
+    VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
+    VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
+    VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
+    VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
+    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
+    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
+    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
+    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
+    VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
+    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
+    VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
+    VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
+    VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
+    VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
+    VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
+    VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
+    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
+    VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
+    VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+    VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+    VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,
+    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,
+    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,
+    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,
+    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,
+    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = 1000120000,
+    VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,
+    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,
+    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,
+    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,
+    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,
+    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = 1000063000,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
+    VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,
+    VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,
+    VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,
+    VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
+    VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
+    VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
+    VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
+    VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
+    VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
+    VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
+    VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
+    VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
+    VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
+    VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
+    VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
+    VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
+    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
+    VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,
+    VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,
+    VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,
+    VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,
+    VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,
+    VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,
+    VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,
+    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,
+    VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,
+    VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,
+    VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,
+    VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,
+    VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,
+    VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX = 1000086000,
+    VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX = 1000086001,
+    VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX = 1000086002,
+    VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX = 1000086003,
+    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX = 1000086004,
+    VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX = 1000086005,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,
+    VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,
+    VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,
+    VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,
+    VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,
+    VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,
+    VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,
+    VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,
+    VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,
+    VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,
+    VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,
+    VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,
+    VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,
+    VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,
+    VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,
+    VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,
+    VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,
+    VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,
+    VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,
+    VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,
+    VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,
+    VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = 1000130000,
+    VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = 1000130001,
+    VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,
+    VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,
+    VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,
+    VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = 1000147000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,
+    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,
+    VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,
+    VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,
+    VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = 1000161000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = 1000161001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = 1000161002,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = 1000161003,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = 1000161004,
+    VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = 1000174000,
+    VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,
+    VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,
+    VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+    VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
+    VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
+    VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
+    VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
+    VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
+    VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
+    VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
+    VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+    VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
+    VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+    VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+    VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
+    VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
+    VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
+    VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
+    VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+    VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkStructureType;
+
+typedef enum VkSystemAllocationScope {
+    VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
+    VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
+    VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
+    VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
+    VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
+    VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
+    VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
+    VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
+    VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocationScope;
+
+typedef enum VkInternalAllocationType {
+    VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
+    VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+    VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+    VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
+    VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkInternalAllocationType;
+
+typedef enum VkFormat {
+    VK_FORMAT_UNDEFINED = 0,
+    VK_FORMAT_R4G4_UNORM_PACK8 = 1,
+    VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
+    VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
+    VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
+    VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
+    VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
+    VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
+    VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
+    VK_FORMAT_R8_UNORM = 9,
+    VK_FORMAT_R8_SNORM = 10,
+    VK_FORMAT_R8_USCALED = 11,
+    VK_FORMAT_R8_SSCALED = 12,
+    VK_FORMAT_R8_UINT = 13,
+    VK_FORMAT_R8_SINT = 14,
+    VK_FORMAT_R8_SRGB = 15,
+    VK_FORMAT_R8G8_UNORM = 16,
+    VK_FORMAT_R8G8_SNORM = 17,
+    VK_FORMAT_R8G8_USCALED = 18,
+    VK_FORMAT_R8G8_SSCALED = 19,
+    VK_FORMAT_R8G8_UINT = 20,
+    VK_FORMAT_R8G8_SINT = 21,
+    VK_FORMAT_R8G8_SRGB = 22,
+    VK_FORMAT_R8G8B8_UNORM = 23,
+    VK_FORMAT_R8G8B8_SNORM = 24,
+    VK_FORMAT_R8G8B8_USCALED = 25,
+    VK_FORMAT_R8G8B8_SSCALED = 26,
+    VK_FORMAT_R8G8B8_UINT = 27,
+    VK_FORMAT_R8G8B8_SINT = 28,
+    VK_FORMAT_R8G8B8_SRGB = 29,
+    VK_FORMAT_B8G8R8_UNORM = 30,
+    VK_FORMAT_B8G8R8_SNORM = 31,
+    VK_FORMAT_B8G8R8_USCALED = 32,
+    VK_FORMAT_B8G8R8_SSCALED = 33,
+    VK_FORMAT_B8G8R8_UINT = 34,
+    VK_FORMAT_B8G8R8_SINT = 35,
+    VK_FORMAT_B8G8R8_SRGB = 36,
+    VK_FORMAT_R8G8B8A8_UNORM = 37,
+    VK_FORMAT_R8G8B8A8_SNORM = 38,
+    VK_FORMAT_R8G8B8A8_USCALED = 39,
+    VK_FORMAT_R8G8B8A8_SSCALED = 40,
+    VK_FORMAT_R8G8B8A8_UINT = 41,
+    VK_FORMAT_R8G8B8A8_SINT = 42,
+    VK_FORMAT_R8G8B8A8_SRGB = 43,
+    VK_FORMAT_B8G8R8A8_UNORM = 44,
+    VK_FORMAT_B8G8R8A8_SNORM = 45,
+    VK_FORMAT_B8G8R8A8_USCALED = 46,
+    VK_FORMAT_B8G8R8A8_SSCALED = 47,
+    VK_FORMAT_B8G8R8A8_UINT = 48,
+    VK_FORMAT_B8G8R8A8_SINT = 49,
+    VK_FORMAT_B8G8R8A8_SRGB = 50,
+    VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
+    VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
+    VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
+    VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
+    VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
+    VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
+    VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
+    VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
+    VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
+    VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
+    VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
+    VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
+    VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
+    VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
+    VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
+    VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
+    VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
+    VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
+    VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
+    VK_FORMAT_R16_UNORM = 70,
+    VK_FORMAT_R16_SNORM = 71,
+    VK_FORMAT_R16_USCALED = 72,
+    VK_FORMAT_R16_SSCALED = 73,
+    VK_FORMAT_R16_UINT = 74,
+    VK_FORMAT_R16_SINT = 75,
+    VK_FORMAT_R16_SFLOAT = 76,
+    VK_FORMAT_R16G16_UNORM = 77,
+    VK_FORMAT_R16G16_SNORM = 78,
+    VK_FORMAT_R16G16_USCALED = 79,
+    VK_FORMAT_R16G16_SSCALED = 80,
+    VK_FORMAT_R16G16_UINT = 81,
+    VK_FORMAT_R16G16_SINT = 82,
+    VK_FORMAT_R16G16_SFLOAT = 83,
+    VK_FORMAT_R16G16B16_UNORM = 84,
+    VK_FORMAT_R16G16B16_SNORM = 85,
+    VK_FORMAT_R16G16B16_USCALED = 86,
+    VK_FORMAT_R16G16B16_SSCALED = 87,
+    VK_FORMAT_R16G16B16_UINT = 88,
+    VK_FORMAT_R16G16B16_SINT = 89,
+    VK_FORMAT_R16G16B16_SFLOAT = 90,
+    VK_FORMAT_R16G16B16A16_UNORM = 91,
+    VK_FORMAT_R16G16B16A16_SNORM = 92,
+    VK_FORMAT_R16G16B16A16_USCALED = 93,
+    VK_FORMAT_R16G16B16A16_SSCALED = 94,
+    VK_FORMAT_R16G16B16A16_UINT = 95,
+    VK_FORMAT_R16G16B16A16_SINT = 96,
+    VK_FORMAT_R16G16B16A16_SFLOAT = 97,
+    VK_FORMAT_R32_UINT = 98,
+    VK_FORMAT_R32_SINT = 99,
+    VK_FORMAT_R32_SFLOAT = 100,
+    VK_FORMAT_R32G32_UINT = 101,
+    VK_FORMAT_R32G32_SINT = 102,
+    VK_FORMAT_R32G32_SFLOAT = 103,
+    VK_FORMAT_R32G32B32_UINT = 104,
+    VK_FORMAT_R32G32B32_SINT = 105,
+    VK_FORMAT_R32G32B32_SFLOAT = 106,
+    VK_FORMAT_R32G32B32A32_UINT = 107,
+    VK_FORMAT_R32G32B32A32_SINT = 108,
+    VK_FORMAT_R32G32B32A32_SFLOAT = 109,
+    VK_FORMAT_R64_UINT = 110,
+    VK_FORMAT_R64_SINT = 111,
+    VK_FORMAT_R64_SFLOAT = 112,
+    VK_FORMAT_R64G64_UINT = 113,
+    VK_FORMAT_R64G64_SINT = 114,
+    VK_FORMAT_R64G64_SFLOAT = 115,
+    VK_FORMAT_R64G64B64_UINT = 116,
+    VK_FORMAT_R64G64B64_SINT = 117,
+    VK_FORMAT_R64G64B64_SFLOAT = 118,
+    VK_FORMAT_R64G64B64A64_UINT = 119,
+    VK_FORMAT_R64G64B64A64_SINT = 120,
+    VK_FORMAT_R64G64B64A64_SFLOAT = 121,
+    VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
+    VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
+    VK_FORMAT_D16_UNORM = 124,
+    VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
+    VK_FORMAT_D32_SFLOAT = 126,
+    VK_FORMAT_S8_UINT = 127,
+    VK_FORMAT_D16_UNORM_S8_UINT = 128,
+    VK_FORMAT_D24_UNORM_S8_UINT = 129,
+    VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
+    VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
+    VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
+    VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
+    VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
+    VK_FORMAT_BC2_UNORM_BLOCK = 135,
+    VK_FORMAT_BC2_SRGB_BLOCK = 136,
+    VK_FORMAT_BC3_UNORM_BLOCK = 137,
+    VK_FORMAT_BC3_SRGB_BLOCK = 138,
+    VK_FORMAT_BC4_UNORM_BLOCK = 139,
+    VK_FORMAT_BC4_SNORM_BLOCK = 140,
+    VK_FORMAT_BC5_UNORM_BLOCK = 141,
+    VK_FORMAT_BC5_SNORM_BLOCK = 142,
+    VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
+    VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
+    VK_FORMAT_BC7_UNORM_BLOCK = 145,
+    VK_FORMAT_BC7_SRGB_BLOCK = 146,
+    VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
+    VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
+    VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
+    VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
+    VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
+    VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
+    VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
+    VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
+    VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
+    VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
+    VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
+    VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
+    VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
+    VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
+    VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
+    VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
+    VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
+    VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
+    VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
+    VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
+    VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
+    VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
+    VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
+    VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
+    VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
+    VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
+    VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
+    VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
+    VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
+    VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
+    VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
+    VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
+    VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
+    VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
+    VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
+    VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
+    VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
+    VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
+    VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,
+    VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,
+    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,
+    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,
+    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,
+    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,
+    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,
+    VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,
+    VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,
+    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,
+    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,
+    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,
+    VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,
+    VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,
+    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,
+    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,
+    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,
+    VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,
+    VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,
+    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,
+    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,
+    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,
+    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,
+    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
+    VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
+    VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
+    VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
+    VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
+    VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
+    VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
+    VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
+    VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,
+    VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,
+    VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+    VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+    VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+    VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,
+    VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+    VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+    VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+    VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,
+    VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+    VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+    VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+    VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+    VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+    VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,
+    VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+    VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+    VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,
+    VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
+    VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
+    VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
+    VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
+} VkFormat;
+
+typedef enum VkImageType {
+    VK_IMAGE_TYPE_1D = 0,
+    VK_IMAGE_TYPE_2D = 1,
+    VK_IMAGE_TYPE_3D = 2,
+    VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
+    VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
+    VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
+    VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkImageType;
+
+typedef enum VkImageTiling {
+    VK_IMAGE_TILING_OPTIMAL = 0,
+    VK_IMAGE_TILING_LINEAR = 1,
+    VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
+    VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
+    VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
+    VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
+} VkImageTiling;
+
+typedef enum VkPhysicalDeviceType {
+    VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
+    VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
+    VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
+    VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
+    VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
+    VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
+    VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
+    VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
+    VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkPhysicalDeviceType;
+
+typedef enum VkQueryType {
+    VK_QUERY_TYPE_OCCLUSION = 0,
+    VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
+    VK_QUERY_TYPE_TIMESTAMP = 2,
+    VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
+    VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
+    VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
+    VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkQueryType;
+
+typedef enum VkSharingMode {
+    VK_SHARING_MODE_EXCLUSIVE = 0,
+    VK_SHARING_MODE_CONCURRENT = 1,
+    VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
+    VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
+    VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
+    VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSharingMode;
+
+typedef enum VkImageLayout {
+    VK_IMAGE_LAYOUT_UNDEFINED = 0,
+    VK_IMAGE_LAYOUT_GENERAL = 1,
+    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
+    VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
+    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
+    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
+    VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
+    VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
+    VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
+    VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
+    VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
+    VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
+    VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
+} VkImageLayout;
+
+typedef enum VkImageViewType {
+    VK_IMAGE_VIEW_TYPE_1D = 0,
+    VK_IMAGE_VIEW_TYPE_2D = 1,
+    VK_IMAGE_VIEW_TYPE_3D = 2,
+    VK_IMAGE_VIEW_TYPE_CUBE = 3,
+    VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
+    VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
+    VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
+    VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
+    VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
+    VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
+    VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkImageViewType;
+
+typedef enum VkComponentSwizzle {
+    VK_COMPONENT_SWIZZLE_IDENTITY = 0,
+    VK_COMPONENT_SWIZZLE_ZERO = 1,
+    VK_COMPONENT_SWIZZLE_ONE = 2,
+    VK_COMPONENT_SWIZZLE_R = 3,
+    VK_COMPONENT_SWIZZLE_G = 4,
+    VK_COMPONENT_SWIZZLE_B = 5,
+    VK_COMPONENT_SWIZZLE_A = 6,
+    VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
+    VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
+    VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
+    VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+} VkComponentSwizzle;
+
+typedef enum VkVertexInputRate {
+    VK_VERTEX_INPUT_RATE_VERTEX = 0,
+    VK_VERTEX_INPUT_RATE_INSTANCE = 1,
+    VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
+    VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
+    VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
+    VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
+} VkVertexInputRate;
+
+typedef enum VkPrimitiveTopology {
+    VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
+    VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
+    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
+    VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
+    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
+    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
+    VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
+    VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
+    VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
+    VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
+    VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
+} VkPrimitiveTopology;
+
+typedef enum VkPolygonMode {
+    VK_POLYGON_MODE_FILL = 0,
+    VK_POLYGON_MODE_LINE = 1,
+    VK_POLYGON_MODE_POINT = 2,
+    VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,
+    VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
+    VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
+    VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
+    VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkPolygonMode;
+
+typedef enum VkFrontFace {
+    VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+    VK_FRONT_FACE_CLOCKWISE = 1,
+    VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+    VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
+    VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
+    VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
+} VkFrontFace;
+
+typedef enum VkCompareOp {
+    VK_COMPARE_OP_NEVER = 0,
+    VK_COMPARE_OP_LESS = 1,
+    VK_COMPARE_OP_EQUAL = 2,
+    VK_COMPARE_OP_LESS_OR_EQUAL = 3,
+    VK_COMPARE_OP_GREATER = 4,
+    VK_COMPARE_OP_NOT_EQUAL = 5,
+    VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
+    VK_COMPARE_OP_ALWAYS = 7,
+    VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
+    VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
+    VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
+    VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
+} VkCompareOp;
+
+typedef enum VkStencilOp {
+    VK_STENCIL_OP_KEEP = 0,
+    VK_STENCIL_OP_ZERO = 1,
+    VK_STENCIL_OP_REPLACE = 2,
+    VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
+    VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
+    VK_STENCIL_OP_INVERT = 5,
+    VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
+    VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
+    VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
+    VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
+    VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
+    VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
+} VkStencilOp;
+
+typedef enum VkLogicOp {
+    VK_LOGIC_OP_CLEAR = 0,
+    VK_LOGIC_OP_AND = 1,
+    VK_LOGIC_OP_AND_REVERSE = 2,
+    VK_LOGIC_OP_COPY = 3,
+    VK_LOGIC_OP_AND_INVERTED = 4,
+    VK_LOGIC_OP_NO_OP = 5,
+    VK_LOGIC_OP_XOR = 6,
+    VK_LOGIC_OP_OR = 7,
+    VK_LOGIC_OP_NOR = 8,
+    VK_LOGIC_OP_EQUIVALENT = 9,
+    VK_LOGIC_OP_INVERT = 10,
+    VK_LOGIC_OP_OR_REVERSE = 11,
+    VK_LOGIC_OP_COPY_INVERTED = 12,
+    VK_LOGIC_OP_OR_INVERTED = 13,
+    VK_LOGIC_OP_NAND = 14,
+    VK_LOGIC_OP_SET = 15,
+    VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
+    VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
+    VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
+    VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
+} VkLogicOp;
+
+typedef enum VkBlendFactor {
+    VK_BLEND_FACTOR_ZERO = 0,
+    VK_BLEND_FACTOR_ONE = 1,
+    VK_BLEND_FACTOR_SRC_COLOR = 2,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
+    VK_BLEND_FACTOR_DST_COLOR = 4,
+    VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
+    VK_BLEND_FACTOR_SRC_ALPHA = 6,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
+    VK_BLEND_FACTOR_DST_ALPHA = 8,
+    VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
+    VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
+    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
+    VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
+    VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
+    VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
+    VK_BLEND_FACTOR_SRC1_COLOR = 15,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
+    VK_BLEND_FACTOR_SRC1_ALPHA = 17,
+    VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
+    VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
+    VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
+    VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
+    VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
+} VkBlendFactor;
+
+typedef enum VkBlendOp {
+    VK_BLEND_OP_ADD = 0,
+    VK_BLEND_OP_SUBTRACT = 1,
+    VK_BLEND_OP_REVERSE_SUBTRACT = 2,
+    VK_BLEND_OP_MIN = 3,
+    VK_BLEND_OP_MAX = 4,
+    VK_BLEND_OP_ZERO_EXT = 1000148000,
+    VK_BLEND_OP_SRC_EXT = 1000148001,
+    VK_BLEND_OP_DST_EXT = 1000148002,
+    VK_BLEND_OP_SRC_OVER_EXT = 1000148003,
+    VK_BLEND_OP_DST_OVER_EXT = 1000148004,
+    VK_BLEND_OP_SRC_IN_EXT = 1000148005,
+    VK_BLEND_OP_DST_IN_EXT = 1000148006,
+    VK_BLEND_OP_SRC_OUT_EXT = 1000148007,
+    VK_BLEND_OP_DST_OUT_EXT = 1000148008,
+    VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,
+    VK_BLEND_OP_DST_ATOP_EXT = 1000148010,
+    VK_BLEND_OP_XOR_EXT = 1000148011,
+    VK_BLEND_OP_MULTIPLY_EXT = 1000148012,
+    VK_BLEND_OP_SCREEN_EXT = 1000148013,
+    VK_BLEND_OP_OVERLAY_EXT = 1000148014,
+    VK_BLEND_OP_DARKEN_EXT = 1000148015,
+    VK_BLEND_OP_LIGHTEN_EXT = 1000148016,
+    VK_BLEND_OP_COLORDODGE_EXT = 1000148017,
+    VK_BLEND_OP_COLORBURN_EXT = 1000148018,
+    VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,
+    VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,
+    VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,
+    VK_BLEND_OP_EXCLUSION_EXT = 1000148022,
+    VK_BLEND_OP_INVERT_EXT = 1000148023,
+    VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,
+    VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,
+    VK_BLEND_OP_LINEARBURN_EXT = 1000148026,
+    VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,
+    VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,
+    VK_BLEND_OP_PINLIGHT_EXT = 1000148029,
+    VK_BLEND_OP_HARDMIX_EXT = 1000148030,
+    VK_BLEND_OP_HSL_HUE_EXT = 1000148031,
+    VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,
+    VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,
+    VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,
+    VK_BLEND_OP_PLUS_EXT = 1000148035,
+    VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,
+    VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,
+    VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,
+    VK_BLEND_OP_MINUS_EXT = 1000148039,
+    VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,
+    VK_BLEND_OP_CONTRAST_EXT = 1000148041,
+    VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,
+    VK_BLEND_OP_RED_EXT = 1000148043,
+    VK_BLEND_OP_GREEN_EXT = 1000148044,
+    VK_BLEND_OP_BLUE_EXT = 1000148045,
+    VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
+    VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
+    VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
+    VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
+} VkBlendOp;
+
+typedef enum VkDynamicState {
+    VK_DYNAMIC_STATE_VIEWPORT = 0,
+    VK_DYNAMIC_STATE_SCISSOR = 1,
+    VK_DYNAMIC_STATE_LINE_WIDTH = 2,
+    VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
+    VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
+    VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
+    VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
+    VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
+    VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
+    VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,
+    VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,
+    VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,
+    VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
+    VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
+    VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
+    VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
+} VkDynamicState;
+
+typedef enum VkFilter {
+    VK_FILTER_NEAREST = 0,
+    VK_FILTER_LINEAR = 1,
+    VK_FILTER_CUBIC_IMG = 1000015000,
+    VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
+    VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
+    VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
+    VK_FILTER_MAX_ENUM = 0x7FFFFFFF
+} VkFilter;
+
+typedef enum VkSamplerMipmapMode {
+    VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
+    VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
+    VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
+    VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
+    VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
+    VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerMipmapMode;
+
+typedef enum VkSamplerAddressMode {
+    VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
+    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
+    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
+    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
+    VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
+    VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
+    VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
+    VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
+    VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerAddressMode;
+
+typedef enum VkBorderColor {
+    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
+    VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
+    VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
+    VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
+    VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
+    VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
+    VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+    VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
+    VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
+    VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
+} VkBorderColor;
+
+typedef enum VkDescriptorType {
+    VK_DESCRIPTOR_TYPE_SAMPLER = 0,
+    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
+    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
+    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
+    VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
+    VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
+    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
+    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
+    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
+    VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
+    VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
+    VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
+    VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
+    VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorType;
+
+typedef enum VkAttachmentLoadOp {
+    VK_ATTACHMENT_LOAD_OP_LOAD = 0,
+    VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
+    VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
+    VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
+    VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+    VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
+    VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentLoadOp;
+
+typedef enum VkAttachmentStoreOp {
+    VK_ATTACHMENT_STORE_OP_STORE = 0,
+    VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
+    VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
+    VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+    VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
+    VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentStoreOp;
+
+typedef enum VkPipelineBindPoint {
+    VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
+    VK_PIPELINE_BIND_POINT_COMPUTE = 1,
+    VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
+    VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
+    VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
+    VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineBindPoint;
+
+typedef enum VkCommandBufferLevel {
+    VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+    VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+    VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+    VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
+    VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
+    VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferLevel;
+
+typedef enum VkIndexType {
+    VK_INDEX_TYPE_UINT16 = 0,
+    VK_INDEX_TYPE_UINT32 = 1,
+    VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
+    VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
+    VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
+    VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkIndexType;
+
+typedef enum VkSubpassContents {
+    VK_SUBPASS_CONTENTS_INLINE = 0,
+    VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+    VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
+    VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+    VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
+    VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+} VkSubpassContents;
+
+typedef enum VkObjectType {
+    VK_OBJECT_TYPE_UNKNOWN = 0,
+    VK_OBJECT_TYPE_INSTANCE = 1,
+    VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,
+    VK_OBJECT_TYPE_DEVICE = 3,
+    VK_OBJECT_TYPE_QUEUE = 4,
+    VK_OBJECT_TYPE_SEMAPHORE = 5,
+    VK_OBJECT_TYPE_COMMAND_BUFFER = 6,
+    VK_OBJECT_TYPE_FENCE = 7,
+    VK_OBJECT_TYPE_DEVICE_MEMORY = 8,
+    VK_OBJECT_TYPE_BUFFER = 9,
+    VK_OBJECT_TYPE_IMAGE = 10,
+    VK_OBJECT_TYPE_EVENT = 11,
+    VK_OBJECT_TYPE_QUERY_POOL = 12,
+    VK_OBJECT_TYPE_BUFFER_VIEW = 13,
+    VK_OBJECT_TYPE_IMAGE_VIEW = 14,
+    VK_OBJECT_TYPE_SHADER_MODULE = 15,
+    VK_OBJECT_TYPE_PIPELINE_CACHE = 16,
+    VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,
+    VK_OBJECT_TYPE_RENDER_PASS = 18,
+    VK_OBJECT_TYPE_PIPELINE = 19,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,
+    VK_OBJECT_TYPE_SAMPLER = 21,
+    VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,
+    VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,
+    VK_OBJECT_TYPE_FRAMEBUFFER = 24,
+    VK_OBJECT_TYPE_COMMAND_POOL = 25,
+    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,
+    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
+    VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,
+    VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,
+    VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,
+    VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,
+    VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,
+    VK_OBJECT_TYPE_OBJECT_TABLE_NVX = 1000086000,
+    VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX = 1000086001,
+    VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,
+    VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,
+    VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,
+    VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,
+    VK_OBJECT_TYPE_BEGIN_RANGE = VK_OBJECT_TYPE_UNKNOWN,
+    VK_OBJECT_TYPE_END_RANGE = VK_OBJECT_TYPE_COMMAND_POOL,
+    VK_OBJECT_TYPE_RANGE_SIZE = (VK_OBJECT_TYPE_COMMAND_POOL - VK_OBJECT_TYPE_UNKNOWN + 1),
+    VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkObjectType;
+
+typedef VkFlags VkInstanceCreateFlags;
+
+typedef enum VkFormatFeatureFlagBits {
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
+    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
+    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
+    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
+    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
+    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
+    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
+    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
+    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
+    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
+    VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
+    VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
+    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,
+    VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,
+    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,
+    VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,
+    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = 0x00010000,
+    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,
+    VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,
+    VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,
+    VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,
+    VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,
+    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,
+    VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFormatFeatureFlagBits;
+typedef VkFlags VkFormatFeatureFlags;
+
+typedef enum VkImageUsageFlagBits {
+    VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
+    VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
+    VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
+    VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
+    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
+    VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
+    VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
+    VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageUsageFlagBits;
+typedef VkFlags VkImageUsageFlags;
+
+typedef enum VkImageCreateFlagBits {
+    VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+    VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+    VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+    VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
+    VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
+    VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,
+    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,
+    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,
+    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,
+    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,
+    VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,
+    VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,
+    VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,
+    VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,
+    VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,
+    VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
+    VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,
+    VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,
+    VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageCreateFlagBits;
+typedef VkFlags VkImageCreateFlags;
+
+typedef enum VkSampleCountFlagBits {
+    VK_SAMPLE_COUNT_1_BIT = 0x00000001,
+    VK_SAMPLE_COUNT_2_BIT = 0x00000002,
+    VK_SAMPLE_COUNT_4_BIT = 0x00000004,
+    VK_SAMPLE_COUNT_8_BIT = 0x00000008,
+    VK_SAMPLE_COUNT_16_BIT = 0x00000010,
+    VK_SAMPLE_COUNT_32_BIT = 0x00000020,
+    VK_SAMPLE_COUNT_64_BIT = 0x00000040,
+    VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSampleCountFlagBits;
+typedef VkFlags VkSampleCountFlags;
+
+typedef enum VkQueueFlagBits {
+    VK_QUEUE_GRAPHICS_BIT = 0x00000001,
+    VK_QUEUE_COMPUTE_BIT = 0x00000002,
+    VK_QUEUE_TRANSFER_BIT = 0x00000004,
+    VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
+    VK_QUEUE_PROTECTED_BIT = 0x00000010,
+    VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueueFlagBits;
+typedef VkFlags VkQueueFlags;
+
+typedef enum VkMemoryPropertyFlagBits {
+    VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
+    VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
+    VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
+    VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
+    VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
+    VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,
+    VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryPropertyFlagBits;
+typedef VkFlags VkMemoryPropertyFlags;
+
+typedef enum VkMemoryHeapFlagBits {
+    VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
+    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,
+    VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,
+    VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryHeapFlagBits;
+typedef VkFlags VkMemoryHeapFlags;
+typedef VkFlags VkDeviceCreateFlags;
+
+typedef enum VkDeviceQueueCreateFlagBits {
+    VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,
+    VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDeviceQueueCreateFlagBits;
+typedef VkFlags VkDeviceQueueCreateFlags;
+
+typedef enum VkPipelineStageFlagBits {
+    VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
+    VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
+    VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
+    VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
+    VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
+    VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
+    VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
+    VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
+    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
+    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
+    VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
+    VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
+    VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
+    VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
+    VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
+    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
+    VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX = 0x00020000,
+    VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineStageFlagBits;
+typedef VkFlags VkPipelineStageFlags;
+typedef VkFlags VkMemoryMapFlags;
+
+typedef enum VkImageAspectFlagBits {
+    VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+    VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+    VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+    VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+    VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,
+    VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,
+    VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,
+    VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,
+    VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,
+    VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,
+    VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkImageAspectFlagBits;
+typedef VkFlags VkImageAspectFlags;
+
+typedef enum VkSparseImageFormatFlagBits {
+    VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
+    VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
+    VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
+    VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSparseImageFormatFlagBits;
+typedef VkFlags VkSparseImageFormatFlags;
+
+typedef enum VkSparseMemoryBindFlagBits {
+    VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
+    VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSparseMemoryBindFlagBits;
+typedef VkFlags VkSparseMemoryBindFlags;
+
+typedef enum VkFenceCreateFlagBits {
+    VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
+    VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFenceCreateFlagBits;
+typedef VkFlags VkFenceCreateFlags;
+typedef VkFlags VkSemaphoreCreateFlags;
+typedef VkFlags VkEventCreateFlags;
+typedef VkFlags VkQueryPoolCreateFlags;
+
+typedef enum VkQueryPipelineStatisticFlagBits {
+    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
+    VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
+    VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
+    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
+    VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
+    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
+    VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
+    VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
+    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
+    VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
+    VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
+    VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryPipelineStatisticFlagBits;
+typedef VkFlags VkQueryPipelineStatisticFlags;
+
+typedef enum VkQueryResultFlagBits {
+    VK_QUERY_RESULT_64_BIT = 0x00000001,
+    VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
+    VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
+    VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
+    VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryResultFlagBits;
+typedef VkFlags VkQueryResultFlags;
+
+typedef enum VkBufferCreateFlagBits {
+    VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
+    VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
+    VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
+    VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,
+    VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkBufferCreateFlagBits;
+typedef VkFlags VkBufferCreateFlags;
+
+typedef enum VkBufferUsageFlagBits {
+    VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+    VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+    VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
+    VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
+    VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
+    VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
+    VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
+    VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
+    VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
+    VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkBufferUsageFlagBits;
+typedef VkFlags VkBufferUsageFlags;
+typedef VkFlags VkBufferViewCreateFlags;
+typedef VkFlags VkImageViewCreateFlags;
+typedef VkFlags VkShaderModuleCreateFlags;
+typedef VkFlags VkPipelineCacheCreateFlags;
+
+typedef enum VkPipelineCreateFlagBits {
+    VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
+    VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
+    VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
+    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,
+    VK_PIPELINE_CREATE_DISPATCH_BASE = 0x00000010,
+    VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,
+    VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,
+    VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPipelineCreateFlagBits;
+typedef VkFlags VkPipelineCreateFlags;
+typedef VkFlags VkPipelineShaderStageCreateFlags;
+
+typedef enum VkShaderStageFlagBits {
+    VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+    VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+    VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+    VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+    VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
+    VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+    VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkShaderStageFlagBits;
+typedef VkFlags VkPipelineVertexInputStateCreateFlags;
+typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
+typedef VkFlags VkPipelineTessellationStateCreateFlags;
+typedef VkFlags VkPipelineViewportStateCreateFlags;
+typedef VkFlags VkPipelineRasterizationStateCreateFlags;
+
+typedef enum VkCullModeFlagBits {
+    VK_CULL_MODE_NONE = 0,
+    VK_CULL_MODE_FRONT_BIT = 0x00000001,
+    VK_CULL_MODE_BACK_BIT = 0x00000002,
+    VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
+    VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCullModeFlagBits;
+typedef VkFlags VkCullModeFlags;
+typedef VkFlags VkPipelineMultisampleStateCreateFlags;
+typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
+typedef VkFlags VkPipelineColorBlendStateCreateFlags;
+
+typedef enum VkColorComponentFlagBits {
+    VK_COLOR_COMPONENT_R_BIT = 0x00000001,
+    VK_COLOR_COMPONENT_G_BIT = 0x00000002,
+    VK_COLOR_COMPONENT_B_BIT = 0x00000004,
+    VK_COLOR_COMPONENT_A_BIT = 0x00000008,
+    VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkColorComponentFlagBits;
+typedef VkFlags VkColorComponentFlags;
+typedef VkFlags VkPipelineDynamicStateCreateFlags;
+typedef VkFlags VkPipelineLayoutCreateFlags;
+typedef VkFlags VkShaderStageFlags;
+typedef VkFlags VkSamplerCreateFlags;
+
+typedef enum VkDescriptorSetLayoutCreateFlagBits {
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = 0x00000002,
+    VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorSetLayoutCreateFlagBits;
+typedef VkFlags VkDescriptorSetLayoutCreateFlags;
+
+typedef enum VkDescriptorPoolCreateFlagBits {
+    VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
+    VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = 0x00000002,
+    VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorPoolCreateFlagBits;
+typedef VkFlags VkDescriptorPoolCreateFlags;
+typedef VkFlags VkDescriptorPoolResetFlags;
+typedef VkFlags VkFramebufferCreateFlags;
+typedef VkFlags VkRenderPassCreateFlags;
+
+typedef enum VkAttachmentDescriptionFlagBits {
+    VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
+    VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkAttachmentDescriptionFlagBits;
+typedef VkFlags VkAttachmentDescriptionFlags;
+
+typedef enum VkSubpassDescriptionFlagBits {
+    VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,
+    VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,
+    VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSubpassDescriptionFlagBits;
+typedef VkFlags VkSubpassDescriptionFlags;
+
+typedef enum VkAccessFlagBits {
+    VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
+    VK_ACCESS_INDEX_READ_BIT = 0x00000002,
+    VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
+    VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
+    VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
+    VK_ACCESS_SHADER_READ_BIT = 0x00000020,
+    VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
+    VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
+    VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
+    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
+    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
+    VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
+    VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
+    VK_ACCESS_HOST_READ_BIT = 0x00002000,
+    VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
+    VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
+    VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
+    VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX = 0x00020000,
+    VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX = 0x00040000,
+    VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,
+    VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkAccessFlagBits;
+typedef VkFlags VkAccessFlags;
+
+typedef enum VkDependencyFlagBits {
+    VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
+    VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,
+    VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,
+    VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,
+    VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,
+    VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkDependencyFlagBits;
+typedef VkFlags VkDependencyFlags;
+
+typedef enum VkCommandPoolCreateFlagBits {
+    VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+    VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+    VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,
+    VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandPoolCreateFlagBits;
+typedef VkFlags VkCommandPoolCreateFlags;
+
+typedef enum VkCommandPoolResetFlagBits {
+    VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+    VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandPoolResetFlagBits;
+typedef VkFlags VkCommandPoolResetFlags;
+
+typedef enum VkCommandBufferUsageFlagBits {
+    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+    VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+    VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+    VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferUsageFlagBits;
+typedef VkFlags VkCommandBufferUsageFlags;
+
+typedef enum VkQueryControlFlagBits {
+    VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
+    VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkQueryControlFlagBits;
+typedef VkFlags VkQueryControlFlags;
+
+typedef enum VkCommandBufferResetFlagBits {
+    VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+    VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferResetFlagBits;
+typedef VkFlags VkCommandBufferResetFlags;
+
+typedef enum VkStencilFaceFlagBits {
+    VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
+    VK_STENCIL_FACE_BACK_BIT = 0x00000002,
+    VK_STENCIL_FRONT_AND_BACK = 0x00000003,
+    VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkStencilFaceFlagBits;
+typedef VkFlags VkStencilFaceFlags;
+
+typedef struct VkApplicationInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pApplicationName;
+    uint32_t           applicationVersion;
+    const char*        pEngineName;
+    uint32_t           engineVersion;
+    uint32_t           apiVersion;
+} VkApplicationInfo;
+
+typedef struct VkInstanceCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkInstanceCreateFlags       flags;
+    const VkApplicationInfo*    pApplicationInfo;
+    uint32_t                    enabledLayerCount;
+    const char* const*          ppEnabledLayerNames;
+    uint32_t                    enabledExtensionCount;
+    const char* const*          ppEnabledExtensionNames;
+} VkInstanceCreateInfo;
+
+typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
+    void*                                       pUserData,
+    size_t                                      size,
+    size_t                                      alignment,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
+    void*                                       pUserData,
+    void*                                       pOriginal,
+    size_t                                      size,
+    size_t                                      alignment,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
+    void*                                       pUserData,
+    void*                                       pMemory);
+
+typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
+    void*                                       pUserData,
+    size_t                                      size,
+    VkInternalAllocationType                    allocationType,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
+    void*                                       pUserData,
+    size_t                                      size,
+    VkInternalAllocationType                    allocationType,
+    VkSystemAllocationScope                     allocationScope);
+
+typedef struct VkAllocationCallbacks {
+    void*                                   pUserData;
+    PFN_vkAllocationFunction                pfnAllocation;
+    PFN_vkReallocationFunction              pfnReallocation;
+    PFN_vkFreeFunction                      pfnFree;
+    PFN_vkInternalAllocationNotification    pfnInternalAllocation;
+    PFN_vkInternalFreeNotification          pfnInternalFree;
+} VkAllocationCallbacks;
+
+typedef struct VkPhysicalDeviceFeatures {
+    VkBool32    robustBufferAccess;
+    VkBool32    fullDrawIndexUint32;
+    VkBool32    imageCubeArray;
+    VkBool32    independentBlend;
+    VkBool32    geometryShader;
+    VkBool32    tessellationShader;
+    VkBool32    sampleRateShading;
+    VkBool32    dualSrcBlend;
+    VkBool32    logicOp;
+    VkBool32    multiDrawIndirect;
+    VkBool32    drawIndirectFirstInstance;
+    VkBool32    depthClamp;
+    VkBool32    depthBiasClamp;
+    VkBool32    fillModeNonSolid;
+    VkBool32    depthBounds;
+    VkBool32    wideLines;
+    VkBool32    largePoints;
+    VkBool32    alphaToOne;
+    VkBool32    multiViewport;
+    VkBool32    samplerAnisotropy;
+    VkBool32    textureCompressionETC2;
+    VkBool32    textureCompressionASTC_LDR;
+    VkBool32    textureCompressionBC;
+    VkBool32    occlusionQueryPrecise;
+    VkBool32    pipelineStatisticsQuery;
+    VkBool32    vertexPipelineStoresAndAtomics;
+    VkBool32    fragmentStoresAndAtomics;
+    VkBool32    shaderTessellationAndGeometryPointSize;
+    VkBool32    shaderImageGatherExtended;
+    VkBool32    shaderStorageImageExtendedFormats;
+    VkBool32    shaderStorageImageMultisample;
+    VkBool32    shaderStorageImageReadWithoutFormat;
+    VkBool32    shaderStorageImageWriteWithoutFormat;
+    VkBool32    shaderUniformBufferArrayDynamicIndexing;
+    VkBool32    shaderSampledImageArrayDynamicIndexing;
+    VkBool32    shaderStorageBufferArrayDynamicIndexing;
+    VkBool32    shaderStorageImageArrayDynamicIndexing;
+    VkBool32    shaderClipDistance;
+    VkBool32    shaderCullDistance;
+    VkBool32    shaderFloat64;
+    VkBool32    shaderInt64;
+    VkBool32    shaderInt16;
+    VkBool32    shaderResourceResidency;
+    VkBool32    shaderResourceMinLod;
+    VkBool32    sparseBinding;
+    VkBool32    sparseResidencyBuffer;
+    VkBool32    sparseResidencyImage2D;
+    VkBool32    sparseResidencyImage3D;
+    VkBool32    sparseResidency2Samples;
+    VkBool32    sparseResidency4Samples;
+    VkBool32    sparseResidency8Samples;
+    VkBool32    sparseResidency16Samples;
+    VkBool32    sparseResidencyAliased;
+    VkBool32    variableMultisampleRate;
+    VkBool32    inheritedQueries;
+} VkPhysicalDeviceFeatures;
+
+typedef struct VkFormatProperties {
+    VkFormatFeatureFlags    linearTilingFeatures;
+    VkFormatFeatureFlags    optimalTilingFeatures;
+    VkFormatFeatureFlags    bufferFeatures;
+} VkFormatProperties;
+
+typedef struct VkExtent3D {
+    uint32_t    width;
+    uint32_t    height;
+    uint32_t    depth;
+} VkExtent3D;
+
+typedef struct VkImageFormatProperties {
+    VkExtent3D            maxExtent;
+    uint32_t              maxMipLevels;
+    uint32_t              maxArrayLayers;
+    VkSampleCountFlags    sampleCounts;
+    VkDeviceSize          maxResourceSize;
+} VkImageFormatProperties;
+
+typedef struct VkPhysicalDeviceLimits {
+    uint32_t              maxImageDimension1D;
+    uint32_t              maxImageDimension2D;
+    uint32_t              maxImageDimension3D;
+    uint32_t              maxImageDimensionCube;
+    uint32_t              maxImageArrayLayers;
+    uint32_t              maxTexelBufferElements;
+    uint32_t              maxUniformBufferRange;
+    uint32_t              maxStorageBufferRange;
+    uint32_t              maxPushConstantsSize;
+    uint32_t              maxMemoryAllocationCount;
+    uint32_t              maxSamplerAllocationCount;
+    VkDeviceSize          bufferImageGranularity;
+    VkDeviceSize          sparseAddressSpaceSize;
+    uint32_t              maxBoundDescriptorSets;
+    uint32_t              maxPerStageDescriptorSamplers;
+    uint32_t              maxPerStageDescriptorUniformBuffers;
+    uint32_t              maxPerStageDescriptorStorageBuffers;
+    uint32_t              maxPerStageDescriptorSampledImages;
+    uint32_t              maxPerStageDescriptorStorageImages;
+    uint32_t              maxPerStageDescriptorInputAttachments;
+    uint32_t              maxPerStageResources;
+    uint32_t              maxDescriptorSetSamplers;
+    uint32_t              maxDescriptorSetUniformBuffers;
+    uint32_t              maxDescriptorSetUniformBuffersDynamic;
+    uint32_t              maxDescriptorSetStorageBuffers;
+    uint32_t              maxDescriptorSetStorageBuffersDynamic;
+    uint32_t              maxDescriptorSetSampledImages;
+    uint32_t              maxDescriptorSetStorageImages;
+    uint32_t              maxDescriptorSetInputAttachments;
+    uint32_t              maxVertexInputAttributes;
+    uint32_t              maxVertexInputBindings;
+    uint32_t              maxVertexInputAttributeOffset;
+    uint32_t              maxVertexInputBindingStride;
+    uint32_t              maxVertexOutputComponents;
+    uint32_t              maxTessellationGenerationLevel;
+    uint32_t              maxTessellationPatchSize;
+    uint32_t              maxTessellationControlPerVertexInputComponents;
+    uint32_t              maxTessellationControlPerVertexOutputComponents;
+    uint32_t              maxTessellationControlPerPatchOutputComponents;
+    uint32_t              maxTessellationControlTotalOutputComponents;
+    uint32_t              maxTessellationEvaluationInputComponents;
+    uint32_t              maxTessellationEvaluationOutputComponents;
+    uint32_t              maxGeometryShaderInvocations;
+    uint32_t              maxGeometryInputComponents;
+    uint32_t              maxGeometryOutputComponents;
+    uint32_t              maxGeometryOutputVertices;
+    uint32_t              maxGeometryTotalOutputComponents;
+    uint32_t              maxFragmentInputComponents;
+    uint32_t              maxFragmentOutputAttachments;
+    uint32_t              maxFragmentDualSrcAttachments;
+    uint32_t              maxFragmentCombinedOutputResources;
+    uint32_t              maxComputeSharedMemorySize;
+    uint32_t              maxComputeWorkGroupCount[3];
+    uint32_t              maxComputeWorkGroupInvocations;
+    uint32_t              maxComputeWorkGroupSize[3];
+    uint32_t              subPixelPrecisionBits;
+    uint32_t              subTexelPrecisionBits;
+    uint32_t              mipmapPrecisionBits;
+    uint32_t              maxDrawIndexedIndexValue;
+    uint32_t              maxDrawIndirectCount;
+    float                 maxSamplerLodBias;
+    float                 maxSamplerAnisotropy;
+    uint32_t              maxViewports;
+    uint32_t              maxViewportDimensions[2];
+    float                 viewportBoundsRange[2];
+    uint32_t              viewportSubPixelBits;
+    size_t                minMemoryMapAlignment;
+    VkDeviceSize          minTexelBufferOffsetAlignment;
+    VkDeviceSize          minUniformBufferOffsetAlignment;
+    VkDeviceSize          minStorageBufferOffsetAlignment;
+    int32_t               minTexelOffset;
+    uint32_t              maxTexelOffset;
+    int32_t               minTexelGatherOffset;
+    uint32_t              maxTexelGatherOffset;
+    float                 minInterpolationOffset;
+    float                 maxInterpolationOffset;
+    uint32_t              subPixelInterpolationOffsetBits;
+    uint32_t              maxFramebufferWidth;
+    uint32_t              maxFramebufferHeight;
+    uint32_t              maxFramebufferLayers;
+    VkSampleCountFlags    framebufferColorSampleCounts;
+    VkSampleCountFlags    framebufferDepthSampleCounts;
+    VkSampleCountFlags    framebufferStencilSampleCounts;
+    VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
+    uint32_t              maxColorAttachments;
+    VkSampleCountFlags    sampledImageColorSampleCounts;
+    VkSampleCountFlags    sampledImageIntegerSampleCounts;
+    VkSampleCountFlags    sampledImageDepthSampleCounts;
+    VkSampleCountFlags    sampledImageStencilSampleCounts;
+    VkSampleCountFlags    storageImageSampleCounts;
+    uint32_t              maxSampleMaskWords;
+    VkBool32              timestampComputeAndGraphics;
+    float                 timestampPeriod;
+    uint32_t              maxClipDistances;
+    uint32_t              maxCullDistances;
+    uint32_t              maxCombinedClipAndCullDistances;
+    uint32_t              discreteQueuePriorities;
+    float                 pointSizeRange[2];
+    float                 lineWidthRange[2];
+    float                 pointSizeGranularity;
+    float                 lineWidthGranularity;
+    VkBool32              strictLines;
+    VkBool32              standardSampleLocations;
+    VkDeviceSize          optimalBufferCopyOffsetAlignment;
+    VkDeviceSize          optimalBufferCopyRowPitchAlignment;
+    VkDeviceSize          nonCoherentAtomSize;
+} VkPhysicalDeviceLimits;
+
+typedef struct VkPhysicalDeviceSparseProperties {
+    VkBool32    residencyStandard2DBlockShape;
+    VkBool32    residencyStandard2DMultisampleBlockShape;
+    VkBool32    residencyStandard3DBlockShape;
+    VkBool32    residencyAlignedMipSize;
+    VkBool32    residencyNonResidentStrict;
+} VkPhysicalDeviceSparseProperties;
+
+typedef struct VkPhysicalDeviceProperties {
+    uint32_t                            apiVersion;
+    uint32_t                            driverVersion;
+    uint32_t                            vendorID;
+    uint32_t                            deviceID;
+    VkPhysicalDeviceType                deviceType;
+    char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+    uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
+    VkPhysicalDeviceLimits              limits;
+    VkPhysicalDeviceSparseProperties    sparseProperties;
+} VkPhysicalDeviceProperties;
+
+typedef struct VkQueueFamilyProperties {
+    VkQueueFlags    queueFlags;
+    uint32_t        queueCount;
+    uint32_t        timestampValidBits;
+    VkExtent3D      minImageTransferGranularity;
+} VkQueueFamilyProperties;
+
+typedef struct VkMemoryType {
+    VkMemoryPropertyFlags    propertyFlags;
+    uint32_t                 heapIndex;
+} VkMemoryType;
+
+typedef struct VkMemoryHeap {
+    VkDeviceSize         size;
+    VkMemoryHeapFlags    flags;
+} VkMemoryHeap;
+
+typedef struct VkPhysicalDeviceMemoryProperties {
+    uint32_t        memoryTypeCount;
+    VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
+    uint32_t        memoryHeapCount;
+    VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryProperties;
+
+typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);
+typedef struct VkDeviceQueueCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkDeviceQueueCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+    uint32_t                    queueCount;
+    const float*                pQueuePriorities;
+} VkDeviceQueueCreateInfo;
+
+typedef struct VkDeviceCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkDeviceCreateFlags                flags;
+    uint32_t                           queueCreateInfoCount;
+    const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
+    uint32_t                           enabledLayerCount;
+    const char* const*                 ppEnabledLayerNames;
+    uint32_t                           enabledExtensionCount;
+    const char* const*                 ppEnabledExtensionNames;
+    const VkPhysicalDeviceFeatures*    pEnabledFeatures;
+} VkDeviceCreateInfo;
+
+typedef struct VkExtensionProperties {
+    char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t    specVersion;
+} VkExtensionProperties;
+
+typedef struct VkLayerProperties {
+    char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
+    uint32_t    specVersion;
+    uint32_t    implementationVersion;
+    char        description[VK_MAX_DESCRIPTION_SIZE];
+} VkLayerProperties;
+
+typedef struct VkSubmitInfo {
+    VkStructureType                sType;
+    const void*                    pNext;
+    uint32_t                       waitSemaphoreCount;
+    const VkSemaphore*             pWaitSemaphores;
+    const VkPipelineStageFlags*    pWaitDstStageMask;
+    uint32_t                       commandBufferCount;
+    const VkCommandBuffer*         pCommandBuffers;
+    uint32_t                       signalSemaphoreCount;
+    const VkSemaphore*             pSignalSemaphores;
+} VkSubmitInfo;
+
+typedef struct VkMemoryAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceSize       allocationSize;
+    uint32_t           memoryTypeIndex;
+} VkMemoryAllocateInfo;
+
+typedef struct VkMappedMemoryRange {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDeviceMemory     memory;
+    VkDeviceSize       offset;
+    VkDeviceSize       size;
+} VkMappedMemoryRange;
+
+typedef struct VkMemoryRequirements {
+    VkDeviceSize    size;
+    VkDeviceSize    alignment;
+    uint32_t        memoryTypeBits;
+} VkMemoryRequirements;
+
+typedef struct VkSparseImageFormatProperties {
+    VkImageAspectFlags          aspectMask;
+    VkExtent3D                  imageGranularity;
+    VkSparseImageFormatFlags    flags;
+} VkSparseImageFormatProperties;
+
+typedef struct VkSparseImageMemoryRequirements {
+    VkSparseImageFormatProperties    formatProperties;
+    uint32_t                         imageMipTailFirstLod;
+    VkDeviceSize                     imageMipTailSize;
+    VkDeviceSize                     imageMipTailOffset;
+    VkDeviceSize                     imageMipTailStride;
+} VkSparseImageMemoryRequirements;
+
+typedef struct VkSparseMemoryBind {
+    VkDeviceSize               resourceOffset;
+    VkDeviceSize               size;
+    VkDeviceMemory             memory;
+    VkDeviceSize               memoryOffset;
+    VkSparseMemoryBindFlags    flags;
+} VkSparseMemoryBind;
+
+typedef struct VkSparseBufferMemoryBindInfo {
+    VkBuffer                     buffer;
+    uint32_t                     bindCount;
+    const VkSparseMemoryBind*    pBinds;
+} VkSparseBufferMemoryBindInfo;
+
+typedef struct VkSparseImageOpaqueMemoryBindInfo {
+    VkImage                      image;
+    uint32_t                     bindCount;
+    const VkSparseMemoryBind*    pBinds;
+} VkSparseImageOpaqueMemoryBindInfo;
+
+typedef struct VkImageSubresource {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              mipLevel;
+    uint32_t              arrayLayer;
+} VkImageSubresource;
+
+typedef struct VkOffset3D {
+    int32_t    x;
+    int32_t    y;
+    int32_t    z;
+} VkOffset3D;
+
+typedef struct VkSparseImageMemoryBind {
+    VkImageSubresource         subresource;
+    VkOffset3D                 offset;
+    VkExtent3D                 extent;
+    VkDeviceMemory             memory;
+    VkDeviceSize               memoryOffset;
+    VkSparseMemoryBindFlags    flags;
+} VkSparseImageMemoryBind;
+
+typedef struct VkSparseImageMemoryBindInfo {
+    VkImage                           image;
+    uint32_t                          bindCount;
+    const VkSparseImageMemoryBind*    pBinds;
+} VkSparseImageMemoryBindInfo;
+
+typedef struct VkBindSparseInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    uint32_t                                    waitSemaphoreCount;
+    const VkSemaphore*                          pWaitSemaphores;
+    uint32_t                                    bufferBindCount;
+    const VkSparseBufferMemoryBindInfo*         pBufferBinds;
+    uint32_t                                    imageOpaqueBindCount;
+    const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
+    uint32_t                                    imageBindCount;
+    const VkSparseImageMemoryBindInfo*          pImageBinds;
+    uint32_t                                    signalSemaphoreCount;
+    const VkSemaphore*                          pSignalSemaphores;
+} VkBindSparseInfo;
+
+typedef struct VkFenceCreateInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkFenceCreateFlags    flags;
+} VkFenceCreateInfo;
+
+typedef struct VkSemaphoreCreateInfo {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkSemaphoreCreateFlags    flags;
+} VkSemaphoreCreateInfo;
+
+typedef struct VkEventCreateInfo {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkEventCreateFlags    flags;
+} VkEventCreateInfo;
+
+typedef struct VkQueryPoolCreateInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkQueryPoolCreateFlags           flags;
+    VkQueryType                      queryType;
+    uint32_t                         queryCount;
+    VkQueryPipelineStatisticFlags    pipelineStatistics;
+} VkQueryPoolCreateInfo;
+
+typedef struct VkBufferCreateInfo {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkBufferCreateFlags    flags;
+    VkDeviceSize           size;
+    VkBufferUsageFlags     usage;
+    VkSharingMode          sharingMode;
+    uint32_t               queueFamilyIndexCount;
+    const uint32_t*        pQueueFamilyIndices;
+} VkBufferCreateInfo;
+
+typedef struct VkBufferViewCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkBufferViewCreateFlags    flags;
+    VkBuffer                   buffer;
+    VkFormat                   format;
+    VkDeviceSize               offset;
+    VkDeviceSize               range;
+} VkBufferViewCreateInfo;
+
+typedef struct VkImageCreateInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageCreateFlags       flags;
+    VkImageType              imageType;
+    VkFormat                 format;
+    VkExtent3D               extent;
+    uint32_t                 mipLevels;
+    uint32_t                 arrayLayers;
+    VkSampleCountFlagBits    samples;
+    VkImageTiling            tiling;
+    VkImageUsageFlags        usage;
+    VkSharingMode            sharingMode;
+    uint32_t                 queueFamilyIndexCount;
+    const uint32_t*          pQueueFamilyIndices;
+    VkImageLayout            initialLayout;
+} VkImageCreateInfo;
+
+typedef struct VkSubresourceLayout {
+    VkDeviceSize    offset;
+    VkDeviceSize    size;
+    VkDeviceSize    rowPitch;
+    VkDeviceSize    arrayPitch;
+    VkDeviceSize    depthPitch;
+} VkSubresourceLayout;
+
+typedef struct VkComponentMapping {
+    VkComponentSwizzle    r;
+    VkComponentSwizzle    g;
+    VkComponentSwizzle    b;
+    VkComponentSwizzle    a;
+} VkComponentMapping;
+
+typedef struct VkImageSubresourceRange {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              baseMipLevel;
+    uint32_t              levelCount;
+    uint32_t              baseArrayLayer;
+    uint32_t              layerCount;
+} VkImageSubresourceRange;
+
+typedef struct VkImageViewCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkImageViewCreateFlags     flags;
+    VkImage                    image;
+    VkImageViewType            viewType;
+    VkFormat                   format;
+    VkComponentMapping         components;
+    VkImageSubresourceRange    subresourceRange;
+} VkImageViewCreateInfo;
+
+typedef struct VkShaderModuleCreateInfo {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkShaderModuleCreateFlags    flags;
+    size_t                       codeSize;
+    const uint32_t*              pCode;
+} VkShaderModuleCreateInfo;
+
+typedef struct VkPipelineCacheCreateInfo {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkPipelineCacheCreateFlags    flags;
+    size_t                        initialDataSize;
+    const void*                   pInitialData;
+} VkPipelineCacheCreateInfo;
+
+typedef struct VkSpecializationMapEntry {
+    uint32_t    constantID;
+    uint32_t    offset;
+    size_t      size;
+} VkSpecializationMapEntry;
+
+typedef struct VkSpecializationInfo {
+    uint32_t                           mapEntryCount;
+    const VkSpecializationMapEntry*    pMapEntries;
+    size_t                             dataSize;
+    const void*                        pData;
+} VkSpecializationInfo;
+
+typedef struct VkPipelineShaderStageCreateInfo {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkPipelineShaderStageCreateFlags    flags;
+    VkShaderStageFlagBits               stage;
+    VkShaderModule                      module;
+    const char*                         pName;
+    const VkSpecializationInfo*         pSpecializationInfo;
+} VkPipelineShaderStageCreateInfo;
+
+typedef struct VkVertexInputBindingDescription {
+    uint32_t             binding;
+    uint32_t             stride;
+    VkVertexInputRate    inputRate;
+} VkVertexInputBindingDescription;
+
+typedef struct VkVertexInputAttributeDescription {
+    uint32_t    location;
+    uint32_t    binding;
+    VkFormat    format;
+    uint32_t    offset;
+} VkVertexInputAttributeDescription;
+
+typedef struct VkPipelineVertexInputStateCreateInfo {
+    VkStructureType                             sType;
+    const void*                                 pNext;
+    VkPipelineVertexInputStateCreateFlags       flags;
+    uint32_t                                    vertexBindingDescriptionCount;
+    const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
+    uint32_t                                    vertexAttributeDescriptionCount;
+    const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
+} VkPipelineVertexInputStateCreateInfo;
+
+typedef struct VkPipelineInputAssemblyStateCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPipelineInputAssemblyStateCreateFlags    flags;
+    VkPrimitiveTopology                        topology;
+    VkBool32                                   primitiveRestartEnable;
+} VkPipelineInputAssemblyStateCreateInfo;
+
+typedef struct VkPipelineTessellationStateCreateInfo {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkPipelineTessellationStateCreateFlags    flags;
+    uint32_t                                  patchControlPoints;
+} VkPipelineTessellationStateCreateInfo;
+
+typedef struct VkViewport {
+    float    x;
+    float    y;
+    float    width;
+    float    height;
+    float    minDepth;
+    float    maxDepth;
+} VkViewport;
+
+typedef struct VkOffset2D {
+    int32_t    x;
+    int32_t    y;
+} VkOffset2D;
+
+typedef struct VkExtent2D {
+    uint32_t    width;
+    uint32_t    height;
+} VkExtent2D;
+
+typedef struct VkRect2D {
+    VkOffset2D    offset;
+    VkExtent2D    extent;
+} VkRect2D;
+
+typedef struct VkPipelineViewportStateCreateInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkPipelineViewportStateCreateFlags    flags;
+    uint32_t                              viewportCount;
+    const VkViewport*                     pViewports;
+    uint32_t                              scissorCount;
+    const VkRect2D*                       pScissors;
+} VkPipelineViewportStateCreateInfo;
+
+typedef struct VkPipelineRasterizationStateCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPipelineRasterizationStateCreateFlags    flags;
+    VkBool32                                   depthClampEnable;
+    VkBool32                                   rasterizerDiscardEnable;
+    VkPolygonMode                              polygonMode;
+    VkCullModeFlags                            cullMode;
+    VkFrontFace                                frontFace;
+    VkBool32                                   depthBiasEnable;
+    float                                      depthBiasConstantFactor;
+    float                                      depthBiasClamp;
+    float                                      depthBiasSlopeFactor;
+    float                                      lineWidth;
+} VkPipelineRasterizationStateCreateInfo;
+
+typedef struct VkPipelineMultisampleStateCreateInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkPipelineMultisampleStateCreateFlags    flags;
+    VkSampleCountFlagBits                    rasterizationSamples;
+    VkBool32                                 sampleShadingEnable;
+    float                                    minSampleShading;
+    const VkSampleMask*                      pSampleMask;
+    VkBool32                                 alphaToCoverageEnable;
+    VkBool32                                 alphaToOneEnable;
+} VkPipelineMultisampleStateCreateInfo;
+
+typedef struct VkStencilOpState {
+    VkStencilOp    failOp;
+    VkStencilOp    passOp;
+    VkStencilOp    depthFailOp;
+    VkCompareOp    compareOp;
+    uint32_t       compareMask;
+    uint32_t       writeMask;
+    uint32_t       reference;
+} VkStencilOpState;
+
+typedef struct VkPipelineDepthStencilStateCreateInfo {
+    VkStructureType                           sType;
+    const void*                               pNext;
+    VkPipelineDepthStencilStateCreateFlags    flags;
+    VkBool32                                  depthTestEnable;
+    VkBool32                                  depthWriteEnable;
+    VkCompareOp                               depthCompareOp;
+    VkBool32                                  depthBoundsTestEnable;
+    VkBool32                                  stencilTestEnable;
+    VkStencilOpState                          front;
+    VkStencilOpState                          back;
+    float                                     minDepthBounds;
+    float                                     maxDepthBounds;
+} VkPipelineDepthStencilStateCreateInfo;
+
+typedef struct VkPipelineColorBlendAttachmentState {
+    VkBool32                 blendEnable;
+    VkBlendFactor            srcColorBlendFactor;
+    VkBlendFactor            dstColorBlendFactor;
+    VkBlendOp                colorBlendOp;
+    VkBlendFactor            srcAlphaBlendFactor;
+    VkBlendFactor            dstAlphaBlendFactor;
+    VkBlendOp                alphaBlendOp;
+    VkColorComponentFlags    colorWriteMask;
+} VkPipelineColorBlendAttachmentState;
+
+typedef struct VkPipelineColorBlendStateCreateInfo {
+    VkStructureType                               sType;
+    const void*                                   pNext;
+    VkPipelineColorBlendStateCreateFlags          flags;
+    VkBool32                                      logicOpEnable;
+    VkLogicOp                                     logicOp;
+    uint32_t                                      attachmentCount;
+    const VkPipelineColorBlendAttachmentState*    pAttachments;
+    float                                         blendConstants[4];
+} VkPipelineColorBlendStateCreateInfo;
+
+typedef struct VkPipelineDynamicStateCreateInfo {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkPipelineDynamicStateCreateFlags    flags;
+    uint32_t                             dynamicStateCount;
+    const VkDynamicState*                pDynamicStates;
+} VkPipelineDynamicStateCreateInfo;
+
+typedef struct VkGraphicsPipelineCreateInfo {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    VkPipelineCreateFlags                            flags;
+    uint32_t                                         stageCount;
+    const VkPipelineShaderStageCreateInfo*           pStages;
+    const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
+    const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
+    const VkPipelineTessellationStateCreateInfo*     pTessellationState;
+    const VkPipelineViewportStateCreateInfo*         pViewportState;
+    const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
+    const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
+    const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
+    const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
+    const VkPipelineDynamicStateCreateInfo*          pDynamicState;
+    VkPipelineLayout                                 layout;
+    VkRenderPass                                     renderPass;
+    uint32_t                                         subpass;
+    VkPipeline                                       basePipelineHandle;
+    int32_t                                          basePipelineIndex;
+} VkGraphicsPipelineCreateInfo;
+
+typedef struct VkComputePipelineCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkPipelineCreateFlags              flags;
+    VkPipelineShaderStageCreateInfo    stage;
+    VkPipelineLayout                   layout;
+    VkPipeline                         basePipelineHandle;
+    int32_t                            basePipelineIndex;
+} VkComputePipelineCreateInfo;
+
+typedef struct VkPushConstantRange {
+    VkShaderStageFlags    stageFlags;
+    uint32_t              offset;
+    uint32_t              size;
+} VkPushConstantRange;
+
+typedef struct VkPipelineLayoutCreateInfo {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkPipelineLayoutCreateFlags     flags;
+    uint32_t                        setLayoutCount;
+    const VkDescriptorSetLayout*    pSetLayouts;
+    uint32_t                        pushConstantRangeCount;
+    const VkPushConstantRange*      pPushConstantRanges;
+} VkPipelineLayoutCreateInfo;
+
+typedef struct VkSamplerCreateInfo {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkSamplerCreateFlags    flags;
+    VkFilter                magFilter;
+    VkFilter                minFilter;
+    VkSamplerMipmapMode     mipmapMode;
+    VkSamplerAddressMode    addressModeU;
+    VkSamplerAddressMode    addressModeV;
+    VkSamplerAddressMode    addressModeW;
+    float                   mipLodBias;
+    VkBool32                anisotropyEnable;
+    float                   maxAnisotropy;
+    VkBool32                compareEnable;
+    VkCompareOp             compareOp;
+    float                   minLod;
+    float                   maxLod;
+    VkBorderColor           borderColor;
+    VkBool32                unnormalizedCoordinates;
+} VkSamplerCreateInfo;
+
+typedef struct VkDescriptorSetLayoutBinding {
+    uint32_t              binding;
+    VkDescriptorType      descriptorType;
+    uint32_t              descriptorCount;
+    VkShaderStageFlags    stageFlags;
+    const VkSampler*      pImmutableSamplers;
+} VkDescriptorSetLayoutBinding;
+
+typedef struct VkDescriptorSetLayoutCreateInfo {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    VkDescriptorSetLayoutCreateFlags       flags;
+    uint32_t                               bindingCount;
+    const VkDescriptorSetLayoutBinding*    pBindings;
+} VkDescriptorSetLayoutCreateInfo;
+
+typedef struct VkDescriptorPoolSize {
+    VkDescriptorType    type;
+    uint32_t            descriptorCount;
+} VkDescriptorPoolSize;
+
+typedef struct VkDescriptorPoolCreateInfo {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkDescriptorPoolCreateFlags    flags;
+    uint32_t                       maxSets;
+    uint32_t                       poolSizeCount;
+    const VkDescriptorPoolSize*    pPoolSizes;
+} VkDescriptorPoolCreateInfo;
+
+typedef struct VkDescriptorSetAllocateInfo {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkDescriptorPool                descriptorPool;
+    uint32_t                        descriptorSetCount;
+    const VkDescriptorSetLayout*    pSetLayouts;
+} VkDescriptorSetAllocateInfo;
+
+typedef struct VkDescriptorImageInfo {
+    VkSampler        sampler;
+    VkImageView      imageView;
+    VkImageLayout    imageLayout;
+} VkDescriptorImageInfo;
+
+typedef struct VkDescriptorBufferInfo {
+    VkBuffer        buffer;
+    VkDeviceSize    offset;
+    VkDeviceSize    range;
+} VkDescriptorBufferInfo;
+
+typedef struct VkWriteDescriptorSet {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkDescriptorSet                  dstSet;
+    uint32_t                         dstBinding;
+    uint32_t                         dstArrayElement;
+    uint32_t                         descriptorCount;
+    VkDescriptorType                 descriptorType;
+    const VkDescriptorImageInfo*     pImageInfo;
+    const VkDescriptorBufferInfo*    pBufferInfo;
+    const VkBufferView*              pTexelBufferView;
+} VkWriteDescriptorSet;
+
+typedef struct VkCopyDescriptorSet {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkDescriptorSet    srcSet;
+    uint32_t           srcBinding;
+    uint32_t           srcArrayElement;
+    VkDescriptorSet    dstSet;
+    uint32_t           dstBinding;
+    uint32_t           dstArrayElement;
+    uint32_t           descriptorCount;
+} VkCopyDescriptorSet;
+
+typedef struct VkFramebufferCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkFramebufferCreateFlags    flags;
+    VkRenderPass                renderPass;
+    uint32_t                    attachmentCount;
+    const VkImageView*          pAttachments;
+    uint32_t                    width;
+    uint32_t                    height;
+    uint32_t                    layers;
+} VkFramebufferCreateInfo;
+
+typedef struct VkAttachmentDescription {
+    VkAttachmentDescriptionFlags    flags;
+    VkFormat                        format;
+    VkSampleCountFlagBits           samples;
+    VkAttachmentLoadOp              loadOp;
+    VkAttachmentStoreOp             storeOp;
+    VkAttachmentLoadOp              stencilLoadOp;
+    VkAttachmentStoreOp             stencilStoreOp;
+    VkImageLayout                   initialLayout;
+    VkImageLayout                   finalLayout;
+} VkAttachmentDescription;
+
+typedef struct VkAttachmentReference {
+    uint32_t         attachment;
+    VkImageLayout    layout;
+} VkAttachmentReference;
+
+typedef struct VkSubpassDescription {
+    VkSubpassDescriptionFlags       flags;
+    VkPipelineBindPoint             pipelineBindPoint;
+    uint32_t                        inputAttachmentCount;
+    const VkAttachmentReference*    pInputAttachments;
+    uint32_t                        colorAttachmentCount;
+    const VkAttachmentReference*    pColorAttachments;
+    const VkAttachmentReference*    pResolveAttachments;
+    const VkAttachmentReference*    pDepthStencilAttachment;
+    uint32_t                        preserveAttachmentCount;
+    const uint32_t*                 pPreserveAttachments;
+} VkSubpassDescription;
+
+typedef struct VkSubpassDependency {
+    uint32_t                srcSubpass;
+    uint32_t                dstSubpass;
+    VkPipelineStageFlags    srcStageMask;
+    VkPipelineStageFlags    dstStageMask;
+    VkAccessFlags           srcAccessMask;
+    VkAccessFlags           dstAccessMask;
+    VkDependencyFlags       dependencyFlags;
+} VkSubpassDependency;
+
+typedef struct VkRenderPassCreateInfo {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkRenderPassCreateFlags           flags;
+    uint32_t                          attachmentCount;
+    const VkAttachmentDescription*    pAttachments;
+    uint32_t                          subpassCount;
+    const VkSubpassDescription*       pSubpasses;
+    uint32_t                          dependencyCount;
+    const VkSubpassDependency*        pDependencies;
+} VkRenderPassCreateInfo;
+
+typedef struct VkCommandPoolCreateInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkCommandPoolCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+} VkCommandPoolCreateInfo;
+
+typedef struct VkCommandBufferAllocateInfo {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkCommandPool           commandPool;
+    VkCommandBufferLevel    level;
+    uint32_t                commandBufferCount;
+} VkCommandBufferAllocateInfo;
+
+typedef struct VkCommandBufferInheritanceInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkRenderPass                     renderPass;
+    uint32_t                         subpass;
+    VkFramebuffer                    framebuffer;
+    VkBool32                         occlusionQueryEnable;
+    VkQueryControlFlags              queryFlags;
+    VkQueryPipelineStatisticFlags    pipelineStatistics;
+} VkCommandBufferInheritanceInfo;
+
+typedef struct VkCommandBufferBeginInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkCommandBufferUsageFlags                flags;
+    const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
+} VkCommandBufferBeginInfo;
+
+typedef struct VkBufferCopy {
+    VkDeviceSize    srcOffset;
+    VkDeviceSize    dstOffset;
+    VkDeviceSize    size;
+} VkBufferCopy;
+
+typedef struct VkImageSubresourceLayers {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              mipLevel;
+    uint32_t              baseArrayLayer;
+    uint32_t              layerCount;
+} VkImageSubresourceLayers;
+
+typedef struct VkImageCopy {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageCopy;
+
+typedef struct VkImageBlit {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffsets[2];
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffsets[2];
+} VkImageBlit;
+
+typedef struct VkBufferImageCopy {
+    VkDeviceSize                bufferOffset;
+    uint32_t                    bufferRowLength;
+    uint32_t                    bufferImageHeight;
+    VkImageSubresourceLayers    imageSubresource;
+    VkOffset3D                  imageOffset;
+    VkExtent3D                  imageExtent;
+} VkBufferImageCopy;
+
+typedef union VkClearColorValue {
+    float       float32[4];
+    int32_t     int32[4];
+    uint32_t    uint32[4];
+} VkClearColorValue;
+
+typedef struct VkClearDepthStencilValue {
+    float       depth;
+    uint32_t    stencil;
+} VkClearDepthStencilValue;
+
+typedef union VkClearValue {
+    VkClearColorValue           color;
+    VkClearDepthStencilValue    depthStencil;
+} VkClearValue;
+
+typedef struct VkClearAttachment {
+    VkImageAspectFlags    aspectMask;
+    uint32_t              colorAttachment;
+    VkClearValue          clearValue;
+} VkClearAttachment;
+
+typedef struct VkClearRect {
+    VkRect2D    rect;
+    uint32_t    baseArrayLayer;
+    uint32_t    layerCount;
+} VkClearRect;
+
+typedef struct VkImageResolve {
+    VkImageSubresourceLayers    srcSubresource;
+    VkOffset3D                  srcOffset;
+    VkImageSubresourceLayers    dstSubresource;
+    VkOffset3D                  dstOffset;
+    VkExtent3D                  extent;
+} VkImageResolve;
+
+typedef struct VkMemoryBarrier {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkAccessFlags      srcAccessMask;
+    VkAccessFlags      dstAccessMask;
+} VkMemoryBarrier;
+
+typedef struct VkBufferMemoryBarrier {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkAccessFlags      srcAccessMask;
+    VkAccessFlags      dstAccessMask;
+    uint32_t           srcQueueFamilyIndex;
+    uint32_t           dstQueueFamilyIndex;
+    VkBuffer           buffer;
+    VkDeviceSize       offset;
+    VkDeviceSize       size;
+} VkBufferMemoryBarrier;
+
+typedef struct VkImageMemoryBarrier {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkAccessFlags              srcAccessMask;
+    VkAccessFlags              dstAccessMask;
+    VkImageLayout              oldLayout;
+    VkImageLayout              newLayout;
+    uint32_t                   srcQueueFamilyIndex;
+    uint32_t                   dstQueueFamilyIndex;
+    VkImage                    image;
+    VkImageSubresourceRange    subresourceRange;
+} VkImageMemoryBarrier;
+
+typedef struct VkRenderPassBeginInfo {
+    VkStructureType        sType;
+    const void*            pNext;
+    VkRenderPass           renderPass;
+    VkFramebuffer          framebuffer;
+    VkRect2D               renderArea;
+    uint32_t               clearValueCount;
+    const VkClearValue*    pClearValues;
+} VkRenderPassBeginInfo;
+
+typedef struct VkDispatchIndirectCommand {
+    uint32_t    x;
+    uint32_t    y;
+    uint32_t    z;
+} VkDispatchIndirectCommand;
+
+typedef struct VkDrawIndexedIndirectCommand {
+    uint32_t    indexCount;
+    uint32_t    instanceCount;
+    uint32_t    firstIndex;
+    int32_t     vertexOffset;
+    uint32_t    firstInstance;
+} VkDrawIndexedIndirectCommand;
+
+typedef struct VkDrawIndirectCommand {
+    uint32_t    vertexCount;
+    uint32_t    instanceCount;
+    uint32_t    firstVertex;
+    uint32_t    firstInstance;
+} VkDrawIndirectCommand;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
+typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
+typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
+typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
+typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
+typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
+typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
+typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
+typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
+typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI_PTR *PFN_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);
+typedef void (VKAPI_PTR *PFN_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);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
+typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
+    const VkInstanceCreateInfo*                 pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkInstance*                                 pInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
+    VkInstance                                  instance,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceCount,
+    VkPhysicalDevice*                           pPhysicalDevices);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures*                   pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties*                         pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkImageTiling                               tiling,
+    VkImageUsageFlags                           usage,
+    VkImageCreateFlags                          flags,
+    VkImageFormatProperties*                    pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties*                 pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties*                    pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
+    VkInstance                                  instance,
+    const char*                                 pName);
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
+    VkDevice                                    device,
+    const char*                                 pName);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
+    VkPhysicalDevice                            physicalDevice,
+    const VkDeviceCreateInfo*                   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDevice*                                   pDevice);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
+    VkDevice                                    device,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
+    const char*                                 pLayerName,
+    uint32_t*                                   pPropertyCount,
+    VkExtensionProperties*                      pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const char*                                 pLayerName,
+    uint32_t*                                   pPropertyCount,
+    VkExtensionProperties*                      pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
+    uint32_t*                                   pPropertyCount,
+    VkLayerProperties*                          pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkLayerProperties*                          pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
+    VkDevice                                    device,
+    uint32_t                                    queueFamilyIndex,
+    uint32_t                                    queueIndex,
+    VkQueue*                                    pQueue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
+    VkQueue                                     queue,
+    uint32_t                                    submitCount,
+    const VkSubmitInfo*                         pSubmits,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
+    VkQueue                                     queue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
+    VkDevice                                    device);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
+    VkDevice                                    device,
+    const VkMemoryAllocateInfo*                 pAllocateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDeviceMemory*                             pMemory);
+
+VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                offset,
+    VkDeviceSize                                size,
+    VkMemoryMapFlags                            flags,
+    void**                                      ppData);
+
+VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
+    VkDevice                                    device,
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
+    VkDevice                                    device,
+    uint32_t                                    memoryRangeCount,
+    const VkMappedMemoryRange*                  pMemoryRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkDeviceSize*                               pCommittedMemoryInBytes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                memoryOffset);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
+    VkDevice                                    device,
+    VkImage                                     image,
+    VkDeviceMemory                              memory,
+    VkDeviceSize                                memoryOffset);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    VkMemoryRequirements*                       pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    VkMemoryRequirements*                       pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
+    VkDevice                                    device,
+    VkImage                                     image,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkSampleCountFlagBits                       samples,
+    VkImageUsageFlags                           usage,
+    VkImageTiling                               tiling,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties*              pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
+    VkQueue                                     queue,
+    uint32_t                                    bindInfoCount,
+    const VkBindSparseInfo*                     pBindInfo,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
+    VkDevice                                    device,
+    const VkFenceCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
+    VkDevice                                    device,
+    VkFence                                     fence,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
+    VkDevice                                    device,
+    uint32_t                                    fenceCount,
+    const VkFence*                              pFences);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
+    VkDevice                                    device,
+    VkFence                                     fence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
+    VkDevice                                    device,
+    uint32_t                                    fenceCount,
+    const VkFence*                              pFences,
+    VkBool32                                    waitAll,
+    uint64_t                                    timeout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
+    VkDevice                                    device,
+    const VkSemaphoreCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSemaphore*                                pSemaphore);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
+    VkDevice                                    device,
+    VkSemaphore                                 semaphore,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
+    VkDevice                                    device,
+    const VkEventCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkEvent*                                    pEvent);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
+    VkDevice                                    device,
+    VkEvent                                     event,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
+    VkDevice                                    device,
+    VkEvent                                     event);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
+    VkDevice                                    device,
+    const VkQueryPoolCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkQueryPool*                                pQueryPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
+    VkDevice                                    device,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount,
+    size_t                                      dataSize,
+    void*                                       pData,
+    VkDeviceSize                                stride,
+    VkQueryResultFlags                          flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
+    VkDevice                                    device,
+    const VkBufferCreateInfo*                   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBuffer*                                   pBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
+    VkDevice                                    device,
+    VkBuffer                                    buffer,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
+    VkDevice                                    device,
+    const VkBufferViewCreateInfo*               pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkBufferView*                               pView);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
+    VkDevice                                    device,
+    VkBufferView                                bufferView,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
+    VkDevice                                    device,
+    const VkImageCreateInfo*                    pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkImage*                                    pImage);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
+    VkDevice                                    device,
+    VkImage                                     image,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
+    VkDevice                                    device,
+    VkImage                                     image,
+    const VkImageSubresource*                   pSubresource,
+    VkSubresourceLayout*                        pLayout);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
+    VkDevice                                    device,
+    const VkImageViewCreateInfo*                pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkImageView*                                pView);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
+    VkDevice                                    device,
+    VkImageView                                 imageView,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
+    VkDevice                                    device,
+    const VkShaderModuleCreateInfo*             pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkShaderModule*                             pShaderModule);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
+    VkDevice                                    device,
+    VkShaderModule                              shaderModule,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
+    VkDevice                                    device,
+    const VkPipelineCacheCreateInfo*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipelineCache*                            pPipelineCache);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    size_t*                                     pDataSize,
+    void*                                       pData);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
+    VkDevice                                    device,
+    VkPipelineCache                             dstCache,
+    uint32_t                                    srcCacheCount,
+    const VkPipelineCache*                      pSrcCaches);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkGraphicsPipelineCreateInfo*         pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
+    VkDevice                                    device,
+    VkPipelineCache                             pipelineCache,
+    uint32_t                                    createInfoCount,
+    const VkComputePipelineCreateInfo*          pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipeline*                                 pPipelines);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
+    VkDevice                                    device,
+    const VkPipelineLayoutCreateInfo*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkPipelineLayout*                           pPipelineLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
+    VkDevice                                    device,
+    VkPipelineLayout                            pipelineLayout,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
+    VkDevice                                    device,
+    const VkSamplerCreateInfo*                  pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSampler*                                  pSampler);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
+    VkDevice                                    device,
+    VkSampler                                   sampler,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorSetLayout*                      pSetLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
+    VkDevice                                    device,
+    VkDescriptorSetLayout                       descriptorSetLayout,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
+    VkDevice                                    device,
+    const VkDescriptorPoolCreateInfo*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorPool*                           pDescriptorPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    VkDescriptorPoolResetFlags                  flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
+    VkDevice                                    device,
+    const VkDescriptorSetAllocateInfo*          pAllocateInfo,
+    VkDescriptorSet*                            pDescriptorSets);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
+    VkDevice                                    device,
+    VkDescriptorPool                            descriptorPool,
+    uint32_t                                    descriptorSetCount,
+    const VkDescriptorSet*                      pDescriptorSets);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
+    VkDevice                                    device,
+    uint32_t                                    descriptorWriteCount,
+    const VkWriteDescriptorSet*                 pDescriptorWrites,
+    uint32_t                                    descriptorCopyCount,
+    const VkCopyDescriptorSet*                  pDescriptorCopies);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
+    VkDevice                                    device,
+    const VkFramebufferCreateInfo*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFramebuffer*                              pFramebuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
+    VkDevice                                    device,
+    VkFramebuffer                               framebuffer,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
+    VkDevice                                    device,
+    const VkRenderPassCreateInfo*               pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkRenderPass*                               pRenderPass);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
+    VkDevice                                    device,
+    VkRenderPass                                renderPass,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
+    VkDevice                                    device,
+    VkRenderPass                                renderPass,
+    VkExtent2D*                                 pGranularity);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
+    VkDevice                                    device,
+    const VkCommandPoolCreateInfo*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkCommandPool*                              pCommandPool);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolResetFlags                     flags);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
+    VkDevice                                    device,
+    const VkCommandBufferAllocateInfo*          pAllocateInfo,
+    VkCommandBuffer*                            pCommandBuffers);
+
+VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    uint32_t                                    commandBufferCount,
+    const VkCommandBuffer*                      pCommandBuffers);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
+    VkCommandBuffer                             commandBuffer,
+    const VkCommandBufferBeginInfo*             pBeginInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkCommandBufferResetFlags                   flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipeline                                  pipeline);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkViewport*                           pViewports);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstScissor,
+    uint32_t                                    scissorCount,
+    const VkRect2D*                             pScissors);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
+    VkCommandBuffer                             commandBuffer,
+    float                                       lineWidth);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
+    VkCommandBuffer                             commandBuffer,
+    float                                       depthBiasConstantFactor,
+    float                                       depthBiasClamp,
+    float                                       depthBiasSlopeFactor);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
+    VkCommandBuffer                             commandBuffer,
+    const float                                 blendConstants[4]);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
+    VkCommandBuffer                             commandBuffer,
+    float                                       minDepthBounds,
+    float                                       maxDepthBounds);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    compareMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    writeMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
+    VkCommandBuffer                             commandBuffer,
+    VkStencilFaceFlags                          faceMask,
+    uint32_t                                    reference);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipelineLayout                            layout,
+    uint32_t                                    firstSet,
+    uint32_t                                    descriptorSetCount,
+    const VkDescriptorSet*                      pDescriptorSets,
+    uint32_t                                    dynamicOffsetCount,
+    const uint32_t*                             pDynamicOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkIndexType                                 indexType);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkDeviceSize*                         pOffsets);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    vertexCount,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstVertex,
+    uint32_t                                    firstInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    indexCount,
+    uint32_t                                    instanceCount,
+    uint32_t                                    firstIndex,
+    int32_t                                     vertexOffset,
+    uint32_t                                    firstInstance);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    uint32_t                                    drawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    srcBuffer,
+    VkBuffer                                    dstBuffer,
+    uint32_t                                    regionCount,
+    const VkBufferCopy*                         pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageCopy*                          pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageBlit*                          pRegions,
+    VkFilter                                    filter);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    srcBuffer,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkBufferImageCopy*                    pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkBuffer                                    dstBuffer,
+    uint32_t                                    regionCount,
+    const VkBufferImageCopy*                    pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                dataSize,
+    const void*                                 pData);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                size,
+    uint32_t                                    data);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     image,
+    VkImageLayout                               imageLayout,
+    const VkClearColorValue*                    pColor,
+    uint32_t                                    rangeCount,
+    const VkImageSubresourceRange*              pRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     image,
+    VkImageLayout                               imageLayout,
+    const VkClearDepthStencilValue*             pDepthStencil,
+    uint32_t                                    rangeCount,
+    const VkImageSubresourceRange*              pRanges);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    attachmentCount,
+    const VkClearAttachment*                    pAttachments,
+    uint32_t                                    rectCount,
+    const VkClearRect*                          pRects);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
+    VkCommandBuffer                             commandBuffer,
+    VkImage                                     srcImage,
+    VkImageLayout                               srcImageLayout,
+    VkImage                                     dstImage,
+    VkImageLayout                               dstImageLayout,
+    uint32_t                                    regionCount,
+    const VkImageResolve*                       pRegions);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    VkPipelineStageFlags                        stageMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
+    VkCommandBuffer                             commandBuffer,
+    VkEvent                                     event,
+    VkPipelineStageFlags                        stageMask);
+
+VKAPI_ATTR void VKAPI_CALL 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);
+
+VKAPI_ATTR void VKAPI_CALL 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);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query,
+    VkQueryControlFlags                         flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlagBits                     pipelineStage,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    query);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
+    VkCommandBuffer                             commandBuffer,
+    VkQueryPool                                 queryPool,
+    uint32_t                                    firstQuery,
+    uint32_t                                    queryCount,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    VkDeviceSize                                stride,
+    VkQueryResultFlags                          flags);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineLayout                            layout,
+    VkShaderStageFlags                          stageFlags,
+    uint32_t                                    offset,
+    uint32_t                                    size,
+    const void*                                 pValues);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
+    VkCommandBuffer                             commandBuffer,
+    const VkRenderPassBeginInfo*                pRenderPassBegin,
+    VkSubpassContents                           contents);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
+    VkCommandBuffer                             commandBuffer,
+    VkSubpassContents                           contents);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    commandBufferCount,
+    const VkCommandBuffer*                      pCommandBuffers);
+#endif
+
+#define VK_VERSION_1_1 1
+// Vulkan 1.1 version number
+#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0)// Patch version should always be set to 0
+
+
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)
+
+#define VK_MAX_DEVICE_GROUP_SIZE          32
+#define VK_LUID_SIZE                      8
+#define VK_QUEUE_FAMILY_EXTERNAL          (~0U-1)
+
+
+typedef enum VkPointClippingBehavior {
+    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
+    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
+    VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+    VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+    VK_POINT_CLIPPING_BEHAVIOR_BEGIN_RANGE = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,
+    VK_POINT_CLIPPING_BEHAVIOR_END_RANGE = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,
+    VK_POINT_CLIPPING_BEHAVIOR_RANGE_SIZE = (VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES + 1),
+    VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
+} VkPointClippingBehavior;
+
+typedef enum VkTessellationDomainOrigin {
+    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
+    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
+    VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_BEGIN_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_END_RANGE = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,
+    VK_TESSELLATION_DOMAIN_ORIGIN_RANGE_SIZE = (VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT + 1),
+    VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
+} VkTessellationDomainOrigin;
+
+typedef enum VkSamplerYcbcrModelConversion {
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_BEGIN_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_END_RANGE = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_RANGE_SIZE = (VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY + 1),
+    VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerYcbcrModelConversion;
+
+typedef enum VkSamplerYcbcrRange {
+    VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
+    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
+    VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+    VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+    VK_SAMPLER_YCBCR_RANGE_BEGIN_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
+    VK_SAMPLER_YCBCR_RANGE_END_RANGE = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
+    VK_SAMPLER_YCBCR_RANGE_RANGE_SIZE = (VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - VK_SAMPLER_YCBCR_RANGE_ITU_FULL + 1),
+    VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
+} VkSamplerYcbcrRange;
+
+typedef enum VkChromaLocation {
+    VK_CHROMA_LOCATION_COSITED_EVEN = 0,
+    VK_CHROMA_LOCATION_MIDPOINT = 1,
+    VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,
+    VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,
+    VK_CHROMA_LOCATION_BEGIN_RANGE = VK_CHROMA_LOCATION_COSITED_EVEN,
+    VK_CHROMA_LOCATION_END_RANGE = VK_CHROMA_LOCATION_MIDPOINT,
+    VK_CHROMA_LOCATION_RANGE_SIZE = (VK_CHROMA_LOCATION_MIDPOINT - VK_CHROMA_LOCATION_COSITED_EVEN + 1),
+    VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
+} VkChromaLocation;
+
+typedef enum VkDescriptorUpdateTemplateType {
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_END_RANGE = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET + 1),
+    VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkDescriptorUpdateTemplateType;
+
+
+typedef enum VkSubgroupFeatureFlagBits {
+    VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,
+    VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,
+    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,
+    VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,
+    VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,
+    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,
+    VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,
+    VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
+    VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,
+    VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSubgroupFeatureFlagBits;
+typedef VkFlags VkSubgroupFeatureFlags;
+
+typedef enum VkPeerMemoryFeatureFlagBits {
+    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,
+    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,
+    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,
+    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
+    VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,
+    VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,
+    VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,
+    VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,
+    VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkPeerMemoryFeatureFlagBits;
+typedef VkFlags VkPeerMemoryFeatureFlags;
+
+typedef enum VkMemoryAllocateFlagBits {
+    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
+    VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,
+    VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkMemoryAllocateFlagBits;
+typedef VkFlags VkMemoryAllocateFlags;
+typedef VkFlags VkCommandPoolTrimFlags;
+typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;
+
+typedef enum VkExternalMemoryHandleTypeFlagBits {
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBits;
+typedef VkFlags VkExternalMemoryHandleTypeFlags;
+
+typedef enum VkExternalMemoryFeatureFlagBits {
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBits;
+typedef VkFlags VkExternalMemoryFeatureFlags;
+
+typedef enum VkExternalFenceHandleTypeFlagBits {
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
+    VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalFenceHandleTypeFlagBits;
+typedef VkFlags VkExternalFenceHandleTypeFlags;
+
+typedef enum VkExternalFenceFeatureFlagBits {
+    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,
+    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalFenceFeatureFlagBits;
+typedef VkFlags VkExternalFenceFeatureFlags;
+
+typedef enum VkFenceImportFlagBits {
+    VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
+    VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,
+    VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkFenceImportFlagBits;
+typedef VkFlags VkFenceImportFlags;
+
+typedef enum VkSemaphoreImportFlagBits {
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
+    VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,
+    VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkSemaphoreImportFlagBits;
+typedef VkFlags VkSemaphoreImportFlags;
+
+typedef enum VkExternalSemaphoreHandleTypeFlagBits {
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
+    VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalSemaphoreHandleTypeFlagBits;
+typedef VkFlags VkExternalSemaphoreHandleTypeFlags;
+
+typedef enum VkExternalSemaphoreFeatureFlagBits {
+    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,
+    VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
+} VkExternalSemaphoreFeatureFlagBits;
+typedef VkFlags VkExternalSemaphoreFeatureFlags;
+
+typedef struct VkPhysicalDeviceSubgroupProperties {
+    VkStructureType           sType;
+    void*                     pNext;
+    uint32_t                  subgroupSize;
+    VkShaderStageFlags        supportedStages;
+    VkSubgroupFeatureFlags    supportedOperations;
+    VkBool32                  quadOperationsInAllStages;
+} VkPhysicalDeviceSubgroupProperties;
+
+typedef struct VkBindBufferMemoryInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           buffer;
+    VkDeviceMemory     memory;
+    VkDeviceSize       memoryOffset;
+} VkBindBufferMemoryInfo;
+
+typedef struct VkBindImageMemoryInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkDeviceMemory     memory;
+    VkDeviceSize       memoryOffset;
+} VkBindImageMemoryInfo;
+
+typedef struct VkPhysicalDevice16BitStorageFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           storageBuffer16BitAccess;
+    VkBool32           uniformAndStorageBuffer16BitAccess;
+    VkBool32           storagePushConstant16;
+    VkBool32           storageInputOutput16;
+} VkPhysicalDevice16BitStorageFeatures;
+
+typedef struct VkMemoryDedicatedRequirements {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           prefersDedicatedAllocation;
+    VkBool32           requiresDedicatedAllocation;
+} VkMemoryDedicatedRequirements;
+
+typedef struct VkMemoryDedicatedAllocateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkBuffer           buffer;
+} VkMemoryDedicatedAllocateInfo;
+
+typedef struct VkMemoryAllocateFlagsInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkMemoryAllocateFlags    flags;
+    uint32_t                 deviceMask;
+} VkMemoryAllocateFlagsInfo;
+
+typedef struct VkDeviceGroupRenderPassBeginInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceMask;
+    uint32_t           deviceRenderAreaCount;
+    const VkRect2D*    pDeviceRenderAreas;
+} VkDeviceGroupRenderPassBeginInfo;
+
+typedef struct VkDeviceGroupCommandBufferBeginInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceMask;
+} VkDeviceGroupCommandBufferBeginInfo;
+
+typedef struct VkDeviceGroupSubmitInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreCount;
+    const uint32_t*    pWaitSemaphoreDeviceIndices;
+    uint32_t           commandBufferCount;
+    const uint32_t*    pCommandBufferDeviceMasks;
+    uint32_t           signalSemaphoreCount;
+    const uint32_t*    pSignalSemaphoreDeviceIndices;
+} VkDeviceGroupSubmitInfo;
+
+typedef struct VkDeviceGroupBindSparseInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           resourceDeviceIndex;
+    uint32_t           memoryDeviceIndex;
+} VkDeviceGroupBindSparseInfo;
+
+typedef struct VkBindBufferMemoryDeviceGroupInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceIndexCount;
+    const uint32_t*    pDeviceIndices;
+} VkBindBufferMemoryDeviceGroupInfo;
+
+typedef struct VkBindImageMemoryDeviceGroupInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           deviceIndexCount;
+    const uint32_t*    pDeviceIndices;
+    uint32_t           splitInstanceBindRegionCount;
+    const VkRect2D*    pSplitInstanceBindRegions;
+} VkBindImageMemoryDeviceGroupInfo;
+
+typedef struct VkPhysicalDeviceGroupProperties {
+    VkStructureType     sType;
+    void*               pNext;
+    uint32_t            physicalDeviceCount;
+    VkPhysicalDevice    physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    VkBool32            subsetAllocation;
+} VkPhysicalDeviceGroupProperties;
+
+typedef struct VkDeviceGroupDeviceCreateInfo {
+    VkStructureType            sType;
+    const void*                pNext;
+    uint32_t                   physicalDeviceCount;
+    const VkPhysicalDevice*    pPhysicalDevices;
+} VkDeviceGroupDeviceCreateInfo;
+
+typedef struct VkBufferMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBuffer           buffer;
+} VkBufferMemoryRequirementsInfo2;
+
+typedef struct VkImageMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+} VkImageMemoryRequirementsInfo2;
+
+typedef struct VkImageSparseMemoryRequirementsInfo2 {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+} VkImageSparseMemoryRequirementsInfo2;
+
+typedef struct VkMemoryRequirements2 {
+    VkStructureType         sType;
+    void*                   pNext;
+    VkMemoryRequirements    memoryRequirements;
+} VkMemoryRequirements2;
+
+typedef struct VkSparseImageMemoryRequirements2 {
+    VkStructureType                    sType;
+    void*                              pNext;
+    VkSparseImageMemoryRequirements    memoryRequirements;
+} VkSparseImageMemoryRequirements2;
+
+typedef struct VkPhysicalDeviceFeatures2 {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkPhysicalDeviceFeatures    features;
+} VkPhysicalDeviceFeatures2;
+
+typedef struct VkPhysicalDeviceProperties2 {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkPhysicalDeviceProperties    properties;
+} VkPhysicalDeviceProperties2;
+
+typedef struct VkFormatProperties2 {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkFormatProperties    formatProperties;
+} VkFormatProperties2;
+
+typedef struct VkImageFormatProperties2 {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkImageFormatProperties    imageFormatProperties;
+} VkImageFormatProperties2;
+
+typedef struct VkPhysicalDeviceImageFormatInfo2 {
+    VkStructureType       sType;
+    const void*           pNext;
+    VkFormat              format;
+    VkImageType           type;
+    VkImageTiling         tiling;
+    VkImageUsageFlags     usage;
+    VkImageCreateFlags    flags;
+} VkPhysicalDeviceImageFormatInfo2;
+
+typedef struct VkQueueFamilyProperties2 {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkQueueFamilyProperties    queueFamilyProperties;
+} VkQueueFamilyProperties2;
+
+typedef struct VkPhysicalDeviceMemoryProperties2 {
+    VkStructureType                     sType;
+    void*                               pNext;
+    VkPhysicalDeviceMemoryProperties    memoryProperties;
+} VkPhysicalDeviceMemoryProperties2;
+
+typedef struct VkSparseImageFormatProperties2 {
+    VkStructureType                  sType;
+    void*                            pNext;
+    VkSparseImageFormatProperties    properties;
+} VkSparseImageFormatProperties2;
+
+typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkFormat                 format;
+    VkImageType              type;
+    VkSampleCountFlagBits    samples;
+    VkImageUsageFlags        usage;
+    VkImageTiling            tiling;
+} VkPhysicalDeviceSparseImageFormatInfo2;
+
+typedef struct VkPhysicalDevicePointClippingProperties {
+    VkStructureType            sType;
+    void*                      pNext;
+    VkPointClippingBehavior    pointClippingBehavior;
+} VkPhysicalDevicePointClippingProperties;
+
+typedef struct VkInputAttachmentAspectReference {
+    uint32_t              subpass;
+    uint32_t              inputAttachmentIndex;
+    VkImageAspectFlags    aspectMask;
+} VkInputAttachmentAspectReference;
+
+typedef struct VkRenderPassInputAttachmentAspectCreateInfo {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    uint32_t                                   aspectReferenceCount;
+    const VkInputAttachmentAspectReference*    pAspectReferences;
+} VkRenderPassInputAttachmentAspectCreateInfo;
+
+typedef struct VkImageViewUsageCreateInfo {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkImageUsageFlags    usage;
+} VkImageViewUsageCreateInfo;
+
+typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkTessellationDomainOrigin    domainOrigin;
+} VkPipelineTessellationDomainOriginStateCreateInfo;
+
+typedef struct VkRenderPassMultiviewCreateInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           subpassCount;
+    const uint32_t*    pViewMasks;
+    uint32_t           dependencyCount;
+    const int32_t*     pViewOffsets;
+    uint32_t           correlationMaskCount;
+    const uint32_t*    pCorrelationMasks;
+} VkRenderPassMultiviewCreateInfo;
+
+typedef struct VkPhysicalDeviceMultiviewFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           multiview;
+    VkBool32           multiviewGeometryShader;
+    VkBool32           multiviewTessellationShader;
+} VkPhysicalDeviceMultiviewFeatures;
+
+typedef struct VkPhysicalDeviceMultiviewProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxMultiviewViewCount;
+    uint32_t           maxMultiviewInstanceIndex;
+} VkPhysicalDeviceMultiviewProperties;
+
+typedef struct VkPhysicalDeviceVariablePointerFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           variablePointersStorageBuffer;
+    VkBool32           variablePointers;
+} VkPhysicalDeviceVariablePointerFeatures;
+
+typedef struct VkPhysicalDeviceProtectedMemoryFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           protectedMemory;
+} VkPhysicalDeviceProtectedMemoryFeatures;
+
+typedef struct VkPhysicalDeviceProtectedMemoryProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           protectedNoFault;
+} VkPhysicalDeviceProtectedMemoryProperties;
+
+typedef struct VkDeviceQueueInfo2 {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkDeviceQueueCreateFlags    flags;
+    uint32_t                    queueFamilyIndex;
+    uint32_t                    queueIndex;
+} VkDeviceQueueInfo2;
+
+typedef struct VkProtectedSubmitInfo {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           protectedSubmit;
+} VkProtectedSubmitInfo;
+
+typedef struct VkSamplerYcbcrConversionCreateInfo {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkFormat                         format;
+    VkSamplerYcbcrModelConversion    ycbcrModel;
+    VkSamplerYcbcrRange              ycbcrRange;
+    VkComponentMapping               components;
+    VkChromaLocation                 xChromaOffset;
+    VkChromaLocation                 yChromaOffset;
+    VkFilter                         chromaFilter;
+    VkBool32                         forceExplicitReconstruction;
+} VkSamplerYcbcrConversionCreateInfo;
+
+typedef struct VkSamplerYcbcrConversionInfo {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSamplerYcbcrConversion    conversion;
+} VkSamplerYcbcrConversionInfo;
+
+typedef struct VkBindImagePlaneMemoryInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    planeAspect;
+} VkBindImagePlaneMemoryInfo;
+
+typedef struct VkImagePlaneMemoryRequirementsInfo {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkImageAspectFlagBits    planeAspect;
+} VkImagePlaneMemoryRequirementsInfo;
+
+typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           samplerYcbcrConversion;
+} VkPhysicalDeviceSamplerYcbcrConversionFeatures;
+
+typedef struct VkSamplerYcbcrConversionImageFormatProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           combinedImageSamplerDescriptorCount;
+} VkSamplerYcbcrConversionImageFormatProperties;
+
+typedef struct VkDescriptorUpdateTemplateEntry {
+    uint32_t            dstBinding;
+    uint32_t            dstArrayElement;
+    uint32_t            descriptorCount;
+    VkDescriptorType    descriptorType;
+    size_t              offset;
+    size_t              stride;
+} VkDescriptorUpdateTemplateEntry;
+
+typedef struct VkDescriptorUpdateTemplateCreateInfo {
+    VkStructureType                           sType;
+    void*                                     pNext;
+    VkDescriptorUpdateTemplateCreateFlags     flags;
+    uint32_t                                  descriptorUpdateEntryCount;
+    const VkDescriptorUpdateTemplateEntry*    pDescriptorUpdateEntries;
+    VkDescriptorUpdateTemplateType            templateType;
+    VkDescriptorSetLayout                     descriptorSetLayout;
+    VkPipelineBindPoint                       pipelineBindPoint;
+    VkPipelineLayout                          pipelineLayout;
+    uint32_t                                  set;
+} VkDescriptorUpdateTemplateCreateInfo;
+
+typedef struct VkExternalMemoryProperties {
+    VkExternalMemoryFeatureFlags       externalMemoryFeatures;
+    VkExternalMemoryHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalMemoryHandleTypeFlags    compatibleHandleTypes;
+} VkExternalMemoryProperties;
+
+typedef struct VkPhysicalDeviceExternalImageFormatInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalImageFormatInfo;
+
+typedef struct VkExternalImageFormatProperties {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkExternalMemoryProperties    externalMemoryProperties;
+} VkExternalImageFormatProperties;
+
+typedef struct VkPhysicalDeviceExternalBufferInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkBufferCreateFlags                   flags;
+    VkBufferUsageFlags                    usage;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalBufferInfo;
+
+typedef struct VkExternalBufferProperties {
+    VkStructureType               sType;
+    void*                         pNext;
+    VkExternalMemoryProperties    externalMemoryProperties;
+} VkExternalBufferProperties;
+
+typedef struct VkPhysicalDeviceIDProperties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint8_t            deviceUUID[VK_UUID_SIZE];
+    uint8_t            driverUUID[VK_UUID_SIZE];
+    uint8_t            deviceLUID[VK_LUID_SIZE];
+    uint32_t           deviceNodeMask;
+    VkBool32           deviceLUIDValid;
+} VkPhysicalDeviceIDProperties;
+
+typedef struct VkExternalMemoryImageCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExternalMemoryImageCreateInfo;
+
+typedef struct VkExternalMemoryBufferCreateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExternalMemoryBufferCreateInfo;
+
+typedef struct VkExportMemoryAllocateInfo {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkExternalMemoryHandleTypeFlags    handleTypes;
+} VkExportMemoryAllocateInfo;
+
+typedef struct VkPhysicalDeviceExternalFenceInfo {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalFenceInfo;
+
+typedef struct VkExternalFenceProperties {
+    VkStructureType                   sType;
+    void*                             pNext;
+    VkExternalFenceHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalFenceHandleTypeFlags    compatibleHandleTypes;
+    VkExternalFenceFeatureFlags       externalFenceFeatures;
+} VkExternalFenceProperties;
+
+typedef struct VkExportFenceCreateInfo {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkExternalFenceHandleTypeFlags    handleTypes;
+} VkExportFenceCreateInfo;
+
+typedef struct VkExportSemaphoreCreateInfo {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalSemaphoreHandleTypeFlags    handleTypes;
+} VkExportSemaphoreCreateInfo;
+
+typedef struct VkPhysicalDeviceExternalSemaphoreInfo {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkPhysicalDeviceExternalSemaphoreInfo;
+
+typedef struct VkExternalSemaphoreProperties {
+    VkStructureType                       sType;
+    void*                                 pNext;
+    VkExternalSemaphoreHandleTypeFlags    exportFromImportedHandleTypes;
+    VkExternalSemaphoreHandleTypeFlags    compatibleHandleTypes;
+    VkExternalSemaphoreFeatureFlags       externalSemaphoreFeatures;
+} VkExternalSemaphoreProperties;
+
+typedef struct VkPhysicalDeviceMaintenance3Properties {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxPerSetDescriptors;
+    VkDeviceSize       maxMemoryAllocationSize;
+} VkPhysicalDeviceMaintenance3Properties;
+
+typedef struct VkDescriptorSetLayoutSupport {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           supported;
+} VkDescriptorSetLayoutSupport;
+
+typedef struct VkPhysicalDeviceShaderDrawParameterFeatures {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderDrawParameters;
+} VkPhysicalDeviceShaderDrawParameterFeatures;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
+typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(
+    uint32_t*                                   pApiVersion);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindBufferMemoryInfo*               pBindInfos);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindImageMemoryInfo*                pBindInfos);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(
+    VkDevice                                    device,
+    uint32_t                                    heapIndex,
+    uint32_t                                    localDeviceIndex,
+    uint32_t                                    remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    deviceMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    baseGroupX,
+    uint32_t                                    baseGroupY,
+    uint32_t                                    baseGroupZ,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(
+    VkDevice                                    device,
+    const VkImageMemoryRequirementsInfo2*       pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(
+    VkDevice                                    device,
+    const VkBufferMemoryRequirementsInfo2*      pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(
+    VkDevice                                    device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures2*                  pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties2*                pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties2*                        pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
+    VkImageFormatProperties2*                   pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2*                   pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties2*             pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolTrimFlags                      flags);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(
+    VkDevice                                    device,
+    const VkDeviceQueueInfo2*                   pQueueInfo,
+    VkQueue*                                    pQueue);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(
+    VkDevice                                    device,
+    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSamplerYcbcrConversion*                   pYcbcrConversion);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(
+    VkDevice                                    device,
+    VkSamplerYcbcrConversion                    ycbcrConversion,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(
+    VkDevice                                    device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(
+    VkDevice                                    device,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(
+    VkDevice                                    device,
+    VkDescriptorSet                             descriptorSet,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const void*                                 pData);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
+    VkExternalBufferProperties*                 pExternalBufferProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
+    VkExternalFenceProperties*                  pExternalFenceProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    VkDescriptorSetLayoutSupport*               pSupport);
+#endif
+
+#define VK_KHR_surface 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
+
+#define VK_KHR_SURFACE_SPEC_VERSION       25
+#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"
+#define VK_COLORSPACE_SRGB_NONLINEAR_KHR  VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
+
+
+typedef enum VkColorSpaceKHR {
+    VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,
+    VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,
+    VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,
+    VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = 1000104003,
+    VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,
+    VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,
+    VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,
+    VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,
+    VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,
+    VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,
+    VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,
+    VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,
+    VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,
+    VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,
+    VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,
+    VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
+    VK_COLOR_SPACE_RANGE_SIZE_KHR = (VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1),
+    VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkColorSpaceKHR;
+
+typedef enum VkPresentModeKHR {
+    VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
+    VK_PRESENT_MODE_MAILBOX_KHR = 1,
+    VK_PRESENT_MODE_FIFO_KHR = 2,
+    VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
+    VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,
+    VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,
+    VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR,
+    VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
+    VK_PRESENT_MODE_RANGE_SIZE_KHR = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
+    VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkPresentModeKHR;
+
+
+typedef enum VkSurfaceTransformFlagBitsKHR {
+    VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
+    VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
+    VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
+    VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
+    VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
+    VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
+    VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSurfaceTransformFlagBitsKHR;
+typedef VkFlags VkSurfaceTransformFlagsKHR;
+
+typedef enum VkCompositeAlphaFlagBitsKHR {
+    VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+    VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
+    VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
+    VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
+    VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkCompositeAlphaFlagBitsKHR;
+typedef VkFlags VkCompositeAlphaFlagsKHR;
+
+typedef struct VkSurfaceCapabilitiesKHR {
+    uint32_t                         minImageCount;
+    uint32_t                         maxImageCount;
+    VkExtent2D                       currentExtent;
+    VkExtent2D                       minImageExtent;
+    VkExtent2D                       maxImageExtent;
+    uint32_t                         maxImageArrayLayers;
+    VkSurfaceTransformFlagsKHR       supportedTransforms;
+    VkSurfaceTransformFlagBitsKHR    currentTransform;
+    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
+    VkImageUsageFlags                supportedUsageFlags;
+} VkSurfaceCapabilitiesKHR;
+
+typedef struct VkSurfaceFormatKHR {
+    VkFormat           format;
+    VkColorSpaceKHR    colorSpace;
+} VkSurfaceFormatKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
+    VkInstance                                  instance,
+    VkSurfaceKHR                                surface,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    VkSurfaceKHR                                surface,
+    VkBool32*                                   pSupported);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pSurfaceFormatCount,
+    VkSurfaceFormatKHR*                         pSurfaceFormats);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pPresentModeCount,
+    VkPresentModeKHR*                           pPresentModes);
+#endif
+
+#define VK_KHR_swapchain 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
+
+#define VK_KHR_SWAPCHAIN_SPEC_VERSION     70
+#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"
+
+
+typedef enum VkSwapchainCreateFlagBitsKHR {
+    VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,
+    VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,
+    VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkSwapchainCreateFlagBitsKHR;
+typedef VkFlags VkSwapchainCreateFlagsKHR;
+
+typedef enum VkDeviceGroupPresentModeFlagBitsKHR {
+    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,
+    VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,
+    VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,
+    VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,
+    VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkDeviceGroupPresentModeFlagBitsKHR;
+typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;
+
+typedef struct VkSwapchainCreateInfoKHR {
+    VkStructureType                  sType;
+    const void*                      pNext;
+    VkSwapchainCreateFlagsKHR        flags;
+    VkSurfaceKHR                     surface;
+    uint32_t                         minImageCount;
+    VkFormat                         imageFormat;
+    VkColorSpaceKHR                  imageColorSpace;
+    VkExtent2D                       imageExtent;
+    uint32_t                         imageArrayLayers;
+    VkImageUsageFlags                imageUsage;
+    VkSharingMode                    imageSharingMode;
+    uint32_t                         queueFamilyIndexCount;
+    const uint32_t*                  pQueueFamilyIndices;
+    VkSurfaceTransformFlagBitsKHR    preTransform;
+    VkCompositeAlphaFlagBitsKHR      compositeAlpha;
+    VkPresentModeKHR                 presentMode;
+    VkBool32                         clipped;
+    VkSwapchainKHR                   oldSwapchain;
+} VkSwapchainCreateInfoKHR;
+
+typedef struct VkPresentInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 waitSemaphoreCount;
+    const VkSemaphore*       pWaitSemaphores;
+    uint32_t                 swapchainCount;
+    const VkSwapchainKHR*    pSwapchains;
+    const uint32_t*          pImageIndices;
+    VkResult*                pResults;
+} VkPresentInfoKHR;
+
+typedef struct VkImageSwapchainCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+} VkImageSwapchainCreateInfoKHR;
+
+typedef struct VkBindImageMemorySwapchainInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+    uint32_t           imageIndex;
+} VkBindImageMemorySwapchainInfoKHR;
+
+typedef struct VkAcquireNextImageInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSwapchainKHR     swapchain;
+    uint64_t           timeout;
+    VkSemaphore        semaphore;
+    VkFence            fence;
+    uint32_t           deviceMask;
+} VkAcquireNextImageInfoKHR;
+
+typedef struct VkDeviceGroupPresentCapabilitiesKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    uint32_t                            presentMask[VK_MAX_DEVICE_GROUP_SIZE];
+    VkDeviceGroupPresentModeFlagsKHR    modes;
+} VkDeviceGroupPresentCapabilitiesKHR;
+
+typedef struct VkDeviceGroupPresentInfoKHR {
+    VkStructureType                        sType;
+    const void*                            pNext;
+    uint32_t                               swapchainCount;
+    const uint32_t*                        pDeviceMasks;
+    VkDeviceGroupPresentModeFlagBitsKHR    mode;
+} VkDeviceGroupPresentInfoKHR;
+
+typedef struct VkDeviceGroupSwapchainCreateInfoKHR {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkDeviceGroupPresentModeFlagsKHR    modes;
+} VkDeviceGroupSwapchainCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
+typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
+    VkDevice                                    device,
+    const VkSwapchainCreateInfoKHR*             pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSwapchainKHR*                             pSwapchain);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint32_t*                                   pSwapchainImageCount,
+    VkImage*                                    pSwapchainImages);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint64_t                                    timeout,
+    VkSemaphore                                 semaphore,
+    VkFence                                     fence,
+    uint32_t*                                   pImageIndex);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
+    VkQueue                                     queue,
+    const VkPresentInfoKHR*                     pPresentInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(
+    VkDevice                                    device,
+    VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(
+    VkDevice                                    device,
+    VkSurfaceKHR                                surface,
+    VkDeviceGroupPresentModeFlagsKHR*           pModes);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    uint32_t*                                   pRectCount,
+    VkRect2D*                                   pRects);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(
+    VkDevice                                    device,
+    const VkAcquireNextImageInfoKHR*            pAcquireInfo,
+    uint32_t*                                   pImageIndex);
+#endif
+
+#define VK_KHR_display 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
+
+#define VK_KHR_DISPLAY_SPEC_VERSION       21
+#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"
+
+
+typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
+    VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
+    VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
+    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
+    VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
+    VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkDisplayPlaneAlphaFlagBitsKHR;
+typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
+typedef VkFlags VkDisplayModeCreateFlagsKHR;
+typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
+
+typedef struct VkDisplayPropertiesKHR {
+    VkDisplayKHR                  display;
+    const char*                   displayName;
+    VkExtent2D                    physicalDimensions;
+    VkExtent2D                    physicalResolution;
+    VkSurfaceTransformFlagsKHR    supportedTransforms;
+    VkBool32                      planeReorderPossible;
+    VkBool32                      persistentContent;
+} VkDisplayPropertiesKHR;
+
+typedef struct VkDisplayModeParametersKHR {
+    VkExtent2D    visibleRegion;
+    uint32_t      refreshRate;
+} VkDisplayModeParametersKHR;
+
+typedef struct VkDisplayModePropertiesKHR {
+    VkDisplayModeKHR              displayMode;
+    VkDisplayModeParametersKHR    parameters;
+} VkDisplayModePropertiesKHR;
+
+typedef struct VkDisplayModeCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkDisplayModeCreateFlagsKHR    flags;
+    VkDisplayModeParametersKHR     parameters;
+} VkDisplayModeCreateInfoKHR;
+
+typedef struct VkDisplayPlaneCapabilitiesKHR {
+    VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
+    VkOffset2D                     minSrcPosition;
+    VkOffset2D                     maxSrcPosition;
+    VkExtent2D                     minSrcExtent;
+    VkExtent2D                     maxSrcExtent;
+    VkOffset2D                     minDstPosition;
+    VkOffset2D                     maxDstPosition;
+    VkExtent2D                     minDstExtent;
+    VkExtent2D                     maxDstExtent;
+} VkDisplayPlaneCapabilitiesKHR;
+
+typedef struct VkDisplayPlanePropertiesKHR {
+    VkDisplayKHR    currentDisplay;
+    uint32_t        currentStackIndex;
+} VkDisplayPlanePropertiesKHR;
+
+typedef struct VkDisplaySurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkDisplaySurfaceCreateFlagsKHR    flags;
+    VkDisplayModeKHR                  displayMode;
+    uint32_t                          planeIndex;
+    uint32_t                          planeStackIndex;
+    VkSurfaceTransformFlagBitsKHR     transform;
+    float                             globalAlpha;
+    VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
+    VkExtent2D                        imageExtent;
+} VkDisplaySurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPropertiesKHR*                     pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayPlanePropertiesKHR*                pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    planeIndex,
+    uint32_t*                                   pDisplayCount,
+    VkDisplayKHR*                               pDisplays);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    uint32_t*                                   pPropertyCount,
+    VkDisplayModePropertiesKHR*                 pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display,
+    const VkDisplayModeCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDisplayModeKHR*                           pMode);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayModeKHR                            mode,
+    uint32_t                                    planeIndex,
+    VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
+    VkInstance                                  instance,
+    const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#define VK_KHR_display_swapchain 1
+#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
+#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"
+
+typedef struct VkDisplayPresentInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkRect2D           srcRect;
+    VkRect2D           dstRect;
+    VkBool32           persistent;
+} VkDisplayPresentInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
+    VkDevice                                    device,
+    uint32_t                                    swapchainCount,
+    const VkSwapchainCreateInfoKHR*             pCreateInfos,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSwapchainKHR*                             pSwapchains);
+#endif
+
+#define VK_KHR_sampler_mirror_clamp_to_edge 1
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"
+
+
+#define VK_KHR_multiview 1
+#define VK_KHR_MULTIVIEW_SPEC_VERSION     1
+#define VK_KHR_MULTIVIEW_EXTENSION_NAME   "VK_KHR_multiview"
+
+typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
+
+typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
+
+typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
+
+
+
+#define VK_KHR_get_physical_device_properties2 1
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"
+
+typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
+
+typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
+
+typedef VkFormatProperties2 VkFormatProperties2KHR;
+
+typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
+
+typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
+
+typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
+
+typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
+
+typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
+
+typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceFeatures2*                  pFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceProperties2*                pProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkFormatProperties2*                        pFormatProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
+    VkImageFormatProperties2*                   pImageFormatProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t*                                   pQueueFamilyPropertyCount,
+    VkQueueFamilyProperties2*                   pQueueFamilyProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
+    uint32_t*                                   pPropertyCount,
+    VkSparseImageFormatProperties2*             pProperties);
+#endif
+
+#define VK_KHR_device_group 1
+#define VK_KHR_DEVICE_GROUP_SPEC_VERSION  3
+#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"
+
+typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
+
+typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
+
+typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
+
+typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
+
+
+typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
+
+typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
+
+typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
+
+typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
+
+typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
+
+typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
+
+typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);
+typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);
+typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice                                    device,
+    uint32_t                                    heapIndex,
+    uint32_t                                    localDeviceIndex,
+    uint32_t                                    remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    deviceMask);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    baseGroupX,
+    uint32_t                                    baseGroupY,
+    uint32_t                                    baseGroupZ,
+    uint32_t                                    groupCountX,
+    uint32_t                                    groupCountY,
+    uint32_t                                    groupCountZ);
+#endif
+
+#define VK_KHR_shader_draw_parameters 1
+#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1
+#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"
+
+
+#define VK_KHR_maintenance1 1
+#define VK_KHR_MAINTENANCE1_SPEC_VERSION  2
+#define VK_KHR_MAINTENANCE1_EXTENSION_NAME "VK_KHR_maintenance1"
+
+typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(
+    VkDevice                                    device,
+    VkCommandPool                               commandPool,
+    VkCommandPoolTrimFlags                      flags);
+#endif
+
+#define VK_KHR_device_group_creation 1
+#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1
+#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"
+#define VK_MAX_DEVICE_GROUP_SIZE_KHR      VK_MAX_DEVICE_GROUP_SIZE
+
+typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
+
+typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(
+    VkInstance                                  instance,
+    uint32_t*                                   pPhysicalDeviceGroupCount,
+    VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
+#endif
+
+#define VK_KHR_external_memory_capabilities 1
+#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"
+#define VK_LUID_SIZE_KHR                  VK_LUID_SIZE
+
+typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
+
+typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
+
+typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
+
+typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
+
+
+typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
+
+typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
+
+typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
+
+typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
+
+typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
+
+typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
+    VkExternalBufferProperties*                 pExternalBufferProperties);
+#endif
+
+#define VK_KHR_external_memory 1
+#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"
+#define VK_QUEUE_FAMILY_EXTERNAL_KHR      VK_QUEUE_FAMILY_EXTERNAL
+
+typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
+
+typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
+
+typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
+
+
+
+#define VK_KHR_external_memory_fd 1
+#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"
+
+typedef struct VkImportMemoryFdInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    int                                   fd;
+} VkImportMemoryFdInfoKHR;
+
+typedef struct VkMemoryFdPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryFdPropertiesKHR;
+
+typedef struct VkMemoryGetFdInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetFdInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(
+    VkDevice                                    device,
+    const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
+    int*                                        pFd);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    int                                         fd,
+    VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
+#endif
+
+#define VK_KHR_external_semaphore_capabilities 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"
+
+typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
+
+typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
+
+typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
+
+typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
+
+
+typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
+
+typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
+    VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
+#endif
+
+#define VK_KHR_external_semaphore 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"
+
+typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
+
+typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
+
+
+typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_fd 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"
+
+typedef struct VkImportSemaphoreFdInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    int                                      fd;
+} VkImportSemaphoreFdInfoKHR;
+
+typedef struct VkSemaphoreGetFdInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetFdInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
+    int*                                        pFd);
+#endif
+
+#define VK_KHR_push_descriptor 1
+#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2
+#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"
+
+typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxPushDescriptors;
+} VkPhysicalDevicePushDescriptorPropertiesKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);
+typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineBindPoint                         pipelineBindPoint,
+    VkPipelineLayout                            layout,
+    uint32_t                                    set,
+    uint32_t                                    descriptorWriteCount,
+    const VkWriteDescriptorSet*                 pDescriptorWrites);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(
+    VkCommandBuffer                             commandBuffer,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    VkPipelineLayout                            layout,
+    uint32_t                                    set,
+    const void*                                 pData);
+#endif
+
+#define VK_KHR_16bit_storage 1
+#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1
+#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"
+
+typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
+
+
+
+#define VK_KHR_incremental_present 1
+#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 1
+#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"
+
+typedef struct VkRectLayerKHR {
+    VkOffset2D    offset;
+    VkExtent2D    extent;
+    uint32_t      layer;
+} VkRectLayerKHR;
+
+typedef struct VkPresentRegionKHR {
+    uint32_t                 rectangleCount;
+    const VkRectLayerKHR*    pRectangles;
+} VkPresentRegionKHR;
+
+typedef struct VkPresentRegionsKHR {
+    VkStructureType              sType;
+    const void*                  pNext;
+    uint32_t                     swapchainCount;
+    const VkPresentRegionKHR*    pRegions;
+} VkPresentRegionsKHR;
+
+
+
+#define VK_KHR_descriptor_update_template 1
+typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;
+
+
+#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1
+#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"
+
+typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
+
+
+typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
+
+
+typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
+
+typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);
+typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(
+    VkDevice                                    device,
+    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(
+    VkDevice                                    device,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(
+    VkDevice                                    device,
+    VkDescriptorSet                             descriptorSet,
+    VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
+    const void*                                 pData);
+#endif
+
+#define VK_KHR_shared_presentable_image 1
+#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
+#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
+
+typedef struct VkSharedPresentSurfaceCapabilitiesKHR {
+    VkStructureType      sType;
+    void*                pNext;
+    VkImageUsageFlags    sharedPresentSupportedUsageFlags;
+} VkSharedPresentSurfaceCapabilitiesKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain);
+#endif
+
+#define VK_KHR_external_fence_capabilities 1
+#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"
+
+typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
+
+typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
+
+typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
+
+typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
+
+
+typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
+
+typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
+    VkExternalFenceProperties*                  pExternalFenceProperties);
+#endif
+
+#define VK_KHR_external_fence 1
+#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"
+
+typedef VkFenceImportFlags VkFenceImportFlagsKHR;
+
+typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
+
+
+typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
+
+
+
+#define VK_KHR_external_fence_fd 1
+#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"
+
+typedef struct VkImportFenceFdInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    int                                  fd;
+} VkImportFenceFdInfoKHR;
+
+typedef struct VkFenceGetFdInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetFdInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(
+    VkDevice                                    device,
+    const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(
+    VkDevice                                    device,
+    const VkFenceGetFdInfoKHR*                  pGetFdInfo,
+    int*                                        pFd);
+#endif
+
+#define VK_KHR_maintenance2 1
+#define VK_KHR_MAINTENANCE2_SPEC_VERSION  1
+#define VK_KHR_MAINTENANCE2_EXTENSION_NAME "VK_KHR_maintenance2"
+
+typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;
+
+typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
+
+
+typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
+
+typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
+
+typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
+
+typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
+
+typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
+
+
+
+#define VK_KHR_get_surface_capabilities2 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1
+#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"
+
+typedef struct VkPhysicalDeviceSurfaceInfo2KHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkSurfaceKHR       surface;
+} VkPhysicalDeviceSurfaceInfo2KHR;
+
+typedef struct VkSurfaceCapabilities2KHR {
+    VkStructureType             sType;
+    void*                       pNext;
+    VkSurfaceCapabilitiesKHR    surfaceCapabilities;
+} VkSurfaceCapabilities2KHR;
+
+typedef struct VkSurfaceFormat2KHR {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkSurfaceFormatKHR    surfaceFormat;
+} VkSurfaceFormat2KHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(
+    VkPhysicalDevice                            physicalDevice,
+    const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
+    uint32_t*                                   pSurfaceFormatCount,
+    VkSurfaceFormat2KHR*                        pSurfaceFormats);
+#endif
+
+#define VK_KHR_variable_pointers 1
+#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1
+#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"
+
+typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
+
+
+
+#define VK_KHR_dedicated_allocation 1
+#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3
+#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"
+
+typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
+
+typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
+
+
+
+#define VK_KHR_storage_buffer_storage_class 1
+#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1
+#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"
+
+
+#define VK_KHR_relaxed_block_layout 1
+#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1
+#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"
+
+
+#define VK_KHR_get_memory_requirements2 1
+#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1
+#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"
+
+typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
+
+typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
+
+typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
+
+typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
+
+typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);
+typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkImageMemoryRequirementsInfo2*       pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkBufferMemoryRequirementsInfo2*      pInfo,
+    VkMemoryRequirements2*                      pMemoryRequirements);
+
+VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(
+    VkDevice                                    device,
+    const VkImageSparseMemoryRequirementsInfo2* pInfo,
+    uint32_t*                                   pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
+#endif
+
+#define VK_KHR_image_format_list 1
+#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1
+#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"
+
+typedef struct VkImageFormatListCreateInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           viewFormatCount;
+    const VkFormat*    pViewFormats;
+} VkImageFormatListCreateInfoKHR;
+
+
+
+#define VK_KHR_sampler_ycbcr_conversion 1
+typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;
+
+
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 1
+#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
+
+typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
+
+typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
+
+typedef VkChromaLocation VkChromaLocationKHR;
+
+
+typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
+
+typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
+
+typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
+
+typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
+
+typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
+
+typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);
+typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(
+    VkDevice                                    device,
+    const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSamplerYcbcrConversion*                   pYcbcrConversion);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(
+    VkDevice                                    device,
+    VkSamplerYcbcrConversion                    ycbcrConversion,
+    const VkAllocationCallbacks*                pAllocator);
+#endif
+
+#define VK_KHR_bind_memory2 1
+#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1
+#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"
+
+typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
+
+typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);
+typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindBufferMemoryInfo*               pBindInfos);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(
+    VkDevice                                    device,
+    uint32_t                                    bindInfoCount,
+    const VkBindImageMemoryInfo*                pBindInfos);
+#endif
+
+#define VK_KHR_maintenance3 1
+#define VK_KHR_MAINTENANCE3_SPEC_VERSION  1
+#define VK_KHR_MAINTENANCE3_EXTENSION_NAME "VK_KHR_maintenance3"
+
+typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
+
+typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
+
+
+typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(
+    VkDevice                                    device,
+    const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
+    VkDescriptorSetLayoutSupport*               pSupport);
+#endif
+
+#define VK_EXT_debug_report 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)
+
+#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  9
+#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"
+#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
+#define VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT
+
+
+typedef enum VkDebugReportObjectTypeEXT {
+    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
+    VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
+    VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
+    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
+    VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
+    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
+    VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
+    VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
+    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
+    VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
+    VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
+    VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
+    VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,
+    VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT = 31,
+    VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT = 32,
+    VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,
+    VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,
+    VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = (VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1),
+    VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugReportObjectTypeEXT;
+
+
+typedef enum VkDebugReportFlagBitsEXT {
+    VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
+    VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
+    VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
+    VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
+    VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
+    VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugReportFlagBitsEXT;
+typedef VkFlags VkDebugReportFlagsEXT;
+
+typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
+    VkDebugReportFlagsEXT                       flags,
+    VkDebugReportObjectTypeEXT                  objectType,
+    uint64_t                                    object,
+    size_t                                      location,
+    int32_t                                     messageCode,
+    const char*                                 pLayerPrefix,
+    const char*                                 pMessage,
+    void*                                       pUserData);
+
+typedef struct VkDebugReportCallbackCreateInfoEXT {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkDebugReportFlagsEXT           flags;
+    PFN_vkDebugReportCallbackEXT    pfnCallback;
+    void*                           pUserData;
+} VkDebugReportCallbackCreateInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
+typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
+    VkInstance                                  instance,
+    const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDebugReportCallbackEXT*                   pCallback);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
+    VkInstance                                  instance,
+    VkDebugReportCallbackEXT                    callback,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
+    VkInstance                                  instance,
+    VkDebugReportFlagsEXT                       flags,
+    VkDebugReportObjectTypeEXT                  objectType,
+    uint64_t                                    object,
+    size_t                                      location,
+    int32_t                                     messageCode,
+    const char*                                 pLayerPrefix,
+    const char*                                 pMessage);
+#endif
+
+#define VK_NV_glsl_shader 1
+#define VK_NV_GLSL_SHADER_SPEC_VERSION    1
+#define VK_NV_GLSL_SHADER_EXTENSION_NAME  "VK_NV_glsl_shader"
+
+
+#define VK_EXT_depth_range_unrestricted 1
+#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1
+#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"
+
+
+#define VK_IMG_filter_cubic 1
+#define VK_IMG_FILTER_CUBIC_SPEC_VERSION  1
+#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"
+
+
+#define VK_AMD_rasterization_order 1
+#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1
+#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"
+
+
+typedef enum VkRasterizationOrderAMD {
+    VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
+    VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,
+    VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD,
+    VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD,
+    VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1),
+    VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkRasterizationOrderAMD;
+
+typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {
+    VkStructureType            sType;
+    const void*                pNext;
+    VkRasterizationOrderAMD    rasterizationOrder;
+} VkPipelineRasterizationStateRasterizationOrderAMD;
+
+
+
+#define VK_AMD_shader_trinary_minmax 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1
+#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"
+
+
+#define VK_AMD_shader_explicit_vertex_parameter 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1
+#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"
+
+
+#define VK_EXT_debug_marker 1
+#define VK_EXT_DEBUG_MARKER_SPEC_VERSION  4
+#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"
+
+typedef struct VkDebugMarkerObjectNameInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    const char*                   pObjectName;
+} VkDebugMarkerObjectNameInfoEXT;
+
+typedef struct VkDebugMarkerObjectTagInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkDebugReportObjectTypeEXT    objectType;
+    uint64_t                      object;
+    uint64_t                      tagName;
+    size_t                        tagSize;
+    const void*                   pTag;
+} VkDebugMarkerObjectTagInfoEXT;
+
+typedef struct VkDebugMarkerMarkerInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pMarkerName;
+    float              color[4];
+} VkDebugMarkerMarkerInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(
+    VkDevice                                    device,
+    const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(
+    VkDevice                                    device,
+    const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
+#endif
+
+#define VK_AMD_gcn_shader 1
+#define VK_AMD_GCN_SHADER_SPEC_VERSION    1
+#define VK_AMD_GCN_SHADER_EXTENSION_NAME  "VK_AMD_gcn_shader"
+
+
+#define VK_NV_dedicated_allocation 1
+#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1
+#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"
+
+typedef struct VkDedicatedAllocationImageCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationImageCreateInfoNV;
+
+typedef struct VkDedicatedAllocationBufferCreateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           dedicatedAllocation;
+} VkDedicatedAllocationBufferCreateInfoNV;
+
+typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkImage            image;
+    VkBuffer           buffer;
+} VkDedicatedAllocationMemoryAllocateInfoNV;
+
+
+
+#define VK_AMD_draw_indirect_count 1
+#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 1
+#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"
+
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkBuffer                                    buffer,
+    VkDeviceSize                                offset,
+    VkBuffer                                    countBuffer,
+    VkDeviceSize                                countBufferOffset,
+    uint32_t                                    maxDrawCount,
+    uint32_t                                    stride);
+#endif
+
+#define VK_AMD_negative_viewport_height 1
+#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1
+#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"
+
+
+#define VK_AMD_gpu_shader_half_float 1
+#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 1
+#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"
+
+
+#define VK_AMD_shader_ballot 1
+#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1
+#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"
+
+
+#define VK_AMD_texture_gather_bias_lod 1
+#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1
+#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"
+
+typedef struct VkTextureLODGatherFormatPropertiesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           supportsTextureGatherLODBiasAMD;
+} VkTextureLODGatherFormatPropertiesAMD;
+
+
+
+#define VK_AMD_shader_info 1
+#define VK_AMD_SHADER_INFO_SPEC_VERSION   1
+#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"
+
+
+typedef enum VkShaderInfoTypeAMD {
+    VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,
+    VK_SHADER_INFO_TYPE_BINARY_AMD = 1,
+    VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,
+    VK_SHADER_INFO_TYPE_BEGIN_RANGE_AMD = VK_SHADER_INFO_TYPE_STATISTICS_AMD,
+    VK_SHADER_INFO_TYPE_END_RANGE_AMD = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD,
+    VK_SHADER_INFO_TYPE_RANGE_SIZE_AMD = (VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - VK_SHADER_INFO_TYPE_STATISTICS_AMD + 1),
+    VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF
+} VkShaderInfoTypeAMD;
+
+typedef struct VkShaderResourceUsageAMD {
+    uint32_t    numUsedVgprs;
+    uint32_t    numUsedSgprs;
+    uint32_t    ldsSizePerLocalWorkGroup;
+    size_t      ldsUsageSizeInBytes;
+    size_t      scratchMemUsageInBytes;
+} VkShaderResourceUsageAMD;
+
+typedef struct VkShaderStatisticsInfoAMD {
+    VkShaderStageFlags          shaderStageMask;
+    VkShaderResourceUsageAMD    resourceUsage;
+    uint32_t                    numPhysicalVgprs;
+    uint32_t                    numPhysicalSgprs;
+    uint32_t                    numAvailableVgprs;
+    uint32_t                    numAvailableSgprs;
+    uint32_t                    computeWorkGroupSize[3];
+} VkShaderStatisticsInfoAMD;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(
+    VkDevice                                    device,
+    VkPipeline                                  pipeline,
+    VkShaderStageFlagBits                       shaderStage,
+    VkShaderInfoTypeAMD                         infoType,
+    size_t*                                     pInfoSize,
+    void*                                       pInfo);
+#endif
+
+#define VK_AMD_shader_image_load_store_lod 1
+#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1
+#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"
+
+
+#define VK_IMG_format_pvrtc 1
+#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION  1
+#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"
+
+
+#define VK_NV_external_memory_capabilities 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"
+
+
+typedef enum VkExternalMemoryHandleTypeFlagBitsNV {
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,
+    VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryHandleTypeFlagBitsNV;
+typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
+
+typedef enum VkExternalMemoryFeatureFlagBitsNV {
+    VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,
+    VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,
+    VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,
+    VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF
+} VkExternalMemoryFeatureFlagBitsNV;
+typedef VkFlags VkExternalMemoryFeatureFlagsNV;
+
+typedef struct VkExternalImageFormatPropertiesNV {
+    VkImageFormatProperties              imageFormatProperties;
+    VkExternalMemoryFeatureFlagsNV       externalMemoryFeatures;
+    VkExternalMemoryHandleTypeFlagsNV    exportFromImportedHandleTypes;
+    VkExternalMemoryHandleTypeFlagsNV    compatibleHandleTypes;
+} VkExternalImageFormatPropertiesNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
+    VkPhysicalDevice                            physicalDevice,
+    VkFormat                                    format,
+    VkImageType                                 type,
+    VkImageTiling                               tiling,
+    VkImageUsageFlags                           usage,
+    VkImageCreateFlags                          flags,
+    VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
+    VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
+#endif
+
+#define VK_NV_external_memory 1
+#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"
+
+typedef struct VkExternalMemoryImageCreateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExternalMemoryImageCreateInfoNV;
+
+typedef struct VkExportMemoryAllocateInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleTypes;
+} VkExportMemoryAllocateInfoNV;
+
+
+
+#define VK_EXT_validation_flags 1
+#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"
+
+
+typedef enum VkValidationCheckEXT {
+    VK_VALIDATION_CHECK_ALL_EXT = 0,
+    VK_VALIDATION_CHECK_SHADERS_EXT = 1,
+    VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT,
+    VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_SHADERS_EXT,
+    VK_VALIDATION_CHECK_RANGE_SIZE_EXT = (VK_VALIDATION_CHECK_SHADERS_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1),
+    VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationCheckEXT;
+
+typedef struct VkValidationFlagsEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 disabledValidationCheckCount;
+    VkValidationCheckEXT*    pDisabledValidationChecks;
+} VkValidationFlagsEXT;
+
+
+
+#define VK_EXT_shader_subgroup_ballot 1
+#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1
+#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"
+
+
+#define VK_EXT_shader_subgroup_vote 1
+#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1
+#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"
+
+
+#define VK_NVX_device_generated_commands 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkObjectTableNVX)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNVX)
+
+#define VK_NVX_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3
+#define VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NVX_device_generated_commands"
+
+
+typedef enum VkIndirectCommandsTokenTypeNVX {
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX = 0,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DESCRIPTOR_SET_NVX = 1,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NVX = 2,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NVX = 3,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NVX = 4,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NVX = 5,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NVX = 6,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX = 7,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_BEGIN_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_END_RANGE_NVX = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX,
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_RANGE_SIZE_NVX = (VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NVX - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NVX + 1),
+    VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
+} VkIndirectCommandsTokenTypeNVX;
+
+typedef enum VkObjectEntryTypeNVX {
+    VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX = 0,
+    VK_OBJECT_ENTRY_TYPE_PIPELINE_NVX = 1,
+    VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX = 2,
+    VK_OBJECT_ENTRY_TYPE_VERTEX_BUFFER_NVX = 3,
+    VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX = 4,
+    VK_OBJECT_ENTRY_TYPE_BEGIN_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX,
+    VK_OBJECT_ENTRY_TYPE_END_RANGE_NVX = VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX,
+    VK_OBJECT_ENTRY_TYPE_RANGE_SIZE_NVX = (VK_OBJECT_ENTRY_TYPE_PUSH_CONSTANT_NVX - VK_OBJECT_ENTRY_TYPE_DESCRIPTOR_SET_NVX + 1),
+    VK_OBJECT_ENTRY_TYPE_MAX_ENUM_NVX = 0x7FFFFFFF
+} VkObjectEntryTypeNVX;
+
+
+typedef enum VkIndirectCommandsLayoutUsageFlagBitsNVX {
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX = 0x00000001,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX = 0x00000002,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX = 0x00000004,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX = 0x00000008,
+    VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
+} VkIndirectCommandsLayoutUsageFlagBitsNVX;
+typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNVX;
+
+typedef enum VkObjectEntryUsageFlagBitsNVX {
+    VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX = 0x00000001,
+    VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX = 0x00000002,
+    VK_OBJECT_ENTRY_USAGE_FLAG_BITS_MAX_ENUM_NVX = 0x7FFFFFFF
+} VkObjectEntryUsageFlagBitsNVX;
+typedef VkFlags VkObjectEntryUsageFlagsNVX;
+
+typedef struct VkDeviceGeneratedCommandsFeaturesNVX {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkBool32           computeBindingPointSupport;
+} VkDeviceGeneratedCommandsFeaturesNVX;
+
+typedef struct VkDeviceGeneratedCommandsLimitsNVX {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           maxIndirectCommandsLayoutTokenCount;
+    uint32_t           maxObjectEntryCounts;
+    uint32_t           minSequenceCountBufferOffsetAlignment;
+    uint32_t           minSequenceIndexBufferOffsetAlignment;
+    uint32_t           minCommandsTokenBufferOffsetAlignment;
+} VkDeviceGeneratedCommandsLimitsNVX;
+
+typedef struct VkIndirectCommandsTokenNVX {
+    VkIndirectCommandsTokenTypeNVX    tokenType;
+    VkBuffer                          buffer;
+    VkDeviceSize                      offset;
+} VkIndirectCommandsTokenNVX;
+
+typedef struct VkIndirectCommandsLayoutTokenNVX {
+    VkIndirectCommandsTokenTypeNVX    tokenType;
+    uint32_t                          bindingUnit;
+    uint32_t                          dynamicCount;
+    uint32_t                          divisor;
+} VkIndirectCommandsLayoutTokenNVX;
+
+typedef struct VkIndirectCommandsLayoutCreateInfoNVX {
+    VkStructureType                            sType;
+    const void*                                pNext;
+    VkPipelineBindPoint                        pipelineBindPoint;
+    VkIndirectCommandsLayoutUsageFlagsNVX      flags;
+    uint32_t                                   tokenCount;
+    const VkIndirectCommandsLayoutTokenNVX*    pTokens;
+} VkIndirectCommandsLayoutCreateInfoNVX;
+
+typedef struct VkCmdProcessCommandsInfoNVX {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkObjectTableNVX                     objectTable;
+    VkIndirectCommandsLayoutNVX          indirectCommandsLayout;
+    uint32_t                             indirectCommandsTokenCount;
+    const VkIndirectCommandsTokenNVX*    pIndirectCommandsTokens;
+    uint32_t                             maxSequencesCount;
+    VkCommandBuffer                      targetCommandBuffer;
+    VkBuffer                             sequencesCountBuffer;
+    VkDeviceSize                         sequencesCountOffset;
+    VkBuffer                             sequencesIndexBuffer;
+    VkDeviceSize                         sequencesIndexOffset;
+} VkCmdProcessCommandsInfoNVX;
+
+typedef struct VkCmdReserveSpaceForCommandsInfoNVX {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkObjectTableNVX               objectTable;
+    VkIndirectCommandsLayoutNVX    indirectCommandsLayout;
+    uint32_t                       maxSequencesCount;
+} VkCmdReserveSpaceForCommandsInfoNVX;
+
+typedef struct VkObjectTableCreateInfoNVX {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    uint32_t                             objectCount;
+    const VkObjectEntryTypeNVX*          pObjectEntryTypes;
+    const uint32_t*                      pObjectEntryCounts;
+    const VkObjectEntryUsageFlagsNVX*    pObjectEntryUsageFlags;
+    uint32_t                             maxUniformBuffersPerDescriptor;
+    uint32_t                             maxStorageBuffersPerDescriptor;
+    uint32_t                             maxStorageImagesPerDescriptor;
+    uint32_t                             maxSampledImagesPerDescriptor;
+    uint32_t                             maxPipelineLayouts;
+} VkObjectTableCreateInfoNVX;
+
+typedef struct VkObjectTableEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+} VkObjectTableEntryNVX;
+
+typedef struct VkObjectTablePipelineEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+    VkPipeline                    pipeline;
+} VkObjectTablePipelineEntryNVX;
+
+typedef struct VkObjectTableDescriptorSetEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+    VkPipelineLayout              pipelineLayout;
+    VkDescriptorSet               descriptorSet;
+} VkObjectTableDescriptorSetEntryNVX;
+
+typedef struct VkObjectTableVertexBufferEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+    VkBuffer                      buffer;
+} VkObjectTableVertexBufferEntryNVX;
+
+typedef struct VkObjectTableIndexBufferEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+    VkBuffer                      buffer;
+    VkIndexType                   indexType;
+} VkObjectTableIndexBufferEntryNVX;
+
+typedef struct VkObjectTablePushConstantEntryNVX {
+    VkObjectEntryTypeNVX          type;
+    VkObjectEntryUsageFlagsNVX    flags;
+    VkPipelineLayout              pipelineLayout;
+    VkShaderStageFlags            stageFlags;
+} VkObjectTablePushConstantEntryNVX;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdProcessCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdReserveSpaceForCommandsNVX)(VkCommandBuffer commandBuffer, const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNVX)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
+typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNVX)(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateObjectTableNVX)(VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkObjectTableNVX* pObjectTable);
+typedef void (VKAPI_PTR *PFN_vkDestroyObjectTableNVX)(VkDevice device, VkObjectTableNVX objectTable, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkRegisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectTableEntryNVX* const*    ppObjectTableEntries, const uint32_t* pObjectIndices);
+typedef VkResult (VKAPI_PTR *PFN_vkUnregisterObjectsNVX)(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, const VkObjectEntryTypeNVX* pObjectEntryTypes, const uint32_t* pObjectIndices);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX)(VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX* pFeatures, VkDeviceGeneratedCommandsLimitsNVX* pLimits);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(
+    VkCommandBuffer                             commandBuffer,
+    const VkCmdProcessCommandsInfoNVX*          pProcessCommandsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(
+    VkCommandBuffer                             commandBuffer,
+    const VkCmdReserveSpaceForCommandsInfoNVX*  pReserveSpaceInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(
+    VkDevice                                    device,
+    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkIndirectCommandsLayoutNVX*                pIndirectCommandsLayout);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice                                    device,
+    VkIndirectCommandsLayoutNVX                 indirectCommandsLayout,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(
+    VkDevice                                    device,
+    const VkObjectTableCreateInfoNVX*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkObjectTableNVX*                           pObjectTable);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(
+    VkDevice                                    device,
+    VkObjectTableNVX                            objectTable,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(
+    VkDevice                                    device,
+    VkObjectTableNVX                            objectTable,
+    uint32_t                                    objectCount,
+    const VkObjectTableEntryNVX* const*         ppObjectTableEntries,
+    const uint32_t*                             pObjectIndices);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(
+    VkDevice                                    device,
+    VkObjectTableNVX                            objectTable,
+    uint32_t                                    objectCount,
+    const VkObjectEntryTypeNVX*                 pObjectEntryTypes,
+    const uint32_t*                             pObjectIndices);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
+    VkPhysicalDevice                            physicalDevice,
+    VkDeviceGeneratedCommandsFeaturesNVX*       pFeatures,
+    VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
+#endif
+
+#define VK_NV_clip_space_w_scaling 1
+#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1
+#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"
+
+typedef struct VkViewportWScalingNV {
+    float    xcoeff;
+    float    ycoeff;
+} VkViewportWScalingNV;
+
+typedef struct VkPipelineViewportWScalingStateCreateInfoNV {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkBool32                       viewportWScalingEnable;
+    uint32_t                       viewportCount;
+    const VkViewportWScalingNV*    pViewportWScalings;
+} VkPipelineViewportWScalingStateCreateInfoNV;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstViewport,
+    uint32_t                                    viewportCount,
+    const VkViewportWScalingNV*                 pViewportWScalings);
+#endif
+
+#define VK_EXT_direct_mode_display 1
+#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"
+
+typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkDisplayKHR                                display);
+#endif
+
+#define VK_EXT_display_surface_counter 1
+#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1
+#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"
+#define VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT
+
+
+typedef enum VkSurfaceCounterFlagBitsEXT {
+    VK_SURFACE_COUNTER_VBLANK_EXT = 0x00000001,
+    VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkSurfaceCounterFlagBitsEXT;
+typedef VkFlags VkSurfaceCounterFlagsEXT;
+
+typedef struct VkSurfaceCapabilities2EXT {
+    VkStructureType                  sType;
+    void*                            pNext;
+    uint32_t                         minImageCount;
+    uint32_t                         maxImageCount;
+    VkExtent2D                       currentExtent;
+    VkExtent2D                       minImageExtent;
+    VkExtent2D                       maxImageExtent;
+    uint32_t                         maxImageArrayLayers;
+    VkSurfaceTransformFlagsKHR       supportedTransforms;
+    VkSurfaceTransformFlagBitsKHR    currentTransform;
+    VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
+    VkImageUsageFlags                supportedUsageFlags;
+    VkSurfaceCounterFlagsEXT         supportedSurfaceCounters;
+} VkSurfaceCapabilities2EXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkSurfaceKHR                                surface,
+    VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
+#endif
+
+#define VK_EXT_display_control 1
+#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1
+#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"
+
+
+typedef enum VkDisplayPowerStateEXT {
+    VK_DISPLAY_POWER_STATE_OFF_EXT = 0,
+    VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,
+    VK_DISPLAY_POWER_STATE_ON_EXT = 2,
+    VK_DISPLAY_POWER_STATE_BEGIN_RANGE_EXT = VK_DISPLAY_POWER_STATE_OFF_EXT,
+    VK_DISPLAY_POWER_STATE_END_RANGE_EXT = VK_DISPLAY_POWER_STATE_ON_EXT,
+    VK_DISPLAY_POWER_STATE_RANGE_SIZE_EXT = (VK_DISPLAY_POWER_STATE_ON_EXT - VK_DISPLAY_POWER_STATE_OFF_EXT + 1),
+    VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDisplayPowerStateEXT;
+
+typedef enum VkDeviceEventTypeEXT {
+    VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,
+    VK_DEVICE_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
+    VK_DEVICE_EVENT_TYPE_END_RANGE_EXT = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT,
+    VK_DEVICE_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + 1),
+    VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDeviceEventTypeEXT;
+
+typedef enum VkDisplayEventTypeEXT {
+    VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,
+    VK_DISPLAY_EVENT_TYPE_BEGIN_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
+    VK_DISPLAY_EVENT_TYPE_END_RANGE_EXT = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT,
+    VK_DISPLAY_EVENT_TYPE_RANGE_SIZE_EXT = (VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + 1),
+    VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDisplayEventTypeEXT;
+
+typedef struct VkDisplayPowerInfoEXT {
+    VkStructureType           sType;
+    const void*               pNext;
+    VkDisplayPowerStateEXT    powerState;
+} VkDisplayPowerInfoEXT;
+
+typedef struct VkDeviceEventInfoEXT {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkDeviceEventTypeEXT    deviceEvent;
+} VkDeviceEventInfoEXT;
+
+typedef struct VkDisplayEventInfoEXT {
+    VkStructureType          sType;
+    const void*              pNext;
+    VkDisplayEventTypeEXT    displayEvent;
+} VkDisplayEventInfoEXT;
+
+typedef struct VkSwapchainCounterCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkSurfaceCounterFlagsEXT    surfaceCounters;
+} VkSwapchainCounterCreateInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(
+    VkDevice                                    device,
+    VkDisplayKHR                                display,
+    const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(
+    VkDevice                                    device,
+    const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(
+    VkDevice                                    device,
+    VkDisplayKHR                                display,
+    const VkDisplayEventInfoEXT*                pDisplayEventInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkFence*                                    pFence);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    VkSurfaceCounterFlagBitsEXT                 counter,
+    uint64_t*                                   pCounterValue);
+#endif
+
+#define VK_GOOGLE_display_timing 1
+#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1
+#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"
+
+typedef struct VkRefreshCycleDurationGOOGLE {
+    uint64_t    refreshDuration;
+} VkRefreshCycleDurationGOOGLE;
+
+typedef struct VkPastPresentationTimingGOOGLE {
+    uint32_t    presentID;
+    uint64_t    desiredPresentTime;
+    uint64_t    actualPresentTime;
+    uint64_t    earliestPresentTime;
+    uint64_t    presentMargin;
+} VkPastPresentationTimingGOOGLE;
+
+typedef struct VkPresentTimeGOOGLE {
+    uint32_t    presentID;
+    uint64_t    desiredPresentTime;
+} VkPresentTimeGOOGLE;
+
+typedef struct VkPresentTimesInfoGOOGLE {
+    VkStructureType               sType;
+    const void*                   pNext;
+    uint32_t                      swapchainCount;
+    const VkPresentTimeGOOGLE*    pTimes;
+} VkPresentTimesInfoGOOGLE;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
+typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(
+    VkDevice                                    device,
+    VkSwapchainKHR                              swapchain,
+    uint32_t*                                   pPresentationTimingCount,
+    VkPastPresentationTimingGOOGLE*             pPresentationTimings);
+#endif
+
+#define VK_NV_sample_mask_override_coverage 1
+#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1
+#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"
+
+
+#define VK_NV_geometry_shader_passthrough 1
+#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1
+#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"
+
+
+#define VK_NV_viewport_array2 1
+#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION 1
+#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME "VK_NV_viewport_array2"
+
+
+#define VK_NVX_multiview_per_view_attributes 1
+#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1
+#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"
+
+typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           perViewPositionAllComponents;
+} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
+
+
+
+#define VK_NV_viewport_swizzle 1
+#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1
+#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"
+
+
+typedef enum VkViewportCoordinateSwizzleNV {
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_BEGIN_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_END_RANGE_NV = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV,
+    VK_VIEWPORT_COORDINATE_SWIZZLE_RANGE_SIZE_NV = (VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV + 1),
+    VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkViewportCoordinateSwizzleNV;
+
+typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;
+
+typedef struct VkViewportSwizzleNV {
+    VkViewportCoordinateSwizzleNV    x;
+    VkViewportCoordinateSwizzleNV    y;
+    VkViewportCoordinateSwizzleNV    z;
+    VkViewportCoordinateSwizzleNV    w;
+} VkViewportSwizzleNV;
+
+typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkPipelineViewportSwizzleStateCreateFlagsNV    flags;
+    uint32_t                                       viewportCount;
+    const VkViewportSwizzleNV*                     pViewportSwizzles;
+} VkPipelineViewportSwizzleStateCreateInfoNV;
+
+
+
+#define VK_EXT_discard_rectangles 1
+#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1
+#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"
+
+
+typedef enum VkDiscardRectangleModeEXT {
+    VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,
+    VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,
+    VK_DISCARD_RECTANGLE_MODE_BEGIN_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT,
+    VK_DISCARD_RECTANGLE_MODE_END_RANGE_EXT = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT,
+    VK_DISCARD_RECTANGLE_MODE_RANGE_SIZE_EXT = (VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT + 1),
+    VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDiscardRectangleModeEXT;
+
+typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;
+
+typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxDiscardRectangles;
+} VkPhysicalDeviceDiscardRectanglePropertiesEXT;
+
+typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {
+    VkStructureType                                  sType;
+    const void*                                      pNext;
+    VkPipelineDiscardRectangleStateCreateFlagsEXT    flags;
+    VkDiscardRectangleModeEXT                        discardRectangleMode;
+    uint32_t                                         discardRectangleCount;
+    const VkRect2D*                                  pDiscardRectangles;
+} VkPipelineDiscardRectangleStateCreateInfoEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    firstDiscardRectangle,
+    uint32_t                                    discardRectangleCount,
+    const VkRect2D*                             pDiscardRectangles);
+#endif
+
+#define VK_EXT_conservative_rasterization 1
+#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1
+#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"
+
+
+typedef enum VkConservativeRasterizationModeEXT {
+    VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_BEGIN_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_END_RANGE_EXT = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT,
+    VK_CONSERVATIVE_RASTERIZATION_MODE_RANGE_SIZE_EXT = (VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT + 1),
+    VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkConservativeRasterizationModeEXT;
+
+typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;
+
+typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    float              primitiveOverestimationSize;
+    float              maxExtraPrimitiveOverestimationSize;
+    float              extraPrimitiveOverestimationSizeGranularity;
+    VkBool32           primitiveUnderestimation;
+    VkBool32           conservativePointAndLineRasterization;
+    VkBool32           degenerateTrianglesRasterized;
+    VkBool32           degenerateLinesRasterized;
+    VkBool32           fullyCoveredFragmentShaderInputVariable;
+    VkBool32           conservativeRasterizationPostDepthCoverage;
+} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
+
+typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
+    VkStructureType                                           sType;
+    const void*                                               pNext;
+    VkPipelineRasterizationConservativeStateCreateFlagsEXT    flags;
+    VkConservativeRasterizationModeEXT                        conservativeRasterizationMode;
+    float                                                     extraPrimitiveOverestimationSize;
+} VkPipelineRasterizationConservativeStateCreateInfoEXT;
+
+
+
+#define VK_EXT_swapchain_colorspace 1
+#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 3
+#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"
+
+
+#define VK_EXT_hdr_metadata 1
+#define VK_EXT_HDR_METADATA_SPEC_VERSION  1
+#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
+
+typedef struct VkXYColorEXT {
+    float    x;
+    float    y;
+} VkXYColorEXT;
+
+typedef struct VkHdrMetadataEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkXYColorEXT       displayPrimaryRed;
+    VkXYColorEXT       displayPrimaryGreen;
+    VkXYColorEXT       displayPrimaryBlue;
+    VkXYColorEXT       whitePoint;
+    float              maxLuminance;
+    float              minLuminance;
+    float              maxContentLightLevel;
+    float              maxFrameAverageLightLevel;
+} VkHdrMetadataEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
+    VkDevice                                    device,
+    uint32_t                                    swapchainCount,
+    const VkSwapchainKHR*                       pSwapchains,
+    const VkHdrMetadataEXT*                     pMetadata);
+#endif
+
+#define VK_EXT_external_memory_dma_buf 1
+#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"
+
+
+#define VK_EXT_queue_family_foreign 1
+#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1
+#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"
+#define VK_QUEUE_FAMILY_FOREIGN_EXT       (~0U-2)
+
+
+#define VK_EXT_debug_utils 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)
+
+#define VK_EXT_DEBUG_UTILS_SPEC_VERSION   1
+#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"
+
+typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;
+typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;
+
+typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,
+    VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugUtilsMessageSeverityFlagBitsEXT;
+typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;
+
+typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {
+    VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,
+    VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDebugUtilsMessageTypeFlagBitsEXT;
+typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;
+
+typedef struct VkDebugUtilsObjectNameInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkObjectType       objectType;
+    uint64_t           objectHandle;
+    const char*        pObjectName;
+} VkDebugUtilsObjectNameInfoEXT;
+
+typedef struct VkDebugUtilsObjectTagInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkObjectType       objectType;
+    uint64_t           objectHandle;
+    uint64_t           tagName;
+    size_t             tagSize;
+    const void*        pTag;
+} VkDebugUtilsObjectTagInfoEXT;
+
+typedef struct VkDebugUtilsLabelEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    const char*        pLabelName;
+    float              color[4];
+} VkDebugUtilsLabelEXT;
+
+typedef struct VkDebugUtilsMessengerCallbackDataEXT {
+    VkStructureType                              sType;
+    const void*                                  pNext;
+    VkDebugUtilsMessengerCallbackDataFlagsEXT    flags;
+    const char*                                  pMessageIdName;
+    int32_t                                      messageIdNumber;
+    const char*                                  pMessage;
+    uint32_t                                     queueLabelCount;
+    VkDebugUtilsLabelEXT*                        pQueueLabels;
+    uint32_t                                     cmdBufLabelCount;
+    VkDebugUtilsLabelEXT*                        pCmdBufLabels;
+    uint32_t                                     objectCount;
+    VkDebugUtilsObjectNameInfoEXT*               pObjects;
+} VkDebugUtilsMessengerCallbackDataEXT;
+
+typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(
+    VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT                  messageType,
+    const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
+    void*                                            pUserData);
+
+typedef struct VkDebugUtilsMessengerCreateInfoEXT {
+    VkStructureType                         sType;
+    const void*                             pNext;
+    VkDebugUtilsMessengerCreateFlagsEXT     flags;
+    VkDebugUtilsMessageSeverityFlagsEXT     messageSeverity;
+    VkDebugUtilsMessageTypeFlagsEXT         messageType;
+    PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
+    void*                                   pUserData;
+} VkDebugUtilsMessengerCreateInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);
+typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);
+typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);
+typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(
+    VkDevice                                    device,
+    const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(
+    VkDevice                                    device,
+    const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(
+    VkQueue                                     queue,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(
+    VkQueue                                     queue);
+
+VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(
+    VkQueue                                     queue,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer);
+
+VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkDebugUtilsLabelEXT*                 pLabelInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(
+    VkInstance                                  instance,
+    const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDebugUtilsMessengerEXT*                   pMessenger);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(
+    VkInstance                                  instance,
+    VkDebugUtilsMessengerEXT                    messenger,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(
+    VkInstance                                  instance,
+    VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
+    VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
+    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
+#endif
+
+#define VK_EXT_sampler_filter_minmax 1
+#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 1
+#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"
+
+
+typedef enum VkSamplerReductionModeEXT {
+    VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = 0,
+    VK_SAMPLER_REDUCTION_MODE_MIN_EXT = 1,
+    VK_SAMPLER_REDUCTION_MODE_MAX_EXT = 2,
+    VK_SAMPLER_REDUCTION_MODE_BEGIN_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT,
+    VK_SAMPLER_REDUCTION_MODE_END_RANGE_EXT = VK_SAMPLER_REDUCTION_MODE_MAX_EXT,
+    VK_SAMPLER_REDUCTION_MODE_RANGE_SIZE_EXT = (VK_SAMPLER_REDUCTION_MODE_MAX_EXT - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT + 1),
+    VK_SAMPLER_REDUCTION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkSamplerReductionModeEXT;
+
+typedef struct VkSamplerReductionModeCreateInfoEXT {
+    VkStructureType              sType;
+    const void*                  pNext;
+    VkSamplerReductionModeEXT    reductionMode;
+} VkSamplerReductionModeCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           filterMinmaxSingleComponentFormats;
+    VkBool32           filterMinmaxImageComponentMapping;
+} VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
+
+
+
+#define VK_AMD_gpu_shader_int16 1
+#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 1
+#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"
+
+
+#define VK_AMD_mixed_attachment_samples 1
+#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1
+#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"
+
+
+#define VK_AMD_shader_fragment_mask 1
+#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1
+#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"
+
+
+#define VK_EXT_shader_stencil_export 1
+#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1
+#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"
+
+
+#define VK_EXT_sample_locations 1
+#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1
+#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"
+
+typedef struct VkSampleLocationEXT {
+    float    x;
+    float    y;
+} VkSampleLocationEXT;
+
+typedef struct VkSampleLocationsInfoEXT {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkSampleCountFlagBits         sampleLocationsPerPixel;
+    VkExtent2D                    sampleLocationGridSize;
+    uint32_t                      sampleLocationsCount;
+    const VkSampleLocationEXT*    pSampleLocations;
+} VkSampleLocationsInfoEXT;
+
+typedef struct VkAttachmentSampleLocationsEXT {
+    uint32_t                    attachmentIndex;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkAttachmentSampleLocationsEXT;
+
+typedef struct VkSubpassSampleLocationsEXT {
+    uint32_t                    subpassIndex;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkSubpassSampleLocationsEXT;
+
+typedef struct VkRenderPassSampleLocationsBeginInfoEXT {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    uint32_t                                 attachmentInitialSampleLocationsCount;
+    const VkAttachmentSampleLocationsEXT*    pAttachmentInitialSampleLocations;
+    uint32_t                                 postSubpassSampleLocationsCount;
+    const VkSubpassSampleLocationsEXT*       pPostSubpassSampleLocations;
+} VkRenderPassSampleLocationsBeginInfoEXT;
+
+typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkBool32                    sampleLocationsEnable;
+    VkSampleLocationsInfoEXT    sampleLocationsInfo;
+} VkPipelineSampleLocationsStateCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
+    VkStructureType       sType;
+    void*                 pNext;
+    VkSampleCountFlags    sampleLocationSampleCounts;
+    VkExtent2D            maxSampleLocationGridSize;
+    float                 sampleLocationCoordinateRange[2];
+    uint32_t              sampleLocationSubPixelBits;
+    VkBool32              variableSampleLocations;
+} VkPhysicalDeviceSampleLocationsPropertiesEXT;
+
+typedef struct VkMultisamplePropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkExtent2D         maxSampleLocationGridSize;
+} VkMultisamplePropertiesEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);
+typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(
+    VkCommandBuffer                             commandBuffer,
+    const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
+
+VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(
+    VkPhysicalDevice                            physicalDevice,
+    VkSampleCountFlagBits                       samples,
+    VkMultisamplePropertiesEXT*                 pMultisampleProperties);
+#endif
+
+#define VK_EXT_blend_operation_advanced 1
+#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2
+#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"
+
+
+typedef enum VkBlendOverlapEXT {
+    VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,
+    VK_BLEND_OVERLAP_DISJOINT_EXT = 1,
+    VK_BLEND_OVERLAP_CONJOINT_EXT = 2,
+    VK_BLEND_OVERLAP_BEGIN_RANGE_EXT = VK_BLEND_OVERLAP_UNCORRELATED_EXT,
+    VK_BLEND_OVERLAP_END_RANGE_EXT = VK_BLEND_OVERLAP_CONJOINT_EXT,
+    VK_BLEND_OVERLAP_RANGE_SIZE_EXT = (VK_BLEND_OVERLAP_CONJOINT_EXT - VK_BLEND_OVERLAP_UNCORRELATED_EXT + 1),
+    VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkBlendOverlapEXT;
+
+typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           advancedBlendCoherentOperations;
+} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
+
+typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           advancedBlendMaxColorAttachments;
+    VkBool32           advancedBlendIndependentBlend;
+    VkBool32           advancedBlendNonPremultipliedSrcColor;
+    VkBool32           advancedBlendNonPremultipliedDstColor;
+    VkBool32           advancedBlendCorrelatedOverlap;
+    VkBool32           advancedBlendAllOperations;
+} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
+
+typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
+    VkStructureType      sType;
+    const void*          pNext;
+    VkBool32             srcPremultiplied;
+    VkBool32             dstPremultiplied;
+    VkBlendOverlapEXT    blendOverlap;
+} VkPipelineColorBlendAdvancedStateCreateInfoEXT;
+
+
+
+#define VK_NV_fragment_coverage_to_color 1
+#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1
+#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"
+
+typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;
+
+typedef struct VkPipelineCoverageToColorStateCreateInfoNV {
+    VkStructureType                                sType;
+    const void*                                    pNext;
+    VkPipelineCoverageToColorStateCreateFlagsNV    flags;
+    VkBool32                                       coverageToColorEnable;
+    uint32_t                                       coverageToColorLocation;
+} VkPipelineCoverageToColorStateCreateInfoNV;
+
+
+
+#define VK_NV_framebuffer_mixed_samples 1
+#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1
+#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"
+
+
+typedef enum VkCoverageModulationModeNV {
+    VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,
+    VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,
+    VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,
+    VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,
+    VK_COVERAGE_MODULATION_MODE_BEGIN_RANGE_NV = VK_COVERAGE_MODULATION_MODE_NONE_NV,
+    VK_COVERAGE_MODULATION_MODE_END_RANGE_NV = VK_COVERAGE_MODULATION_MODE_RGBA_NV,
+    VK_COVERAGE_MODULATION_MODE_RANGE_SIZE_NV = (VK_COVERAGE_MODULATION_MODE_RGBA_NV - VK_COVERAGE_MODULATION_MODE_NONE_NV + 1),
+    VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF
+} VkCoverageModulationModeNV;
+
+typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;
+
+typedef struct VkPipelineCoverageModulationStateCreateInfoNV {
+    VkStructureType                                   sType;
+    const void*                                       pNext;
+    VkPipelineCoverageModulationStateCreateFlagsNV    flags;
+    VkCoverageModulationModeNV                        coverageModulationMode;
+    VkBool32                                          coverageModulationTableEnable;
+    uint32_t                                          coverageModulationTableCount;
+    const float*                                      pCoverageModulationTable;
+} VkPipelineCoverageModulationStateCreateInfoNV;
+
+
+
+#define VK_NV_fill_rectangle 1
+#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1
+#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"
+
+
+#define VK_EXT_post_depth_coverage 1
+#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1
+#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"
+
+
+#define VK_EXT_validation_cache 1
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)
+
+#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1
+#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"
+#define VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT
+
+
+typedef enum VkValidationCacheHeaderVersionEXT {
+    VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,
+    VK_VALIDATION_CACHE_HEADER_VERSION_BEGIN_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
+    VK_VALIDATION_CACHE_HEADER_VERSION_END_RANGE_EXT = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT,
+    VK_VALIDATION_CACHE_HEADER_VERSION_RANGE_SIZE_EXT = (VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + 1),
+    VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkValidationCacheHeaderVersionEXT;
+
+typedef VkFlags VkValidationCacheCreateFlagsEXT;
+
+typedef struct VkValidationCacheCreateInfoEXT {
+    VkStructureType                    sType;
+    const void*                        pNext;
+    VkValidationCacheCreateFlagsEXT    flags;
+    size_t                             initialDataSize;
+    const void*                        pInitialData;
+} VkValidationCacheCreateInfoEXT;
+
+typedef struct VkShaderModuleValidationCacheCreateInfoEXT {
+    VkStructureType         sType;
+    const void*             pNext;
+    VkValidationCacheEXT    validationCache;
+} VkShaderModuleValidationCacheCreateInfoEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
+typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);
+typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(
+    VkDevice                                    device,
+    const VkValidationCacheCreateInfoEXT*       pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkValidationCacheEXT*                       pValidationCache);
+
+VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        validationCache,
+    const VkAllocationCallbacks*                pAllocator);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        dstCache,
+    uint32_t                                    srcCacheCount,
+    const VkValidationCacheEXT*                 pSrcCaches);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(
+    VkDevice                                    device,
+    VkValidationCacheEXT                        validationCache,
+    size_t*                                     pDataSize,
+    void*                                       pData);
+#endif
+
+#define VK_EXT_descriptor_indexing 1
+#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2
+#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"
+
+
+typedef enum VkDescriptorBindingFlagBitsEXT {
+    VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = 0x00000001,
+    VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = 0x00000002,
+    VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = 0x00000004,
+    VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = 0x00000008,
+    VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkDescriptorBindingFlagBitsEXT;
+typedef VkFlags VkDescriptorBindingFlagsEXT;
+
+typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    uint32_t                              bindingCount;
+    const VkDescriptorBindingFlagsEXT*    pBindingFlags;
+} VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
+
+typedef struct VkPhysicalDeviceDescriptorIndexingFeaturesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           shaderInputAttachmentArrayDynamicIndexing;
+    VkBool32           shaderUniformTexelBufferArrayDynamicIndexing;
+    VkBool32           shaderStorageTexelBufferArrayDynamicIndexing;
+    VkBool32           shaderUniformBufferArrayNonUniformIndexing;
+    VkBool32           shaderSampledImageArrayNonUniformIndexing;
+    VkBool32           shaderStorageBufferArrayNonUniformIndexing;
+    VkBool32           shaderStorageImageArrayNonUniformIndexing;
+    VkBool32           shaderInputAttachmentArrayNonUniformIndexing;
+    VkBool32           shaderUniformTexelBufferArrayNonUniformIndexing;
+    VkBool32           shaderStorageTexelBufferArrayNonUniformIndexing;
+    VkBool32           descriptorBindingUniformBufferUpdateAfterBind;
+    VkBool32           descriptorBindingSampledImageUpdateAfterBind;
+    VkBool32           descriptorBindingStorageImageUpdateAfterBind;
+    VkBool32           descriptorBindingStorageBufferUpdateAfterBind;
+    VkBool32           descriptorBindingUniformTexelBufferUpdateAfterBind;
+    VkBool32           descriptorBindingStorageTexelBufferUpdateAfterBind;
+    VkBool32           descriptorBindingUpdateUnusedWhilePending;
+    VkBool32           descriptorBindingPartiallyBound;
+    VkBool32           descriptorBindingVariableDescriptorCount;
+    VkBool32           runtimeDescriptorArray;
+} VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
+
+typedef struct VkPhysicalDeviceDescriptorIndexingPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxUpdateAfterBindDescriptorsInAllPools;
+    VkBool32           shaderUniformBufferArrayNonUniformIndexingNative;
+    VkBool32           shaderSampledImageArrayNonUniformIndexingNative;
+    VkBool32           shaderStorageBufferArrayNonUniformIndexingNative;
+    VkBool32           shaderStorageImageArrayNonUniformIndexingNative;
+    VkBool32           shaderInputAttachmentArrayNonUniformIndexingNative;
+    VkBool32           robustBufferAccessUpdateAfterBind;
+    VkBool32           quadDivergentImplicitLod;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindSamplers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindUniformBuffers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageBuffers;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindSampledImages;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindStorageImages;
+    uint32_t           maxPerStageDescriptorUpdateAfterBindInputAttachments;
+    uint32_t           maxPerStageUpdateAfterBindResources;
+    uint32_t           maxDescriptorSetUpdateAfterBindSamplers;
+    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffers;
+    uint32_t           maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffers;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
+    uint32_t           maxDescriptorSetUpdateAfterBindSampledImages;
+    uint32_t           maxDescriptorSetUpdateAfterBindStorageImages;
+    uint32_t           maxDescriptorSetUpdateAfterBindInputAttachments;
+} VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
+
+typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfoEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           descriptorSetCount;
+    const uint32_t*    pDescriptorCounts;
+} VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
+
+typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupportEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVariableDescriptorCount;
+} VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
+
+
+
+#define VK_EXT_shader_viewport_index_layer 1
+#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1
+#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"
+
+
+#define VK_EXT_global_priority 1
+#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2
+#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"
+
+
+typedef enum VkQueueGlobalPriorityEXT {
+    VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = 128,
+    VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = 256,
+    VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = 512,
+    VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = 1024,
+    VK_QUEUE_GLOBAL_PRIORITY_BEGIN_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT,
+    VK_QUEUE_GLOBAL_PRIORITY_END_RANGE_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT,
+    VK_QUEUE_GLOBAL_PRIORITY_RANGE_SIZE_EXT = (VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT + 1),
+    VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkQueueGlobalPriorityEXT;
+
+typedef struct VkDeviceQueueGlobalPriorityCreateInfoEXT {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkQueueGlobalPriorityEXT    globalPriority;
+} VkDeviceQueueGlobalPriorityCreateInfoEXT;
+
+
+
+#define VK_EXT_external_memory_host 1
+#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1
+#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"
+
+typedef struct VkImportMemoryHostPointerInfoEXT {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    void*                                 pHostPointer;
+} VkImportMemoryHostPointerInfoEXT;
+
+typedef struct VkMemoryHostPointerPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryHostPointerPropertiesEXT;
+
+typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    VkDeviceSize       minImportedHostPointerAlignment;
+} VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    const void*                                 pHostPointer,
+    VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
+#endif
+
+#define VK_AMD_buffer_marker 1
+#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1
+#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"
+
+typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(
+    VkCommandBuffer                             commandBuffer,
+    VkPipelineStageFlagBits                     pipelineStage,
+    VkBuffer                                    dstBuffer,
+    VkDeviceSize                                dstOffset,
+    uint32_t                                    marker);
+#endif
+
+#define VK_AMD_shader_core_properties 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 1
+#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"
+
+typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           shaderEngineCount;
+    uint32_t           shaderArraysPerEngineCount;
+    uint32_t           computeUnitsPerShaderArray;
+    uint32_t           simdPerComputeUnit;
+    uint32_t           wavefrontsPerSimd;
+    uint32_t           wavefrontSize;
+    uint32_t           sgprsPerSimd;
+    uint32_t           minSgprAllocation;
+    uint32_t           maxSgprAllocation;
+    uint32_t           sgprAllocationGranularity;
+    uint32_t           vgprsPerSimd;
+    uint32_t           minVgprAllocation;
+    uint32_t           maxVgprAllocation;
+    uint32_t           vgprAllocationGranularity;
+} VkPhysicalDeviceShaderCorePropertiesAMD;
+
+
+
+#define VK_EXT_vertex_attribute_divisor 1
+#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1
+#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"
+
+typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           maxVertexAttribDivisor;
+} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
+
+typedef struct VkVertexInputBindingDivisorDescriptionEXT {
+    uint32_t    binding;
+    uint32_t    divisor;
+} VkVertexInputBindingDivisorDescriptionEXT;
+
+typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
+    VkStructureType                                     sType;
+    const void*                                         pNext;
+    uint32_t                                            vertexBindingDivisorCount;
+    const VkVertexInputBindingDivisorDescriptionEXT*    pVertexBindingDivisors;
+} VkPipelineVertexInputDivisorStateCreateInfoEXT;
+
+
+
+#define VK_NV_shader_subgroup_partitioned 1
+#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1
+#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_ios.h b/third_party/vulkan/vulkan_ios.h
new file mode 100644
index 000000000..a0924816d
--- /dev/null
+++ b/third_party/vulkan/vulkan_ios.h
@@ -0,0 +1,58 @@
+#ifndef VULKAN_IOS_H_
+#define VULKAN_IOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_ios_surface 1
+#define VK_MVK_IOS_SURFACE_SPEC_VERSION   2
+#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface"
+
+typedef VkFlags VkIOSSurfaceCreateFlagsMVK;
+
+typedef struct VkIOSSurfaceCreateInfoMVK {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkIOSSurfaceCreateFlagsMVK    flags;
+    const void*                   pView;
+} VkIOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_macos.h b/third_party/vulkan/vulkan_macos.h
new file mode 100644
index 000000000..ff0b70180
--- /dev/null
+++ b/third_party/vulkan/vulkan_macos.h
@@ -0,0 +1,58 @@
+#ifndef VULKAN_MACOS_H_
+#define VULKAN_MACOS_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_MVK_macos_surface 1
+#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 2
+#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
+
+typedef VkFlags VkMacOSSurfaceCreateFlagsMVK;
+
+typedef struct VkMacOSSurfaceCreateInfoMVK {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkMacOSSurfaceCreateFlagsMVK    flags;
+    const void*                     pView;
+} VkMacOSSurfaceCreateInfoMVK;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK(
+    VkInstance                                  instance,
+    const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_mir.h b/third_party/vulkan/vulkan_mir.h
new file mode 100644
index 000000000..7d24ed27a
--- /dev/null
+++ b/third_party/vulkan/vulkan_mir.h
@@ -0,0 +1,65 @@
+#ifndef VULKAN_MIR_H_
+#define VULKAN_MIR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_mir_surface 1
+#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
+#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"
+
+typedef VkFlags VkMirSurfaceCreateFlagsKHR;
+
+typedef struct VkMirSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkMirSurfaceCreateFlagsKHR    flags;
+    MirConnection*                connection;
+    MirSurface*                   mirSurface;
+} VkMirSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
+    VkInstance                                  instance,
+    const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    MirConnection*                              connection);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_vi.h b/third_party/vulkan/vulkan_vi.h
new file mode 100644
index 000000000..015166bfc
--- /dev/null
+++ b/third_party/vulkan/vulkan_vi.h
@@ -0,0 +1,58 @@
+#ifndef VULKAN_VI_H_
+#define VULKAN_VI_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_NN_vi_surface 1
+#define VK_NN_VI_SURFACE_SPEC_VERSION     1
+#define VK_NN_VI_SURFACE_EXTENSION_NAME   "VK_NN_vi_surface"
+
+typedef VkFlags VkViSurfaceCreateFlagsNN;
+
+typedef struct VkViSurfaceCreateInfoNN {
+    VkStructureType             sType;
+    const void*                 pNext;
+    VkViSurfaceCreateFlagsNN    flags;
+    void*                       window;
+} VkViSurfaceCreateInfoNN;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN(
+    VkInstance                                  instance,
+    const VkViSurfaceCreateInfoNN*              pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_wayland.h b/third_party/vulkan/vulkan_wayland.h
new file mode 100644
index 000000000..5ba0827aa
--- /dev/null
+++ b/third_party/vulkan/vulkan_wayland.h
@@ -0,0 +1,65 @@
+#ifndef VULKAN_WAYLAND_H_
+#define VULKAN_WAYLAND_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_wayland_surface 1
+#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"
+
+typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;
+
+typedef struct VkWaylandSurfaceCreateInfoKHR {
+    VkStructureType                   sType;
+    const void*                       pNext;
+    VkWaylandSurfaceCreateFlagsKHR    flags;
+    struct wl_display*                display;
+    struct wl_surface*                surface;
+} VkWaylandSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
+    VkInstance                                  instance,
+    const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    struct wl_display*                          display);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_win32.h b/third_party/vulkan/vulkan_win32.h
new file mode 100644
index 000000000..6a85409eb
--- /dev/null
+++ b/third_party/vulkan/vulkan_win32.h
@@ -0,0 +1,276 @@
+#ifndef VULKAN_WIN32_H_
+#define VULKAN_WIN32_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_win32_surface 1
+#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6
+#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"
+
+typedef VkFlags VkWin32SurfaceCreateFlagsKHR;
+
+typedef struct VkWin32SurfaceCreateInfoKHR {
+    VkStructureType                 sType;
+    const void*                     pNext;
+    VkWin32SurfaceCreateFlagsKHR    flags;
+    HINSTANCE                       hinstance;
+    HWND                            hwnd;
+} VkWin32SurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
+    VkInstance                                  instance,
+    const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex);
+#endif
+
+#define VK_KHR_external_memory_win32 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+    HANDLE                                handle;
+    LPCWSTR                               name;
+} VkImportMemoryWin32HandleInfoKHR;
+
+typedef struct VkExportMemoryWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportMemoryWin32HandleInfoKHR;
+
+typedef struct VkMemoryWin32HandlePropertiesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    uint32_t           memoryTypeBits;
+} VkMemoryWin32HandlePropertiesKHR;
+
+typedef struct VkMemoryGetWin32HandleInfoKHR {
+    VkStructureType                       sType;
+    const void*                           pNext;
+    VkDeviceMemory                        memory;
+    VkExternalMemoryHandleTypeFlagBits    handleType;
+} VkMemoryGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR(
+    VkDevice                                    device,
+    const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice                                    device,
+    VkExternalMemoryHandleTypeFlagBits          handleType,
+    HANDLE                                      handle,
+    VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
+#endif
+
+#define VK_KHR_win32_keyed_mutex 1
+#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeouts;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoKHR;
+
+
+
+#define VK_KHR_external_semaphore_win32 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32"
+
+typedef struct VkImportSemaphoreWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkSemaphoreImportFlags                   flags;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+    HANDLE                                   handle;
+    LPCWSTR                                  name;
+} VkImportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkExportSemaphoreWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportSemaphoreWin32HandleInfoKHR;
+
+typedef struct VkD3D12FenceSubmitInfoKHR {
+    VkStructureType    sType;
+    const void*        pNext;
+    uint32_t           waitSemaphoreValuesCount;
+    const uint64_t*    pWaitSemaphoreValues;
+    uint32_t           signalSemaphoreValuesCount;
+    const uint64_t*    pSignalSemaphoreValues;
+} VkD3D12FenceSubmitInfoKHR;
+
+typedef struct VkSemaphoreGetWin32HandleInfoKHR {
+    VkStructureType                          sType;
+    const void*                              pNext;
+    VkSemaphore                              semaphore;
+    VkExternalSemaphoreHandleTypeFlagBits    handleType;
+} VkSemaphoreGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR(
+    VkDevice                                    device,
+    const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_KHR_external_fence_win32 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1
+#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32"
+
+typedef struct VkImportFenceWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkFenceImportFlags                   flags;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+    HANDLE                               handle;
+    LPCWSTR                              name;
+} VkImportFenceWin32HandleInfoKHR;
+
+typedef struct VkExportFenceWin32HandleInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+    LPCWSTR                       name;
+} VkExportFenceWin32HandleInfoKHR;
+
+typedef struct VkFenceGetWin32HandleInfoKHR {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkFence                              fence;
+    VkExternalFenceHandleTypeFlagBits    handleType;
+} VkFenceGetWin32HandleInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo);
+typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR(
+    VkDevice                                    device,
+    const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_external_memory_win32 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1
+#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32"
+
+typedef struct VkImportMemoryWin32HandleInfoNV {
+    VkStructureType                      sType;
+    const void*                          pNext;
+    VkExternalMemoryHandleTypeFlagsNV    handleType;
+    HANDLE                               handle;
+} VkImportMemoryWin32HandleInfoNV;
+
+typedef struct VkExportMemoryWin32HandleInfoNV {
+    VkStructureType               sType;
+    const void*                   pNext;
+    const SECURITY_ATTRIBUTES*    pAttributes;
+    DWORD                         dwAccess;
+} VkExportMemoryWin32HandleInfoNV;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(
+    VkDevice                                    device,
+    VkDeviceMemory                              memory,
+    VkExternalMemoryHandleTypeFlagsNV           handleType,
+    HANDLE*                                     pHandle);
+#endif
+
+#define VK_NV_win32_keyed_mutex 1
+#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 1
+#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex"
+
+typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV {
+    VkStructureType          sType;
+    const void*              pNext;
+    uint32_t                 acquireCount;
+    const VkDeviceMemory*    pAcquireSyncs;
+    const uint64_t*          pAcquireKeys;
+    const uint32_t*          pAcquireTimeoutMilliseconds;
+    uint32_t                 releaseCount;
+    const VkDeviceMemory*    pReleaseSyncs;
+    const uint64_t*          pReleaseKeys;
+} VkWin32KeyedMutexAcquireReleaseInfoNV;
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_xcb.h b/third_party/vulkan/vulkan_xcb.h
new file mode 100644
index 000000000..ba0360060
--- /dev/null
+++ b/third_party/vulkan/vulkan_xcb.h
@@ -0,0 +1,66 @@
+#ifndef VULKAN_XCB_H_
+#define VULKAN_XCB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xcb_surface 1
+#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
+#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"
+
+typedef VkFlags VkXcbSurfaceCreateFlagsKHR;
+
+typedef struct VkXcbSurfaceCreateInfoKHR {
+    VkStructureType               sType;
+    const void*                   pNext;
+    VkXcbSurfaceCreateFlagsKHR    flags;
+    xcb_connection_t*             connection;
+    xcb_window_t                  window;
+} VkXcbSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    xcb_connection_t*                           connection,
+    xcb_visualid_t                              visual_id);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_xlib.h b/third_party/vulkan/vulkan_xlib.h
new file mode 100644
index 000000000..e1d967e01
--- /dev/null
+++ b/third_party/vulkan/vulkan_xlib.h
@@ -0,0 +1,66 @@
+#ifndef VULKAN_XLIB_H_
+#define VULKAN_XLIB_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_KHR_xlib_surface 1
+#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
+#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"
+
+typedef VkFlags VkXlibSurfaceCreateFlagsKHR;
+
+typedef struct VkXlibSurfaceCreateInfoKHR {
+    VkStructureType                sType;
+    const void*                    pNext;
+    VkXlibSurfaceCreateFlagsKHR    flags;
+    Display*                       dpy;
+    Window                         window;
+} VkXlibSurfaceCreateInfoKHR;
+
+
+typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
+typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
+    VkInstance                                  instance,
+    const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkSurfaceKHR*                               pSurface);
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
+    VkPhysicalDevice                            physicalDevice,
+    uint32_t                                    queueFamilyIndex,
+    Display*                                    dpy,
+    VisualID                                    visualID);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/third_party/vulkan/vulkan_xlib_xrandr.h b/third_party/vulkan/vulkan_xlib_xrandr.h
new file mode 100644
index 000000000..117d01799
--- /dev/null
+++ b/third_party/vulkan/vulkan_xlib_xrandr.h
@@ -0,0 +1,54 @@
+#ifndef VULKAN_XLIB_XRANDR_H_
+#define VULKAN_XLIB_XRANDR_H_ 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+** Copyright (c) 2015-2018 The Khronos Group Inc.
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+/*
+** This header is generated from the Khronos Vulkan XML API Registry.
+**
+*/
+
+
+#define VK_EXT_acquire_xlib_display 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1
+#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display"
+
+typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display);
+typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    VkDisplayKHR                                display);
+
+VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(
+    VkPhysicalDevice                            physicalDevice,
+    Display*                                    dpy,
+    RROutput                                    rrOutput,
+    VkDisplayKHR*                               pDisplay);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

From 289a24820ff7760821d0e182c719f37203a0dfa9 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Fri, 4 May 2018 19:20:43 -0500
Subject: [PATCH 55/56] Update Travis link to xenia-project/xenia

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d656cfcf0..6cd1b873c 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ Discussing illegal activities will get you banned. No warnings.
 Buildbot | Status
 -------- | ------
 [Windows](https://ci.appveyor.com/project/benvanik/xenia/branch/master) | [![Build status](https://ci.appveyor.com/api/projects/status/ftqiy86kdfawyx3a/branch/master?svg=true)](https://ci.appveyor.com/project/benvanik/xenia/branch/master)
-[Linux](https://travis-ci.org/benvanik/xenia) | [![Build status](https://travis-ci.org/benvanik/xenia.svg)](https://travis-ci.org/benvanik/xenia)
+[Linux](https://travis-ci.org/xenia-project/xenia) | [![Build status](https://travis-ci.org/xenia-project/xenia.svg)](https://travis-ci.org/xenia-project/xenia)
 
 Some real games run. Most don't.
 See the [Game compatibility list](https://github.com/xenia-project/game-compatibility/issues)

From 30f8fe7bb0d02bf1e09ec139e97c1a4d51defde8 Mon Sep 17 00:00:00 2001
From: "Dr. Chat" <arkolbed@gmail.com>
Date: Sat, 5 May 2018 10:45:39 -0500
Subject: [PATCH 56/56] [GPU] Use log2 when calculating mip offset

---
 src/xenia/gpu/texture_info.cc | 49 ++++++++++++++---------------------
 1 file changed, 20 insertions(+), 29 deletions(-)

diff --git a/src/xenia/gpu/texture_info.cc b/src/xenia/gpu/texture_info.cc
index d80aae0c2..46caa54f3 100644
--- a/src/xenia/gpu/texture_info.cc
+++ b/src/xenia/gpu/texture_info.cc
@@ -439,30 +439,17 @@ uint32_t TextureInfo::GetMipLocation(const TextureInfo& src, uint32_t mip,
   }
 
   // Now, check if the mip is packed at an offset.
-  uint32_t logical_width = std::max(xe::next_pow2(src.width + 1) >> mip, 1u);
-  uint32_t logical_height = std::max(xe::next_pow2(src.height + 1) >> mip, 1u);
-
-  *offset_x = 0;
-  *offset_y = 0;
-  if (std::min(logical_width, logical_height) <= 16) {
-    // Find the block offset of the mip.
-    if (xe::log2_ceil(logical_width) > xe::log2_ceil(logical_height)) {
-      // Wider than tall. Laid out vertically.
-      *offset_y = logical_height & ~0x3;
-      *offset_x = logical_height & 0x3 ? logical_width << 1 : 0;
-    } else {
-      // Taller than wide. Laid out horizontally.
-      *offset_x = logical_width & ~0x3;
-      *offset_y = logical_width & 0x3 ? logical_height << 1 : 0;
-    }
-  }
-
-  *offset_x /= src.format_info()->block_width;
-  *offset_y /= src.format_info()->block_height;
+  GetPackedTileOffset(xe::next_pow2(src.width + 1) >> mip,
+                      xe::next_pow2(src.height + 1) >> mip, src.format_info(),
+                      offset_x, offset_y);
   return address_base + address_offset;
 }
 
 uint32_t TextureInfo::GetMipSize(const TextureInfo& src, uint32_t mip) {
+  if (mip == 0) {
+    return src.input_length;
+  }
+
   uint32_t bytes_per_block = src.format_info()->block_width *
                              src.format_info()->block_height *
                              src.format_info()->bits_per_pixel / 8;
@@ -537,21 +524,24 @@ bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
   // The minimum dimension is what matters most: if either width or height
   // is <= 16 this mode kicks in.
 
-  if (std::min(width, height) > 16) {
+  uint32_t log2_width = xe::log2_ceil(width);
+  uint32_t log2_height = xe::log2_ceil(height);
+  if (std::min(log2_width, log2_height) > 4) {
     // Too big, not packed.
     *out_offset_x = 0;
     *out_offset_y = 0;
     return false;
   }
 
-  if (xe::log2_ceil(width) > xe::log2_ceil(height)) {
+  // Find the block offset of the mip.
+  if (log2_width > log2_height) {
     // Wider than tall. Laid out vertically.
-    *out_offset_x = 0;
-    *out_offset_y = 16;
+    *out_offset_y = log2_height > 0x1 ? 1 << log2_height : 0;
+    *out_offset_x = log2_height <= 0x1 ? 1 << (log2_width + 2) : 0;
   } else {
     // Taller than wide. Laid out horizontally.
-    *out_offset_x = 16;
-    *out_offset_y = 0;
+    *out_offset_x = log2_width > 0x1 ? 1 << log2_width : 0;
+    *out_offset_y = log2_width <= 0x1 ? 1 << (log2_height + 2) : 0;
   }
 
   *out_offset_x /= format_info->block_width;
@@ -562,9 +552,10 @@ bool TextureInfo::GetPackedTileOffset(uint32_t width, uint32_t height,
 bool TextureInfo::GetPackedTileOffset(const TextureInfo& texture_info,
                                       uint32_t* out_offset_x,
                                       uint32_t* out_offset_y) {
-  return GetPackedTileOffset(
-      texture_info.size_2d.logical_width, texture_info.size_2d.logical_height,
-      texture_info.format_info(), out_offset_x, out_offset_y);
+  return GetPackedTileOffset(xe::next_pow2(texture_info.size_2d.logical_width),
+                             xe::next_pow2(texture_info.size_2d.logical_height),
+                             texture_info.format_info(), out_offset_x,
+                             out_offset_y);
 }
 
 // https://github.com/BinomialLLC/crunch/blob/ea9b8d8c00c8329791256adafa8cf11e4e7942a2/inc/crn_decomp.h#L4108