diff --git a/ThunkLibs/Generator/analysis.cpp b/ThunkLibs/Generator/analysis.cpp
index fa730a7652..112d1aedc5 100644
--- a/ThunkLibs/Generator/analysis.cpp
+++ b/ThunkLibs/Generator/analysis.cpp
@@ -301,14 +301,8 @@ void AnalysisAction::ParseInterface(clang::ASTContext& context) {
                 if (auto emitted_function = llvm::dyn_cast<clang::FunctionDecl>(template_args[0].getAsDecl())) {
                     // Process later
                 } else if (auto annotated_member = llvm::dyn_cast<clang::FieldDecl>(template_args[0].getAsDecl())) {
-                    {
-                        if (decl->getNumBases() != 1 || decl->bases_begin()->getType().getAsString() != "fexgen::custom_repack") {
-                            throw report_error(template_arg_loc, "Unsupported member annotation(s)");
-                        }
-
-                        if (!annotated_member->getType()->isPointerType() && !annotated_member->getType()->isArrayType()) {
-                            throw report_error(template_arg_loc, "custom_repack annotation requires pointer member");
-                        }
+                    if (decl->getNumBases() != 1 || decl->bases_begin()->getType().getAsString() != "fexgen::custom_repack") {
+                        throw report_error(template_arg_loc, "Unsupported member annotation(s)");
                     }
 
                     // Get or add parent type to list of structure types
diff --git a/ThunkLibs/Generator/data_layout.cpp b/ThunkLibs/Generator/data_layout.cpp
index 0076a69d74..f083af52d2 100644
--- a/ThunkLibs/Generator/data_layout.cpp
+++ b/ThunkLibs/Generator/data_layout.cpp
@@ -305,15 +305,15 @@ TypeCompatibility DataLayoutCompareAction::GetTypeCompatibility(
                 host_member_type = context.getCanonicalType(array_type->getElementType().getTypePtr());
             }
 
-            if (host_member_type->isPointerType()) {
+            if (types.at(type).UsesCustomRepackFor(host_member_field)) {
+                member_compat.push_back(TypeCompatibility::Repackable);
+                continue;
+            } else if (host_member_type->isPointerType()) {
                 // Automatic repacking of pointers to non-compatible types is only possible if:
                 // * Pointee is fully compatible, or
                 // * Pointer member is annotated
-                // TODO: Don't restrict this to structure types. it applies to pointers to builtin types too!
                 auto host_member_pointee_type = context.getCanonicalType(host_member_type->getPointeeType().getTypePtr());
-                if (types.at(type).UsesCustomRepackFor(host_member_field)) {
-                    member_compat.push_back(TypeCompatibility::Repackable);
-                } else if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).assumed_compatible) {
+                if (types.contains(host_member_pointee_type) && types.at(host_member_pointee_type).assumed_compatible) {
                     // Pointee doesn't need repacking, but pointer needs extending on 32-bit
                     member_compat.push_back(is_32bit ? TypeCompatibility::Repackable : TypeCompatibility::Full);
                 } else if (host_member_pointee_type->isPointerType()) {
diff --git a/ThunkLibs/Generator/gen.cpp b/ThunkLibs/Generator/gen.cpp
index d15cfc03f8..80e548b761 100644
--- a/ThunkLibs/Generator/gen.cpp
+++ b/ThunkLibs/Generator/gen.cpp
@@ -308,7 +308,7 @@ void GenerateThunkLibsAction::EmitLayoutWrappers(
         if (type_repack_info.custom_repacked_members.empty()) {
             fmt::print(file, "void fex_apply_custom_repacking_entry(host_layout<{}>& source, const guest_layout<{}>& from) {{\n", struct_name, struct_name);
             fmt::print(file, "}}\n");
-            fmt::print(file, "bool fex_apply_custom_repacking_exit(guest_layout<{}>& into, host_layout<{}>& from) {{\n", struct_name, struct_name);
+            fmt::print(file, "bool fex_apply_custom_repacking_exit(guest_layout<{}>& into, const host_layout<{}>& from) {{\n", struct_name, struct_name);
             fmt::print(file, "  return false;\n");
             fmt::print(file, "}}\n");
         } else {
@@ -321,7 +321,7 @@ void GenerateThunkLibsAction::EmitLayoutWrappers(
             fmt::print(file, "  fex_custom_repack_entry(source, from);\n");
             fmt::print(file, "}}\n");
 
-            fmt::print(file, "bool fex_apply_custom_repacking_exit(guest_layout<{}>& into, host_layout<{}>& from) {{\n", struct_name, struct_name);
+            fmt::print(file, "bool fex_apply_custom_repacking_exit(guest_layout<{}>& into, const host_layout<{}>& from) {{\n", struct_name, struct_name);
             fmt::print(file, "  return fex_custom_repack_exit(into, from);\n");
             fmt::print(file, "}}\n");
         }
@@ -339,7 +339,12 @@ void GenerateThunkLibsAction::OnAnalysisComplete(clang::ASTContext& context) {
         std::unordered_map<const clang::Type*, TypeCompatibility> ret;
         const auto host_abi = ComputeDataLayout(context, types);
         for (const auto& [type, type_repack_info] : types) {
-            if (!type_repack_info.pointers_only) {
+            if (type_repack_info.emit_layout_wrappers) {
+                // Assume incompatible, since this annotation is set when
+                // compatibility checks would otherwise fail (e.g. due to
+                // circular references)
+                ret.emplace(type, TypeCompatibility::None);
+            } else if (!type_repack_info.pointers_only) {
                 GetTypeCompatibility(context, type, host_abi, ret);
             }
         }
diff --git a/ThunkLibs/GuestLibs/CMakeLists.txt b/ThunkLibs/GuestLibs/CMakeLists.txt
index f68245431c..4f7312d312 100644
--- a/ThunkLibs/GuestLibs/CMakeLists.txt
+++ b/ThunkLibs/GuestLibs/CMakeLists.txt
@@ -217,10 +217,6 @@ if (BITNESS EQUAL 64)
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp)
   add_guest_lib(Xfixes "libXfixes.so.3")
 
-  generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
-  target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
-  add_guest_lib(vulkan "libvulkan.so.1")
-
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -265,6 +261,10 @@ if (BITNESS EQUAL 64)
   add_guest_lib(drm "libdrm.so.2")
 endif()
 
+generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp)
+target_include_directories(libvulkan-guest-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
+add_guest_lib(vulkan "libvulkan.so.1")
+
 generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp)
 add_guest_lib(wayland-client "libwayland-client.so.0.20.0")
 
diff --git a/ThunkLibs/HostLibs/CMakeLists.txt b/ThunkLibs/HostLibs/CMakeLists.txt
index edc3e16587..eb03bf2d28 100644
--- a/ThunkLibs/HostLibs/CMakeLists.txt
+++ b/ThunkLibs/HostLibs/CMakeLists.txt
@@ -148,10 +148,6 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   generate(libXfixes ${CMAKE_CURRENT_SOURCE_DIR}/../libXfixes/libXfixes_interface.cpp ${GUEST_BITNESS})
   add_host_lib(Xfixes ${GUEST_BITNESS})
 
-  generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp ${GUEST_BITNESS})
-  target_include_directories(libvulkan-${GUEST_BITNESS}-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
-  add_host_lib(vulkan ${GUEST_BITNESS})
-
   find_package(PkgConfig)
   pkg_search_module(XCB REQUIRED xcb)
   version_to_variables(${XCB_VERSION} XCB)
@@ -201,6 +197,10 @@ foreach(GUEST_BITNESS IN LISTS BITNESS_LIST)
   generate(libfex_thunk_test ${CMAKE_CURRENT_SOURCE_DIR}/../libfex_thunk_test/libfex_thunk_test_interface.cpp ${GUEST_BITNESS})
   add_host_lib(fex_thunk_test ${GUEST_BITNESS})
 
+  generate(libvulkan ${CMAKE_CURRENT_SOURCE_DIR}/../libvulkan/libvulkan_interface.cpp ${GUEST_BITNESS})
+  target_include_directories(libvulkan-${GUEST_BITNESS}-deps INTERFACE ${FEX_PROJECT_SOURCE_DIR}/External/Vulkan-Headers/include/)
+  add_host_lib(vulkan ${GUEST_BITNESS})
+
   generate(libwayland-client ${CMAKE_CURRENT_SOURCE_DIR}/../libwayland-client/libwayland-client_interface.cpp ${GUEST_BITNESS})
   add_host_lib(wayland-client ${GUEST_BITNESS})
 endforeach()
diff --git a/ThunkLibs/include/common/Host.h b/ThunkLibs/include/common/Host.h
index 814c1875b6..d11b445e95 100644
--- a/ThunkLibs/include/common/Host.h
+++ b/ThunkLibs/include/common/Host.h
@@ -144,6 +144,12 @@ struct __attribute__((packed)) guest_layout {
   }
 };
 
+template<typename T, std::size_t N>
+struct __attribute__((packed)) guest_layout<T[N]> {
+  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;
+  std::array<guest_layout<type>, N> data;
+};
+
 template<typename T>
 struct guest_layout<T*> {
 #ifdef IS_32BIT_THUNK
@@ -241,6 +247,17 @@ const host_layout<T>& to_host_layout(const T& t) {
   return reinterpret_cast<const host_layout<T>&>(t);
 }
 
+template<typename T, size_t N>
+struct host_layout<T[N]> {
+  std::array<T, N> data;
+
+  explicit host_layout(const guest_layout<T[N]>& from) {
+    for (size_t i = 0; i < N; ++i) {
+      data[i] = host_layout<T> { from.data[i] }.data;
+    }
+  }
+};
+
 template<typename T>
 constexpr bool is_long_or_longlong =
     std::is_same_v<T, long> ||
diff --git a/ThunkLibs/libfex_thunk_test/Host.cpp b/ThunkLibs/libfex_thunk_test/Host.cpp
index 86ece9e36e..17abb0cda0 100644
--- a/ThunkLibs/libfex_thunk_test/Host.cpp
+++ b/ThunkLibs/libfex_thunk_test/Host.cpp
@@ -4,9 +4,10 @@ tags: thunklibs|fex_thunk_test
 $end_info$
 */
 
-#include <cstddef>
 #include <dlfcn.h>
 
+#include <unordered_map>
+
 #include "common/Host.h"
 
 #include "api.h"
@@ -29,4 +30,84 @@ bool fex_custom_repack_exit(guest_layout<CustomRepackedType>& to, host_layout<Cu
   return false;
 }
 
+template<StructType TypeIndex, typename Type>
+static const TestBaseStruct* convert(const TestBaseStruct* source) {
+    // Using malloc here since no easily available type information is available at the time of destruction.
+    auto guest_next = reinterpret_cast<guest_layout<Type>*>((void*)source);
+    auto child_mem = (char*)aligned_alloc(alignof(host_layout<Type>), sizeof(host_layout<Type>));
+    auto child = new (child_mem) host_layout<Type> { *guest_next };
+
+    fex_custom_repack_entry(*child, *reinterpret_cast<guest_layout<Type>*>((void*)(source)));
+
+    return (const TestBaseStruct*)child;
+}
+
+template<StructType TypeIndex, typename Type>
+static void convert_to_guest(void* into, const TestBaseStruct* from) {
+    auto typed_into = (guest_layout<Type>*)into;
+    auto oldNext = typed_into->data.Next;
+    *typed_into = to_guest(to_host_layout(*(Type*)from));
+    typed_into->data.Next = oldNext;
+
+    fex_custom_repack_exit(*typed_into, to_host_layout(*(Type*)from));
+}
+
+template<StructType TypeIndex, typename Type>
+inline constexpr std::pair<StructType, std::pair<const TestBaseStruct*(*)(const TestBaseStruct*), void(*)(void*, const TestBaseStruct*)>> converters =
+  { TypeIndex, { convert<TypeIndex, Type>, convert_to_guest<TypeIndex, Type> } };
+
+static std::unordered_map<StructType, std::pair<const TestBaseStruct*(*)(const TestBaseStruct*), void(*)(void*, const TestBaseStruct*)>> next_handlers {
+    converters<StructType::Struct1, TestStruct1>,
+    converters<StructType::Struct2, TestStruct2>,
+};
+
+static void default_fex_custom_repack_entry(TestBaseStruct& into, const guest_layout<TestBaseStruct>* from) {
+  if (!from->data.Next.get_pointer()) {
+      into.Next = nullptr;
+      return;
+  }
+  auto typed_source = reinterpret_cast<const guest_layout<TestBaseStruct>*>(from->data.Next.get_pointer());
+
+  auto next_handler = next_handlers.at(StructType { typed_source->data.Type.data });
+
+  into.Next = (TestBaseStruct*)next_handler.first((const TestBaseStruct*)typed_source);
+}
+
+static void default_fex_custom_repack_reverse(guest_layout<TestBaseStruct>& into, const TestBaseStruct* from) {
+  auto NextHost = from->Next;
+  if (!NextHost) {
+    return;
+  }
+
+  auto next_handler = next_handlers.at(static_cast<StructType>(into.data.Next.get_pointer()->data.Type.data));
+  next_handler.second((void*)into.data.Next.get_pointer(), from->Next);
+
+  free((void*)NextHost);
+}
+
+#define CREATE_INFO_DEFAULT_CUSTOM_REPACK(name) \
+  void fex_custom_repack_entry(host_layout<name>& into, const guest_layout<name>& from) { \
+    default_fex_custom_repack_entry(*(TestBaseStruct*)&into.data, reinterpret_cast<const guest_layout<TestBaseStruct>*>(&from)); \
+  } \
+   \
+  bool fex_custom_repack_exit(guest_layout<name>& into, const host_layout<name>& from) { \
+    auto prev_next = into.data.Next; \
+    default_fex_custom_repack_reverse(*reinterpret_cast<guest_layout<TestBaseStruct>*>(&into), &reinterpret_cast<const TestBaseStruct&>(from.data)); \
+    into = to_guest(from); \
+    into.data.Next = prev_next; \
+    return true; \
+  }
+
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(TestStruct1)
+CREATE_INFO_DEFAULT_CUSTOM_REPACK(TestStruct2)
+
+void fex_custom_repack_entry(host_layout<TestBaseStruct>&, const guest_layout<TestBaseStruct>&) {
+  std::abort();
+}
+
+bool fex_custom_repack_exit(guest_layout<TestBaseStruct>&, const host_layout<TestBaseStruct>&) {
+  std::abort();
+  return false;
+}
+
 EXPORTS(libfex_thunk_test)
diff --git a/ThunkLibs/libfex_thunk_test/api.h b/ThunkLibs/libfex_thunk_test/api.h
index 1503857d3c..ad2f394ac9 100644
--- a/ThunkLibs/libfex_thunk_test/api.h
+++ b/ThunkLibs/libfex_thunk_test/api.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstdint>
+#include <limits>
 
 extern "C" {
 
@@ -74,4 +75,36 @@ enum DivType : uint32_t {};
 #endif
 int FunctionWithDivergentSignature(DivType, DivType, DivType, DivType);
 
+
+/// Interfaces used to test Vulkan-like APIs
+
+// Equivalent of VkStructureType
+enum class StructType {
+    Struct1,
+    Struct2,
+};
+
+// Equivalent of VkBaseInStructure
+struct TestBaseStruct {
+    TestBaseStruct* Next;
+    StructType Type;
+};
+
+// Equivalent of e.g. VkImageCreateInfo
+struct TestStruct1 {
+    const void* Next;
+    StructType Type; // StructType::Struct1
+    uint8_t Data2;
+    uint8_t pad0[3];
+    int Data1;
+};
+
+struct TestStruct2 {
+    const void* Next;
+    StructType Type;  // StructType::Struct2
+    int Data1;
+};
+
+int ReadData1(TestStruct1*, int depth);
+
 }
diff --git a/ThunkLibs/libfex_thunk_test/lib.cpp b/ThunkLibs/libfex_thunk_test/lib.cpp
index 0fbe9a1c10..8f59ad0375 100644
--- a/ThunkLibs/libfex_thunk_test/lib.cpp
+++ b/ThunkLibs/libfex_thunk_test/lib.cpp
@@ -1,5 +1,8 @@
 #include "api.h"
 
+#include <cstdio>
+#include <cstddef>
+
 extern "C" {
 
 uint32_t GetDoubledValue(uint32_t input) {
@@ -59,4 +62,28 @@ int FunctionWithDivergentSignature(DivType a, DivType b, DivType c, DivType d) {
   return ((uint8_t)a << 24) | ((uint8_t)b << 16) | ((uint8_t)c << 8) | (uint8_t)d;
 }
 
+int ReadData1(TestStruct1* data, int depth) {
+  auto* base = (TestBaseStruct*)data;
+  for (int i = 0; i != depth; ++i) {
+    if (!base) {
+      return -1;
+    }
+    base = base->Next;
+  }
+  if (!base) {
+    return -1;
+  }
+
+  switch (base->Type) {
+  case StructType::Struct1:
+    return ((TestStruct1*)base)->Data1;
+
+  case StructType::Struct2:
+    return ((TestStruct2*)base)->Data1;
+
+  default:
+    return -2;
+  }
+}
+
 } // extern "C"
diff --git a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
index 8923722f36..549b1622ec 100644
--- a/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
+++ b/ThunkLibs/libfex_thunk_test/libfex_thunk_test_interface.cpp
@@ -35,3 +35,9 @@ template<> struct fex_gen_config<&CustomRepackedType::data> : fexgen::custom_rep
 template<> struct fex_gen_config<RanCustomRepack> {};
 
 template<> struct fex_gen_config<FunctionWithDivergentSignature> {};
+
+template<> struct fex_gen_config<&TestBaseStruct::Next> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&TestStruct1::Next> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&TestStruct2::Next> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<ReadData1> {};
diff --git a/ThunkLibs/libvulkan/Host.cpp b/ThunkLibs/libvulkan/Host.cpp
index 1cfaa42275..430bbd7164 100644
--- a/ThunkLibs/libvulkan/Host.cpp
+++ b/ThunkLibs/libvulkan/Host.cpp
@@ -14,13 +14,24 @@ tags: thunklibs|Vulkan
 
 #include "common/Host.h"
 
+#include <cassert>
 #include <cstring>
 #include <mutex>
 #include <unordered_map>
+#include <span>
 #include <string_view>
+#include <vector>
 
 #include <dlfcn.h>
 
+#ifdef IS_32BIT_THUNK
+// Union type embedded in VkDescriptorGetInfoEXT
+template<>
+struct guest_layout<VkDescriptorDataEXT> {
+  char union_storage[8];
+};
+#endif
+
 #include "thunkgen_host_libvulkan.inl"
 
 static bool SetupInstance{};
@@ -79,18 +90,28 @@ static VkResult FEXFN_IMPL(vkCreateInstance)(const VkInstanceCreateInfo* a_0, co
 
   VkInstance out;
   auto ret = LDR_PTR(vkCreateInstance)(vk_struct_base, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_2.get_pointer() = to_guest(to_host_layout(out));
-  }
+  *a_2.get_pointer() = to_guest(to_host_layout(out));
   return ret;
 }
 
-static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3){
+static VkResult FEXFN_IMPL(vkCreateDevice)(VkPhysicalDevice a_0, const VkDeviceCreateInfo* a_1, const VkAllocationCallbacks* a_2, guest_layout<VkDevice*> a_3) {
   VkDevice out;
   auto ret = LDR_PTR(vkCreateDevice)(a_0, a_1, nullptr, &out);
-  if (ret == VK_SUCCESS) {
-    *a_3.get_pointer() = to_guest(to_host_layout(out));
-  }
+  *a_3.get_pointer() = to_guest(to_host_layout(out));
+
+  // Reload device-specific function pointers used in custom implementations.
+  // This is only done in advance for functions that don't take a VkDevice
+  // argument. Since this breaks multi-device scenarios, other functions reload
+  // the function pointer on-demand.
+  // NOTE: Running KHR-GLES31.core.compute_shader.simple-compute-shared_context with zink may trigger related issues
+  // TODO: Support multi-device scenarios everywhere
+#ifdef IS_32BIT_THUNK
+  fexldr_ptr_libvulkan_vkCmdSetVertexInputEXT = (PFN_vkCmdSetVertexInputEXT)fexldr_ptr_libvulkan_vkGetDeviceProcAddr(out, "vkCmdSetVertexInputEXT");
+  fexldr_ptr_libvulkan_vkQueueSubmit = (PFN_vkQueueSubmit)fexldr_ptr_libvulkan_vkGetDeviceProcAddr(out, "vkQueueSubmit");
+#else
+  // No functions affected on 64-bit
+#endif
+
   return ret;
 }
 
@@ -131,6 +152,141 @@ static VkResult FEXFN_IMPL(vkCreateDebugUtilsMessengerEXT)(
   return LDR_PTR(vkCreateDebugUtilsMessengerEXT)(a_0, &overridden_callback, nullptr, a_3);
 }
 
+#ifdef IS_32BIT_THUNK
+VkResult fexfn_impl_libvulkan_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* count, guest_layout<VkPhysicalDevice*> devices) {
+  if (!devices.get_pointer()) {
+    return fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, nullptr);
+  }
+
+  auto input_count = *count;
+  std::vector<VkPhysicalDevice> out(input_count);
+  auto ret = fexldr_ptr_libvulkan_vkEnumeratePhysicalDevices(instance, count, out.data());
+  for (size_t i = 0; i < std::min(input_count, *count); ++i) {
+    devices.get_pointer()[i] = to_guest(to_host_layout(out[i]));
+  }
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkGetDeviceQueue(VkDevice device, uint32_t family_index, uint32_t queue_index, guest_layout<VkQueue*> queue) {
+  VkQueue out;
+  (void*&)fexldr_ptr_libvulkan_vkGetDeviceQueue = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkGetDeviceQueue");
+  fexldr_ptr_libvulkan_vkGetDeviceQueue(device, family_index, queue_index, &out);
+  *queue.get_pointer() = to_guest(to_host_layout(out));
+}
+
+VkResult fexfn_impl_libvulkan_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* info, guest_layout<VkCommandBuffer*> buffers) {
+  std::vector<VkCommandBuffer> out(info->commandBufferCount);
+  (void*&)fexldr_ptr_libvulkan_vkAllocateCommandBuffers = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkAllocateCommandBuffers");
+  auto ret = fexldr_ptr_libvulkan_vkAllocateCommandBuffers(device, info, out.data());
+  if (ret == VK_SUCCESS) {
+    for (size_t i = 0; i < info->commandBufferCount; ++i) {
+      buffers.get_pointer()[i] = to_guest(to_host_layout(out[i]));
+    }
+  }
+  return ret;
+}
+
+VkResult fexfn_impl_libvulkan_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, guest_layout<void**> data) {
+  host_layout<void*> host_data {};
+  void* mapped;
+  (void*&)fexldr_ptr_libvulkan_vkMapMemory = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkMapMemory");
+  auto ret = fexldr_ptr_libvulkan_vkMapMemory(device, memory, offset, size, flags, &mapped);
+  if (ret == VK_SUCCESS) {
+    host_data.data = mapped;
+    *data.get_pointer() = to_guest(host_data);
+  }
+  return ret;
+}
+
+// Allocates storage on the heap that must be de-allocated using delete[] or DeleteRepackedStructArray
+template<bool NeedsRepack = true, typename T>
+std::span<std::remove_cv_t<T>> RepackStructArray(uint32_t Count, const guest_layout<T*> GuestData) {
+  if (!GuestData.get_pointer() || Count == 0) {
+    return {};
+  }
+
+  auto HostData = new std::remove_cv_t<T>[Count];
+  for (size_t i = 0; i < Count; ++i) {
+    auto& GuestElement = (const guest_layout<std::remove_cv_t<T>>&)GuestData.get_pointer()[i];
+    auto Element = host_layout<std::remove_cv_t<T>> { GuestElement };
+    if constexpr (NeedsRepack) {
+      fex_apply_custom_repacking_entry(Element, GuestElement);
+    }
+    HostData[i] = Element.data;
+  }
+  return { HostData, Count };
+}
+
+template<typename T>
+void DeleteRepackedStructArray(uint32_t Count, T* HostData, guest_layout<T*>& GuestData) {
+  for (uint32_t i = 0; i < Count; ++i) {
+    fex_apply_custom_repacking_exit(GuestData.get_pointer()[i], to_host_layout(HostData[i]));
+  }
+  delete[] HostData;
+}
+
+void fexfn_impl_libvulkan_vkCmdSetVertexInputEXT(
+    VkCommandBuffer Buffer,
+    uint32_t BindingDescCount, guest_layout<const VkVertexInputBindingDescription2EXT*> GuestBindingDescs,
+    uint32_t AttributeDescCount, guest_layout<const VkVertexInputAttributeDescription2EXT*> GuestAttributeDescs) {
+
+  assert(GuestBindingDescs.get_pointer() && BindingDescCount > 0);
+  assert(GuestAttributeDescs.get_pointer() && AttributeDescCount > 0);
+
+  auto BindingDescs = RepackStructArray(BindingDescCount, GuestBindingDescs);
+  auto AttributeDescs = RepackStructArray(AttributeDescCount, GuestAttributeDescs);
+
+  fexldr_ptr_libvulkan_vkCmdSetVertexInputEXT(  Buffer,
+                                                BindingDescCount, BindingDescs.data(),
+                                                AttributeDescCount, AttributeDescs.data());
+
+  delete[] AttributeDescs.data();
+  delete[] BindingDescs.data();
+}
+
+void fexfn_impl_libvulkan_vkUpdateDescriptorSets(
+    VkDevice device, unsigned int descriptorWriteCount,
+    guest_layout<const VkWriteDescriptorSet*> pDescriptorWrites,
+    unsigned int descriptorCopyCount, guest_layout<const VkCopyDescriptorSet*> pDescriptorCopies) {
+
+  auto HostDescriptorWrites = RepackStructArray(descriptorWriteCount, pDescriptorWrites);
+  auto HostDescriptorCopies = RepackStructArray(descriptorCopyCount, pDescriptorCopies);
+
+  (void*&)fexldr_ptr_libvulkan_vkUpdateDescriptorSets = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkUpdateDescriptorSets");
+  fexldr_ptr_libvulkan_vkUpdateDescriptorSets(device, descriptorWriteCount, HostDescriptorWrites.data(), descriptorCopyCount, HostDescriptorCopies.data());
+
+  delete[] HostDescriptorCopies.data();
+  delete[] HostDescriptorWrites.data();
+}
+
+VkResult fexfn_impl_libvulkan_vkQueueSubmit(VkQueue queue, uint32_t submit_count,
+                                            guest_layout<const VkSubmitInfo*> submit_infos, VkFence fence) {
+
+  auto HostSubmitInfos = RepackStructArray(submit_count, submit_infos);
+  auto ret = fexldr_ptr_libvulkan_vkQueueSubmit(queue, submit_count, HostSubmitInfos.data(), fence);
+  delete[] HostSubmitInfos.data();
+  return ret;
+}
+
+void fexfn_impl_libvulkan_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t num_buffers,
+                                            guest_layout<const VkCommandBuffer*> buffers) {
+
+  auto HostBuffers = RepackStructArray<false>(num_buffers, buffers);
+  (void*&)fexldr_ptr_libvulkan_vkFreeCommandBuffers = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkFreeCommandBuffers");
+  fexldr_ptr_libvulkan_vkFreeCommandBuffers(device, pool, num_buffers, HostBuffers.data());
+  delete[] HostBuffers.data();
+}
+
+VkResult fexfn_impl_libvulkan_vkGetPipelineCacheData(VkDevice device, VkPipelineCache cache, guest_layout<uint32_t*> guest_data_size, void* data) {
+  size_t data_size = guest_data_size.get_pointer()->data;
+  (void*&)fexldr_ptr_libvulkan_vkGetPipelineCacheData = (void*)LDR_PTR(vkGetDeviceProcAddr)(device, "vkGetPipelineCacheData");
+  auto ret = fexldr_ptr_libvulkan_vkGetPipelineCacheData(device, cache, &data_size, data);
+  *guest_data_size.get_pointer() = data_size;
+  return ret;
+}
+
+#endif
+
 static PFN_vkVoidFunction LookupCustomVulkanFunction(const char* a_1) {
   using namespace std::string_view_literals;
 
@@ -144,6 +300,26 @@ static PFN_vkVoidFunction LookupCustomVulkanFunction(const char* a_1) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateMemory;
   } else if (a_1 == "vkFreeMemory"sv) {
       return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeMemory;
+#ifdef IS_32BIT_THUNK
+  } else if (a_1 == "vkAllocateCommandBuffers"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkAllocateCommandBuffers;
+  } else if (a_1 == "vkEnumeratePhysicalDevices"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkEnumeratePhysicalDevices;
+  } else if (a_1 == "vkFreeCommandBuffers"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkFreeCommandBuffers;
+  } else if (a_1 == "vkGetDeviceQueue"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetDeviceQueue;
+  } else if (a_1 == "vkGetPipelineCacheData"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkGetPipelineCacheData;
+  } else if (a_1 == "vkMapMemory"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkMapMemory;
+  } else if (a_1 == "vkQueueSubmit"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkQueueSubmit;
+  } else if (a_1 == "vkCmdSetVertexInputEXT"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkCmdSetVertexInputEXT;
+  } else if (a_1 == "vkUpdateDescriptorSets"sv) {
+      return (PFN_vkVoidFunction)fexfn_impl_libvulkan_vkUpdateDescriptorSets;
+#endif
   }
   return nullptr;
 }
@@ -176,4 +352,1573 @@ static PFN_vkVoidFunction FEXFN_IMPL(vkGetInstanceProcAddr)(VkInstance a_0, cons
   return LDR_PTR(vkGetInstanceProcAddr)(a_0, a_1);
 }
 
+#ifdef IS_32BIT_THUNK
+template<VkStructureType TypeIndex, typename Type>
+static VkBaseOutStructure* convert(const guest_layout<VkBaseOutStructure>* source) {
+    // Using malloc here since no easily available type information is available at the time of destruction.
+    auto typed_source = reinterpret_cast<const guest_layout<Type>*>(source);
+    auto child_mem = (char*)aligned_alloc(alignof(host_layout<Type>), sizeof(host_layout<Type>));
+    auto child = new (child_mem) host_layout<Type> { *typed_source };
+
+    fex_custom_repack_entry(*child, *typed_source);
+
+    return reinterpret_cast<VkBaseOutStructure*>(&child->data);
+}
+
+template<VkStructureType TypeIndex, typename Type>
+static void convert_to_guest(void* into, const VkBaseOutStructure* from) {
+    auto typed_into = reinterpret_cast<guest_layout<Type>*>(into);
+    auto oldNext = typed_into->data.pNext; // TODO: This assumes Vulkan never modifies pNext internally
+    *typed_into = to_guest(to_host_layout(*(Type*)from));
+    typed_into->data.pNext = oldNext;
+
+    fex_custom_repack_exit(*typed_into, to_host_layout(*(Type*)from));
+}
+
+template<VkStructureType TypeIndex, typename Type>
+inline constexpr std::pair<VkStructureType, std::pair<VkBaseOutStructure*(*)(const guest_layout<VkBaseOutStructure>*), void(*)(void*, const VkBaseOutStructure*)>> converters =
+  { TypeIndex, { convert<TypeIndex, Type>, convert_to_guest<TypeIndex, Type> } };
+
+// NOTE: Not all Vulkan structures with pNext members are listed here. This is because excluding structs exclusively used as top-level entries is useful to detect repacking bugs.
+static std::unordered_map<VkStructureType, std::pair<VkBaseOutStructure*(*)(const guest_layout<VkBaseOutStructure>*), void(*)(void*, const VkBaseOutStructure*)>> next_handlers {
+    converters<VkStructureType::VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV, VkAccelerationStructureMotionInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, VkAmigoProfilingSubmitInfoSEC>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, VkAttachmentDescriptionStencilLayout>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, VkAttachmentReferenceStencilLayout>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, VkAttachmentSampleCountInfoAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, VkBindBufferMemoryDeviceGroupInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, VkBindImageMemoryDeviceGroupInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, VkBindImageMemorySwapchainInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, VkBindImagePlaneMemoryInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, VkBufferDeviceAddressCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, VkBufferOpaqueCaptureAddressCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR, VkBufferUsageFlags2CreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, VkCommandBufferInheritanceConditionalRenderingInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, VkCommandBufferInheritanceRenderingInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, VkCommandBufferInheritanceRenderPassTransformInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, VkCommandBufferInheritanceViewportScissorInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM, VkCopyCommandTransformInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, VkDebugReportCallbackCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, VkDebugUtilsMessengerCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, VkDebugUtilsObjectNameInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, VkDedicatedAllocationBufferCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, VkDedicatedAllocationImageCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, VkDedicatedAllocationMemoryAllocateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT, VkDepthBiasRepresentationInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, VkDescriptorBufferBindingPushDescriptorBufferHandleEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, VkDescriptorPoolInlineUniformBlockCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, VkDescriptorSetLayoutBindingFlagsCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, VkDescriptorSetVariableDescriptorCountAllocateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, VkDescriptorSetVariableDescriptorCountLayoutSupport>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT, VkDeviceAddressBindingCallbackDataEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, VkDeviceDiagnosticsConfigCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, VkDeviceGroupBindSparseInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, VkDeviceGroupCommandBufferBeginInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, VkDeviceGroupPresentInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, VkDeviceGroupRenderPassBeginInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, VkDeviceGroupSubmitInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, VkDeviceGroupSwapchainCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, VkDeviceMemoryOverallocationCreateInfoAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, VkDevicePrivateDataCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, VkDeviceQueueGlobalPriorityCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, VkDisplayNativeHdrSurfaceCapabilitiesAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, VkDisplayPresentInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, VkExportFenceCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, VkExportMemoryAllocateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, VkExportMemoryAllocateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, VkExportSemaphoreCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VkExternalImageFormatProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, VkExternalMemoryAcquireUnmodifiedEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, VkExternalMemoryBufferCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, VkExternalMemoryImageCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, VkExternalMemoryImageCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, VkFilterCubicImageViewImageFormatPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, VkFormatProperties3>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, VkGraphicsPipelineLibraryCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, VkHostImageCopyDevicePerformanceQueryEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, VkImageCompressionControlEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, VkImageCompressionPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, VkImageDrmFormatModifierListCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VkImageFormatListCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, VkImagePlaneMemoryRequirementsInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VkImageStencilUsageCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, VkImageSwapchainCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, VkImageViewASTCDecodeModeEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, VkImageViewMinLodCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, VkImageViewSampleWeightCreateInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT, VkImageViewSlicedCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, VkImageViewUsageCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VkImportMemoryFdInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VkMemoryAllocateFlagsInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, VkMemoryBarrier2>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VkMemoryDedicatedAllocateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VkMemoryDedicatedRequirements>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, VkMemoryOpaqueCaptureAddressAllocateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, VkMemoryPriorityAllocateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, VkMultisampledRenderToSingleSampledInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, VkMultiviewPerViewAttributesInfoNVX>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, VkOpticalFlowImageFormatInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, VkPerformanceQuerySubmitInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VkPhysicalDevice16BitStorageFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, VkPhysicalDevice4444FormatsFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VkPhysicalDevice8BitStorageFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, VkPhysicalDeviceAccelerationStructureFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, VkPhysicalDeviceAccelerationStructurePropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, VkPhysicalDeviceAddressBindingReportFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, VkPhysicalDeviceAmigoProfilingFeaturesSEC>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, VkPhysicalDeviceASTCDecodeFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, VkPhysicalDeviceBufferDeviceAddressFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, VkPhysicalDeviceCoherentMemoryFeaturesAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, VkPhysicalDeviceColorWriteEnableFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VkPhysicalDeviceConditionalRenderingFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, VkPhysicalDeviceCooperativeMatrixFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VkPhysicalDeviceCooperativeMatrixFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, VkPhysicalDeviceCooperativeMatrixPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, VkPhysicalDeviceCooperativeMatrixPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VkPhysicalDeviceCornerSampledImageFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VkPhysicalDeviceCoverageReductionModeFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, VkPhysicalDeviceCustomBorderColorFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, VkPhysicalDeviceCustomBorderColorPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, VkPhysicalDeviceDepthBiasControlFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, VkPhysicalDeviceDepthClipControlFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, VkPhysicalDeviceDepthStencilResolveProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, VkPhysicalDeviceDescriptorIndexingFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, VkPhysicalDeviceDescriptorIndexingProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, VkPhysicalDeviceDiagnosticsConfigFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, VkPhysicalDeviceDriverProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, VkPhysicalDeviceDrmPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, VkPhysicalDeviceDynamicRenderingFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VkPhysicalDeviceExclusiveScissorFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, VkPhysicalDeviceExternalImageFormatInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, VkPhysicalDeviceFaultFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, VkPhysicalDeviceFeatures2>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, VkPhysicalDeviceFloatControlsProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, VkPhysicalDeviceFragmentShadingRateFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, VkPhysicalDeviceFragmentShadingRatePropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, VkPhysicalDeviceHostImageCopyFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT, VkPhysicalDeviceHostImageCopyPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, VkPhysicalDeviceHostQueryResetFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, VkPhysicalDeviceIDProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, VkPhysicalDeviceImageCompressionControlFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, VkPhysicalDeviceImageDrmFormatModifierInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, VkPhysicalDeviceImagelessFramebufferFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, VkPhysicalDeviceImageProcessingFeaturesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, VkPhysicalDeviceImageProcessingPropertiesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, VkPhysicalDeviceImageRobustnessFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, VkPhysicalDeviceImageViewImageFormatInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VkPhysicalDeviceIndexTypeUint8FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, VkPhysicalDeviceInheritedViewportScissorFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, VkPhysicalDeviceInlineUniformBlockFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, VkPhysicalDeviceInlineUniformBlockProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, VkPhysicalDeviceLegacyDitheringFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, VkPhysicalDeviceLinearColorAttachmentFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VkPhysicalDeviceLineRasterizationFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, VkPhysicalDeviceLineRasterizationPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, VkPhysicalDeviceMaintenance3Properties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, VkPhysicalDeviceMaintenance4Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, VkPhysicalDeviceMaintenance4Properties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, VkPhysicalDeviceMaintenance5FeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, VkPhysicalDeviceMaintenance5PropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, VkPhysicalDeviceMemoryBudgetPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, VkPhysicalDeviceMemoryDecompressionFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, VkPhysicalDeviceMemoryDecompressionPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, VkPhysicalDeviceMeshShaderFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VkPhysicalDeviceMeshShaderFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT, VkPhysicalDeviceMeshShaderPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, VkPhysicalDeviceMeshShaderPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, VkPhysicalDeviceMultiDrawFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, VkPhysicalDeviceMultiDrawPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VkPhysicalDeviceMultiviewFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, VkPhysicalDeviceMultiviewProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, VkPhysicalDeviceOpacityMicromapPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, VkPhysicalDeviceOpticalFlowFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV, VkPhysicalDeviceOpticalFlowPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, VkPhysicalDevicePCIBusInfoPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VkPhysicalDevicePerformanceQueryFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, VkPhysicalDevicePerformanceQueryPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, VkPhysicalDevicePipelineCreationCacheControlFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, VkPhysicalDevicePipelinePropertiesFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, VkPhysicalDevicePipelineRobustnessFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT, VkPhysicalDevicePipelineRobustnessPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, VkPhysicalDevicePointClippingProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, VkPhysicalDevicePresentBarrierFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, VkPhysicalDevicePresentIdFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, VkPhysicalDevicePresentWaitFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, VkPhysicalDevicePrivateDataFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, VkPhysicalDeviceProtectedMemoryFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, VkPhysicalDeviceProtectedMemoryProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, VkPhysicalDeviceProvokingVertexFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, VkPhysicalDeviceProvokingVertexPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, VkPhysicalDevicePushDescriptorPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, VkPhysicalDeviceRayQueryFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, VkPhysicalDeviceRayTracingPipelineFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, VkPhysicalDeviceRayTracingPipelinePropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, VkPhysicalDeviceRayTracingPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, VkPhysicalDeviceRobustness2FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, VkPhysicalDeviceRobustness2PropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, VkPhysicalDeviceSampleLocationsPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, VkPhysicalDeviceSamplerFilterMinmaxProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VkPhysicalDeviceSamplerYcbcrConversionFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, VkPhysicalDeviceScalarBlockLayoutFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, VkPhysicalDeviceShaderAtomicInt64Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VkPhysicalDeviceShaderClockFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, VkPhysicalDeviceShaderCoreProperties2AMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, VkPhysicalDeviceShaderCorePropertiesAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM, VkPhysicalDeviceShaderCorePropertiesARM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VkPhysicalDeviceShaderDrawParametersFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, VkPhysicalDeviceShaderFloat16Int8Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VkPhysicalDeviceShaderImageFootprintFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, VkPhysicalDeviceShaderIntegerDotProductFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, VkPhysicalDeviceShaderIntegerDotProductProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, VkPhysicalDeviceShaderObjectFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, VkPhysicalDeviceShaderObjectPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, VkPhysicalDeviceShaderTerminateInvocationFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, VkPhysicalDeviceShaderTileImageFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, VkPhysicalDeviceShaderTileImagePropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VkPhysicalDeviceShadingRateImageFeaturesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, VkPhysicalDeviceShadingRateImagePropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, VkPhysicalDeviceSubgroupProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, VkPhysicalDeviceSubgroupSizeControlFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, VkPhysicalDeviceSubgroupSizeControlProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, VkPhysicalDeviceSynchronization2Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, VkPhysicalDeviceTexelBufferAlignmentProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, VkPhysicalDeviceTextureCompressionASTCHDRFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, VkPhysicalDeviceTilePropertiesFeaturesQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VkPhysicalDeviceTimelineSemaphoreFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, VkPhysicalDeviceTimelineSemaphoreProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, VkPhysicalDeviceTransformFeedbackPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, VkPhysicalDeviceUniformBufferStandardLayoutFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VkPhysicalDeviceVariablePointersFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, VkPhysicalDeviceVulkan11Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, VkPhysicalDeviceVulkan11Properties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, VkPhysicalDeviceVulkan12Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, VkPhysicalDeviceVulkan12Properties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, VkPhysicalDeviceVulkan13Features>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, VkPhysicalDeviceVulkan13Properties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, VkPhysicalDeviceVulkanMemoryModelFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, VkPipelineColorBlendAdvancedStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, VkPipelineColorWriteCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, VkPipelineCompilerControlCreateInfoAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, VkPipelineCoverageModulationStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, VkPipelineCoverageReductionStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, VkPipelineCoverageToColorStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR, VkPipelineCreateFlags2CreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, VkPipelineDiscardRectangleStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, VkPipelineFragmentShadingRateEnumStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, VkPipelineFragmentShadingRateStateCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, VkPipelineLibraryCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, VkPipelineRasterizationConservativeStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, VkPipelineRasterizationLineStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, VkPipelineRasterizationProvokingVertexStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, VkPipelineRasterizationStateRasterizationOrderAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, VkPipelineRasterizationStateStreamCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, VkPipelineRenderingCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, VkPipelineRepresentativeFragmentTestStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT, VkPipelineRobustnessCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, VkPipelineSampleLocationsStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, VkPipelineShaderStageModuleIdentifierCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, VkPipelineTessellationDomainOriginStateCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, VkPipelineVertexInputDivisorStateCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, VkPipelineViewportDepthClipControlCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, VkPipelineViewportExclusiveScissorStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, VkPipelineViewportSwizzleStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, VkPipelineViewportWScalingStateCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PRESENT_ID_KHR, VkPresentIdKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, VkProtectedSubmitInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, VkQueryPoolPerformanceCreateInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, VkQueryPoolPerformanceQueryCreateInfoINTEL>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, VkQueueFamilyCheckpointProperties2NV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, VkQueueFamilyCheckpointPropertiesNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, VkQueueFamilyGlobalPriorityPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR, VkQueueFamilyQueryResultStatusPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR, VkQueueFamilyVideoPropertiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, VkRenderingFragmentDensityMapAttachmentInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, VkRenderingFragmentShadingRateAttachmentInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, VkRenderPassAttachmentBeginInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, VkRenderPassCreationControlEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, VkRenderPassCreationFeedbackCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, VkRenderPassFragmentDensityMapCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, VkRenderPassInputAttachmentAspectCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VkRenderPassMultiviewCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, VkRenderPassSubpassFeedbackCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, VkRenderPassTransformBeginInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, VkSampleLocationsInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, VkSamplerBorderColorComponentMappingCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, VkSamplerCustomBorderColorCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, VkSamplerReductionModeCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, VkSamplerYcbcrConversionImageFormatProperties>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, VkSamplerYcbcrConversionInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, VkSemaphoreTypeCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, VkShaderModuleCreateInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, VkShaderModuleValidationCacheCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, VkSharedPresentSurfaceCapabilitiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, VkSubpassFragmentDensityMapOffsetEndInfoQCOM>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, VkSubpassResolvePerformanceQueryEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, VkSubpassShadingPipelineCreateInfoHUAWEI>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT, VkSubresourceHostMemcpySizeEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV, VkSurfaceCapabilitiesPresentBarrierNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT, VkSurfacePresentModeCompatibilityEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, VkSurfacePresentModeEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, VkSurfacePresentScalingCapabilitiesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, VkSurfaceProtectedCapabilitiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, VkSwapchainCounterCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, VkSwapchainDisplayNativeHdrCreateInfoAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV, VkSwapchainPresentBarrierCreateInfoNV>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT, VkSwapchainPresentFenceInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT, VkSwapchainPresentModeInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT, VkSwapchainPresentModesCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT, VkSwapchainPresentScalingCreateInfoEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, VkTextureLODGatherFormatPropertiesAMD>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VkTimelineSemaphoreSubmitInfo>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, VkValidationFeaturesEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, VkValidationFlagsEXT>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, VkVideoDecodeCapabilitiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, VkVideoDecodeH264CapabilitiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, VkVideoDecodeH264DpbSlotInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, VkVideoDecodeH264PictureInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, VkVideoDecodeH264ProfileInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, VkVideoDecodeH265CapabilitiesKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, VkVideoDecodeH265DpbSlotInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, VkVideoDecodeH265PictureInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, VkVideoDecodeH265ProfileInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, VkVideoDecodeUsageInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, VkVideoProfileInfoKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, VkWriteDescriptorSetAccelerationStructureKHR>,
+    converters<VkStructureType::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, VkWriteDescriptorSetAccelerationStructureNV>,
+};
+
+static void default_fex_custom_repack_entry(VkBaseOutStructure& into, const guest_layout<VkBaseOutStructure>* from) {
+  if (!from->data.pNext.get_pointer()) {
+      into.pNext = nullptr;
+      return;
+  }
+  auto typed_source = reinterpret_cast<const guest_layout<VkBaseOutStructure>*>(from->data.pNext.get_pointer());
+
+  auto next_handler = next_handlers.find(static_cast<VkStructureType>(typed_source->data.sType.data));
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext\n", typed_source->data.sType.data);
+    std::abort();
+  }
+
+  into.pNext = next_handler->second.first(typed_source);
+}
+
+template<typename T>
+void default_fex_custom_repack_entry(host_layout<T>& into, const guest_layout<T>& from) {
+  default_fex_custom_repack_entry(*(VkBaseOutStructure*)&into.data, reinterpret_cast<const guest_layout<VkBaseOutStructure>*>(&from));
+}
+
+static void default_fex_custom_repack_reverse(guest_layout<VkBaseOutStructure>& into, const VkBaseOutStructure* from) {
+  auto pNextHost = from->pNext;
+  if (!pNextHost) {
+    return;
+  }
+
+  auto next_handler = next_handlers.find(static_cast<VkStructureType>(into.data.pNext.get_pointer()->data.sType.data));
+  if (next_handler == next_handlers.end()) {
+    fprintf(stderr, "ERROR: Unrecognized VkStructureType %u referenced by pNext when converting to guest\n", from->sType);
+    std::abort();
+  }
+  next_handler->second.second((void*)into.data.pNext.get_pointer(), from->pNext);
+
+  free(pNextHost);
+}
+
+// Default repacking functions that only traverses and repacks the pNext chain.
+// If other members need to be repacked, use VULKAN_NONDEFAULT_CUSTOM_REPACK instead
+#define VULKAN_DEFAULT_CUSTOM_REPACK(name) \
+void fex_custom_repack_entry(host_layout<name>& into, const guest_layout<name>& from) { \
+  default_fex_custom_repack_entry(reinterpret_cast<VkBaseOutStructure&>(into.data), &reinterpret_cast<const guest_layout<VkBaseOutStructure>&>(from)); \
+} \
+ \
+bool fex_custom_repack_exit(guest_layout<name>& into, const host_layout<name>& from) { \
+  auto prev_next = into.data.pNext; \
+  default_fex_custom_repack_reverse(*reinterpret_cast<guest_layout<VkBaseOutStructure>*>(&into), &reinterpret_cast<const VkBaseOutStructure&>(from.data)); \
+  into = to_guest(from); \
+  into.data.pNext = prev_next; \
+  return true; \
+}
+
+// Intentionally left empty. This macro doesn't automate anything, but it
+// helps ensure we don't forget any Vulkan types in the list. The actual
+// repacking functions are defined manually later
+#define VULKAN_NONDEFAULT_CUSTOM_REPACK(name)
+
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureBuildGeometryInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureBuildSizesInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureCaptureDescriptorDataInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureDeviceAddressInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureGeometryAabbsDataKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureGeometryInstancesDataKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureGeometryKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureGeometryMotionTrianglesDataNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureGeometryTrianglesDataKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureMemoryRequirementsInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureMotionInfoNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureTrianglesOpacityMicromapEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAccelerationStructureVersionInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAcquireNextImageInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAcquireProfilingLockInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAmigoProfilingSubmitInfoSEC)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkApplicationInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentDescription2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentDescriptionStencilLayout)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentReference2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentReferenceStencilLayout)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkAttachmentSampleCountInfoAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindAccelerationStructureMemoryInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindBufferMemoryDeviceGroupInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindBufferMemoryInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindImageMemoryDeviceGroupInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindImageMemoryInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindImageMemorySwapchainInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindImagePlaneMemoryInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkBindSparseInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBindVideoSessionMemoryInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkBlitImageInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferCaptureDescriptorDataInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferCopy2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferDeviceAddressCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferDeviceAddressInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferImageCopy2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferMemoryBarrier)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferMemoryBarrier2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferMemoryRequirementsInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferOpaqueCaptureAddressCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferUsageFlags2CreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkBufferViewCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCalibratedTimestampInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCheckpointData2NV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCheckpointDataNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferAllocateInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkCommandBufferBeginInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferInheritanceConditionalRenderingInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferInheritanceInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferInheritanceRenderingInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferInheritanceRenderPassTransformInfoQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferInheritanceViewportScissorInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandBufferSubmitInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCommandPoolCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkComputePipelineCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkComputePipelineIndirectBufferInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkConditionalRenderingBeginInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCooperativeMatrixPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCooperativeMatrixPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyAccelerationStructureInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyAccelerationStructureToMemoryInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyBufferInfo2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyBufferToImageInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyCommandTransformInfoQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyDescriptorSet)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyImageInfo2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyImageToBufferInfo2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyImageToImageInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyImageToMemoryInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyMemoryToAccelerationStructureInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyMemoryToImageInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyMemoryToMicromapInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyMicromapInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCopyMicromapToMemoryInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkCuFunctionCreateInfoNVX)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCuLaunchInfoNVX)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkCuModuleCreateInfoNVX)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugMarkerMarkerInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugMarkerObjectNameInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugMarkerObjectTagInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugReportCallbackCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugUtilsLabelEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugUtilsMessengerCallbackDataEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugUtilsMessengerCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugUtilsObjectNameInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDebugUtilsObjectTagInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDedicatedAllocationBufferCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDedicatedAllocationImageCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDedicatedAllocationMemoryAllocateInfoNV)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDependencyInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDepthBiasInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDepthBiasRepresentationInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorAddressInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorBufferBindingInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDescriptorGetInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorPoolCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorPoolInlineUniformBlockCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetBindingReferenceVALVE)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetLayoutBindingFlagsCreateInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDescriptorSetLayoutCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetLayoutHostMappingInfoVALVE)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetLayoutSupport)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetVariableDescriptorCountAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDescriptorSetVariableDescriptorCountLayoutSupport)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDescriptorUpdateTemplateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceAddressBindingCallbackDataEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceBufferMemoryRequirements)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkDeviceCreateInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceDeviceMemoryReportCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceDiagnosticsConfigCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceEventInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceFaultCountsEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceFaultInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupBindSparseInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupCommandBufferBeginInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupDeviceCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupPresentCapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupPresentInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupRenderPassBeginInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupSubmitInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceGroupSwapchainCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceImageMemoryRequirements)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceImageSubresourceInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceMemoryOpaqueCaptureAddressInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceMemoryOverallocationCreateInfoAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceMemoryReportCallbackDataEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDevicePrivateDataCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceQueueCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceQueueGlobalPriorityCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDeviceQueueInfo2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDirectDriverLoadingInfoLUNARG)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDirectDriverLoadingListLUNARG)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayEventInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayModeCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayModeProperties2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayNativeHdrSurfaceCapabilitiesAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayPlaneCapabilities2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayPlaneInfo2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayPlaneProperties2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayPowerInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayPresentInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplayProperties2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkDisplaySurfaceCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDrmFormatModifierPropertiesList2EXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkDrmFormatModifierPropertiesListEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkEventCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExportFenceCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExportMemoryAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExportMemoryAllocateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExportSemaphoreCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalBufferProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalFenceProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalImageFormatProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalMemoryAcquireUnmodifiedEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalMemoryBufferCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalMemoryImageCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalMemoryImageCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkExternalSemaphoreProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFenceCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFenceGetFdInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFilterCubicImageViewImageFormatPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFormatProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFormatProperties3)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkFragmentShadingRateAttachmentInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFramebufferAttachmentImageInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkFramebufferAttachmentsCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFramebufferCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkFramebufferMixedSamplesCombinationNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkGeneratedCommandsInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkGeneratedCommandsMemoryRequirementsInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkGeometryAABBNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkGeometryNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkGeometryTrianglesNV)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkGraphicsPipelineCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkGraphicsPipelineLibraryCreateInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkGraphicsPipelineShaderGroupsCreateInfoNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkGraphicsShaderGroupCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkHeadlessSurfaceCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkHostImageCopyDevicePerformanceQueryEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkHostImageLayoutTransitionInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageBlit2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageCaptureDescriptorDataInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageCompressionControlEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageCompressionPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageCopy2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageCreateInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkImageDrmFormatModifierExplicitCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageDrmFormatModifierListCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageDrmFormatModifierPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageFormatListCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageFormatProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageMemoryBarrier)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageMemoryBarrier2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageMemoryRequirementsInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImagePlaneMemoryRequirementsInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageResolve2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageSparseMemoryRequirementsInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageStencilUsageCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageSubresource2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageSwapchainCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkImageToMemoryCopyEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewAddressPropertiesNVX)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewASTCDecodeModeEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewCaptureDescriptorDataInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewHandleInfoNVX)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewMinLodCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewSampleWeightCreateInfoQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewSlicedCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImageViewUsageCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImportFenceFdInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImportMemoryFdInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkImportMemoryHostPointerInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkImportSemaphoreFdInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkIndirectCommandsLayoutCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkIndirectCommandsLayoutTokenNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkInitializePerformanceApiInfoINTEL)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkInstanceCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMappedMemoryRange)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateFlagsInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryBarrier)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryBarrier2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryDedicatedRequirements)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryFdPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryGetFdInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryGetRemoteAddressInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryHostPointerPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryMapInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryOpaqueCaptureAddressAllocateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryPriorityAllocateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryRequirements2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryToImageCopyEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMemoryUnmapInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkMicromapBuildInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMicromapBuildSizesInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMicromapCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMicromapVersionInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMultisampledRenderToSingleSampledInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMultisamplePropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMultiviewPerViewAttributesInfoNVX)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkMutableDescriptorTypeCreateInfoEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkOpaqueCaptureDescriptorDataCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkOpticalFlowExecuteInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkOpticalFlowImageFormatInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkOpticalFlowImageFormatPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkOpticalFlowSessionCreateInfoNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkOpticalFlowSessionCreatePrivateDataInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceConfigurationAcquireInfoINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceCounterDescriptionKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceCounterKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceMarkerInfoINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceOverrideInfoINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceQuerySubmitInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPerformanceStreamMarkerInfoINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevice16BitStorageFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevice4444FormatsFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevice8BitStorageFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAccelerationStructureFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAccelerationStructurePropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAddressBindingReportFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAmigoProfilingFeaturesSEC)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceASTCDecodeFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceBufferDeviceAddressFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCoherentMemoryFeaturesAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceColorWriteEnableFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceConditionalRenderingFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCooperativeMatrixFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCooperativeMatrixFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCooperativeMatrixPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCooperativeMatrixPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCopyMemoryIndirectPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCornerSampledImageFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCoverageReductionModeFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCustomBorderColorFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceCustomBorderColorPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDepthBiasControlFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDepthClipControlFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDepthClipEnableFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDepthStencilResolveProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorBufferFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorBufferPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorIndexingFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorIndexingProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDiagnosticsConfigFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDiscardRectanglePropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDriverProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDrmPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDynamicRenderingFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExclusiveScissorFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalBufferInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalFenceInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalImageFormatInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceExternalSemaphoreInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFaultFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFeatures2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFloatControlsProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShadingRateKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceFragmentShadingRatePropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceGroupProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceHostImageCopyFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceHostImageCopyPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceHostQueryResetFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceIDProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageCompressionControlFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageDrmFormatModifierInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageFormatInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImagelessFramebufferFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageProcessingFeaturesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageProcessingPropertiesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageRobustnessFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageViewImageFormatInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceImageViewMinLodFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceInheritedViewportScissorFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceInlineUniformBlockFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceInlineUniformBlockProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceLegacyDitheringFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceLinearColorAttachmentFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceLineRasterizationFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceLineRasterizationPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMaintenance3Properties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMaintenance4Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMaintenance4Properties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMaintenance5FeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMaintenance5PropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMemoryBudgetPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMemoryDecompressionFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMemoryDecompressionPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMemoryPriorityFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMemoryProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMeshShaderFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMeshShaderFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMeshShaderPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMeshShaderPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiDrawFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiDrawPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiviewFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMultiviewProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceOpacityMicromapFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceOpacityMicromapPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceOpticalFlowFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceOpticalFlowPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePCIBusInfoPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePerformanceQueryFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePerformanceQueryPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineCreationCacheControlFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelinePropertiesFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineRobustnessFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePipelineRobustnessPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePointClippingProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePresentBarrierFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePresentIdFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePresentWaitFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePrivateDataFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceProtectedMemoryFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceProtectedMemoryProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceProvokingVertexFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceProvokingVertexPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDevicePushDescriptorPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayQueryFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingPipelineFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingPipelinePropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRayTracingPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRobustness2FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceRobustness2PropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSampleLocationsPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSamplerFilterMinmaxProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSamplerYcbcrConversionFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceScalarBlockLayoutFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderAtomicInt64Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderClockFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderCoreProperties2AMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderCorePropertiesAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderCorePropertiesARM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderDrawParametersFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderFloat16Int8Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderImageFootprintFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderIntegerDotProductFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderIntegerDotProductProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderObjectFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderObjectPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderTerminateInvocationFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderTileImageFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShaderTileImagePropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShadingRateImageFeaturesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceShadingRateImagePropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSparseImageFormatInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubgroupProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubgroupSizeControlFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubgroupSizeControlProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSurfaceInfo2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceSynchronization2Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTexelBufferAlignmentProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTextureCompressionASTCHDRFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTilePropertiesFeaturesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTimelineSemaphoreFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTimelineSemaphoreProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceToolProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTransformFeedbackFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceTransformFeedbackPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVariablePointersFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVideoFormatInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan11Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan11Properties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan12Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan12Properties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan13Features)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkan13Properties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceVulkanMemoryModelFeatures)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkPipelineCacheCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineColorBlendAdvancedStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineColorBlendStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineColorWriteCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCompilerControlCreateInfoAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCoverageModulationStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCoverageReductionStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCoverageToColorStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCreateFlags2CreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineCreationFeedbackCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineDepthStencilStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineDiscardRectangleStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineDynamicStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineExecutableInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineExecutableInternalRepresentationKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineExecutablePropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineExecutableStatisticKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineFragmentShadingRateEnumStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineFragmentShadingRateStateCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineIndirectDeviceAddressInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineInputAssemblyStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineLayoutCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineLibraryCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineMultisampleStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelinePropertiesIdentifierEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationConservativeStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationDepthClipStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationLineStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationStateRasterizationOrderAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRasterizationStateStreamCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRenderingCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRepresentativeFragmentTestStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineRobustnessCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineSampleLocationsStateCreateInfoEXT)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkPipelineShaderStageCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineShaderStageModuleIdentifierCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineTessellationDomainOriginStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineTessellationStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineVertexInputDivisorStateCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineVertexInputStateCreateInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportDepthClipControlCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportExclusiveScissorStateCreateInfoNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportShadingRateImageStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportStateCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportSwizzleStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPipelineViewportWScalingStateCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPresentIdKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPresentInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPresentRegionsKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkPresentTimesInfoGOOGLE)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkPrivateDataSlotCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkProtectedSubmitInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkQueryLowLatencySupportNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueryPoolCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueryPoolPerformanceCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueryPoolPerformanceQueryCreateInfoINTEL)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyCheckpointProperties2NV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyCheckpointPropertiesNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyGlobalPriorityPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyQueryResultStatusPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkQueueFamilyVideoPropertiesKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkRayTracingPipelineCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkRayTracingPipelineCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRayTracingPipelineInterfaceCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkRayTracingShaderGroupCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRayTracingShaderGroupCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkReleaseSwapchainImagesInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderingAreaInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderingAttachmentInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderingFragmentDensityMapAttachmentInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderingFragmentShadingRateAttachmentInfoKHR)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderingInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassAttachmentBeginInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassBeginInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkRenderPassCreateInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassCreationControlEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassCreationFeedbackCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassFragmentDensityMapCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassInputAttachmentAspectCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassMultiviewCreateInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassSampleLocationsBeginInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassSubpassFeedbackCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkRenderPassTransformBeginInfoQCOM)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkResolveImageInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSampleLocationsInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerBorderColorComponentMappingCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerCaptureDescriptorDataInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerCustomBorderColorCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerReductionModeCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerYcbcrConversionCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerYcbcrConversionImageFormatProperties)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSamplerYcbcrConversionInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreGetFdInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreSignalInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreSubmitInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreTypeCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSemaphoreWaitInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkShaderCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkShaderModuleCreateInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkShaderModuleIdentifierEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkShaderModuleValidationCacheCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSharedPresentSurfaceCapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSparseImageFormatProperties2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSparseImageMemoryRequirements2)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkSubmitInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkSubmitInfo2)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassBeginInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassDependency2)
+VULKAN_NONDEFAULT_CUSTOM_REPACK(VkSubpassDescription2)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassDescriptionDepthStencilResolve)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassEndInfo)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassFragmentDensityMapOffsetEndInfoQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassResolvePerformanceQueryEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubpassShadingPipelineCreateInfoHUAWEI)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubresourceHostMemcpySizeEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSubresourceLayout2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfaceCapabilities2EXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfaceCapabilities2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfaceCapabilitiesPresentBarrierNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfaceFormat2KHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfacePresentModeCompatibilityEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfacePresentModeEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfacePresentScalingCapabilitiesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSurfaceProtectedCapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainCounterCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainDisplayNativeHdrCreateInfoAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainPresentBarrierCreateInfoNV)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainPresentFenceInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainPresentModeInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainPresentModesCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkSwapchainPresentScalingCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkTextureLODGatherFormatPropertiesAMD)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkTilePropertiesQCOM)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkTimelineSemaphoreSubmitInfo)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkValidationCacheCreateInfoEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkValidationFeaturesEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkValidationFlagsEXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVertexInputAttributeDescription2EXT)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVertexInputBindingDescription2EXT)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoBeginCodingInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoCapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoCodingControlInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeCapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264CapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264DpbSlotInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264PictureInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264ProfileInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264SessionParametersAddInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH264SessionParametersCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265CapabilitiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265DpbSlotInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265PictureInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265ProfileInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265SessionParametersAddInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeH265SessionParametersCreateInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoDecodeUsageInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoEndCodingInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoFormatPropertiesKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoPictureResourceInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoProfileInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoProfileListInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoReferenceSlotInfoKHR)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoSessionCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoSessionMemoryRequirementsKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoSessionParametersCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkVideoSessionParametersUpdateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkWaylandSurfaceCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkWriteDescriptorSet) // TODO: This should be non-default instead
+VULKAN_DEFAULT_CUSTOM_REPACK(VkWriteDescriptorSetAccelerationStructureKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkWriteDescriptorSetAccelerationStructureNV)
+//VULKAN_DEFAULT_CUSTOM_REPACK(VkWriteDescriptorSetInlineUniformBlock)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkXcbSurfaceCreateInfoKHR)
+VULKAN_DEFAULT_CUSTOM_REPACK(VkXlibSurfaceCreateInfoKHR)
+
+
+void fex_custom_repack_entry(host_layout<VkInstanceCreateInfo>& into, const guest_layout<VkInstanceCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  auto HostApplicationInfo = new host_layout<VkApplicationInfo> { *from.data.pApplicationInfo.get_pointer() };
+  fex_apply_custom_repacking_entry(*HostApplicationInfo, *from.data.pApplicationInfo.get_pointer());
+
+  into.data.pApplicationInfo = &HostApplicationInfo->data;
+
+  auto extension_count = from.data.enabledExtensionCount.data;
+  into.data.ppEnabledExtensionNames = RepackStructArray<false>(extension_count, from.data.ppEnabledExtensionNames).data();
+
+  auto layer_count = from.data.enabledLayerCount.data;
+  into.data.ppEnabledLayerNames = RepackStructArray<false>(layer_count, from.data.ppEnabledLayerNames).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkInstanceCreateInfo>& into, const host_layout<VkInstanceCreateInfo>& from) {
+  delete from.data.pApplicationInfo;
+  delete[] from.data.ppEnabledExtensionNames;
+  delete[] from.data.ppEnabledLayerNames;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDeviceCreateInfo>& into, const guest_layout<VkDeviceCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  auto HostQueueCreateInfo = new host_layout<VkDeviceQueueCreateInfo> { *from.data.pQueueCreateInfos.get_pointer() };
+  fex_apply_custom_repacking_entry(*HostQueueCreateInfo, *from.data.pQueueCreateInfos.get_pointer());
+  into.data.pQueueCreateInfos = &HostQueueCreateInfo->data;
+
+  auto layer_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledLayerNames\n", layer_count);
+  into.data.ppEnabledLayerNames = RepackStructArray<false>(layer_count, from.data.ppEnabledLayerNames).data();
+
+  auto extension_count = from.data.enabledExtensionCount.data;
+  fprintf(stderr, "  Repacking %d ppEnabledExtensionNames\n", extension_count);
+  into.data.ppEnabledExtensionNames = RepackStructArray<false>(extension_count, from.data.ppEnabledExtensionNames).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDeviceCreateInfo>& into, const host_layout<VkDeviceCreateInfo>& from) {
+  delete from.data.pQueueCreateInfos;
+  delete[] from.data.ppEnabledExtensionNames;
+  delete[] from.data.ppEnabledLayerNames;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDescriptorSetLayoutCreateInfo>& into, const guest_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pBindings = RepackStructArray(from.data.bindingCount.data, from.data.pBindings).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDescriptorSetLayoutCreateInfo>& into, const host_layout<VkDescriptorSetLayoutCreateInfo>& from) {
+  delete[] from.data.pBindings;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassCreateInfo>& into, const guest_layout<VkRenderPassCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pSubpasses = RepackStructArray(from.data.subpassCount.data, from.data.pSubpasses).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassCreateInfo>& into, const host_layout<VkRenderPassCreateInfo>& from) {
+  delete[] from.data.pSubpasses;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassCreateInfo2>& into, const guest_layout<VkRenderPassCreateInfo2>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pAttachments = RepackStructArray(from.data.attachmentCount.data, from.data.pAttachments).data();
+  into.data.pSubpasses = RepackStructArray(from.data.subpassCount.data, from.data.pSubpasses).data();
+  into.data.pDependencies = RepackStructArray(from.data.dependencyCount.data, from.data.pDependencies).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassCreateInfo2>& into, const host_layout<VkRenderPassCreateInfo2>& from) {
+  DeleteRepackedStructArray(from.data.attachmentCount, from.data.pAttachments, into.data.pAttachments);
+  DeleteRepackedStructArray(from.data.subpassCount, from.data.pSubpasses, into.data.pSubpasses);
+  DeleteRepackedStructArray(from.data.dependencyCount, from.data.pDependencies, into.data.pDependencies);
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkSubpassDescription2>& into, const guest_layout<VkSubpassDescription2>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pInputAttachments = RepackStructArray(from.data.inputAttachmentCount.data, from.data.pInputAttachments).data();
+  into.data.pColorAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pColorAttachments).data();
+  into.data.pResolveAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pResolveAttachments).data();
+
+  if (from.data.pDepthStencilAttachment.data == 0) {
+    into.data.pDepthStencilAttachment = nullptr;
+  } else {
+    into.data.pDepthStencilAttachment = new VkAttachmentReference2;
+    auto in_data = host_layout<VkAttachmentReference2> { *from.data.pDepthStencilAttachment.get_pointer() };
+    fex_apply_custom_repacking_entry(in_data, *from.data.pDepthStencilAttachment.get_pointer());
+    memcpy((void*)into.data.pDepthStencilAttachment, &in_data.data, sizeof(VkAttachmentReference2));
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkSubpassDescription2>& into, const host_layout<VkSubpassDescription2>& from) {
+  DeleteRepackedStructArray(from.data.inputAttachmentCount, from.data.pInputAttachments, into.data.pInputAttachments);
+  DeleteRepackedStructArray(from.data.colorAttachmentCount, from.data.pColorAttachments, into.data.pColorAttachments);
+  DeleteRepackedStructArray(from.data.colorAttachmentCount, from.data.pResolveAttachments, into.data.pResolveAttachments);
+  if (from.data.pDepthStencilAttachment) {
+    fex_apply_custom_repacking_exit(*into.data.pDepthStencilAttachment.get_pointer(), to_host_layout(*from.data.pDepthStencilAttachment));
+    delete from.data.pDepthStencilAttachment;
+  }
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderingInfo>& into, const guest_layout<VkRenderingInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  into.data.pColorAttachments = RepackStructArray(from.data.colorAttachmentCount.data, from.data.pColorAttachments).data();
+
+  if (from.data.pDepthAttachment.get_pointer() == nullptr) {
+    into.data.pDepthAttachment = nullptr;
+  } else {
+    into.data.pDepthAttachment = new VkRenderingAttachmentInfo;
+    auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pDepthAttachment.get_pointer() };
+    fex_apply_custom_repacking_entry(in_data, *from.data.pDepthAttachment.get_pointer());
+    memcpy((void*)into.data.pDepthAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+
+  if (from.data.pStencilAttachment.get_pointer() == nullptr) {
+    into.data.pStencilAttachment = nullptr;
+  } else {
+    into.data.pStencilAttachment = new VkRenderingAttachmentInfo;
+    auto in_data = host_layout<VkRenderingAttachmentInfo> { *from.data.pStencilAttachment.get_pointer() };
+    fex_apply_custom_repacking_entry(in_data, *from.data.pStencilAttachment.get_pointer());
+    memcpy((void*)into.data.pStencilAttachment, &in_data.data, sizeof(VkRenderingAttachmentInfo));
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderingInfo>& into, const host_layout<VkRenderingInfo>& from) {
+  DeleteRepackedStructArray(from.data.colorAttachmentCount, from.data.pColorAttachments, into.data.pColorAttachments);
+  if (from.data.pDepthAttachment) {
+    fex_apply_custom_repacking_exit(*into.data.pDepthAttachment.get_pointer(), to_host_layout(*from.data.pDepthAttachment));
+    delete from.data.pDepthAttachment;
+  }
+  if (from.data.pStencilAttachment) {
+    fex_apply_custom_repacking_exit(*into.data.pStencilAttachment.get_pointer(), to_host_layout(*from.data.pStencilAttachment));
+    delete from.data.pStencilAttachment;
+  }
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDescriptorGetInfoEXT>& into, const guest_layout<VkDescriptorGetInfoEXT>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  switch (into.data.type) {
+  case VK_DESCRIPTOR_TYPE_SAMPLER:
+  case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
+  case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
+  case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
+  case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
+  {
+    // VkSampler* or VkDescriptorImageInfo*. Handle by zero-extending
+    guest_layout<VkSampler*> guest_data;
+    memcpy(&guest_data, from.data.data.union_storage, sizeof(guest_data));
+    into.data.data.pSampler = host_layout<VkSampler*> { guest_data }.data;
+    break;
+  }
+
+  case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+  case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+  case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+  case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+  {
+    // VkDescriptorAddressInfoEXT*. Repacking required
+    guest_layout<VkDescriptorAddressInfoEXT*> guest_ptr;
+    memcpy(&guest_ptr, from.data.data.union_storage, sizeof(guest_ptr));
+    auto child_mem = (char*)aligned_alloc(alignof(host_layout<VkDescriptorAddressInfoEXT>), sizeof(host_layout<VkDescriptorAddressInfoEXT>));
+    auto child = new (child_mem) host_layout<VkDescriptorAddressInfoEXT> { *guest_ptr.get_pointer() };
+
+    default_fex_custom_repack_entry(*child, *guest_ptr.get_pointer());
+    into.data.data.pUniformBuffer = &child->data;
+    break;
+  }
+
+  case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
+  case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:
+  {
+    // Copy unmodified
+    static_assert(sizeof(guest_layout<VkDeviceAddress>) == sizeof(uint64_t));
+    memcpy(&into.data.data.accelerationStructure, &from.data.data, sizeof(uint64_t));
+  }
+
+  case VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM:
+  case VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM:
+  case VK_DESCRIPTOR_TYPE_MUTABLE_EXT:
+  case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
+  case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
+  case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK:
+  default:
+    fprintf(stderr, "ERROR: Invalid descriptor type used in VkDescriptorGetInfoEXT");
+    std::abort();
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDescriptorGetInfoEXT>& into, const host_layout<VkDescriptorGetInfoEXT>& from) {
+  switch (from.data.type) {
+  case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
+  case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
+  case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
+  case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
+    // Delete storage allocated on entry
+    free((void*)from.data.data.pUniformBuffer);
+
+  default:
+    // Nothing to do for the rest
+    break;
+  }
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDependencyInfo>& into, const guest_layout<VkDependencyInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pMemoryBarriers = RepackStructArray(from.data.memoryBarrierCount.data, from.data.pMemoryBarriers).data();
+  into.data.pImageMemoryBarriers = RepackStructArray(from.data.imageMemoryBarrierCount.data, from.data.pImageMemoryBarriers).data();
+  into.data.pBufferMemoryBarriers = RepackStructArray(from.data.bufferMemoryBarrierCount.data, from.data.pBufferMemoryBarriers).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDependencyInfo>& into, const host_layout<VkDependencyInfo>& from) {
+  DeleteRepackedStructArray(from.data.memoryBarrierCount, from.data.pMemoryBarriers, into.data.pMemoryBarriers);
+  DeleteRepackedStructArray(from.data.imageMemoryBarrierCount, from.data.pImageMemoryBarriers, into.data.pImageMemoryBarriers);
+  DeleteRepackedStructArray(from.data.bufferMemoryBarrierCount, from.data.pBufferMemoryBarriers, into.data.pBufferMemoryBarriers);
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkDescriptorUpdateTemplateCreateInfo>& into, const guest_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pDescriptorUpdateEntries = RepackStructArray(from.data.descriptorUpdateEntryCount.data, from.data.pDescriptorUpdateEntries).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkDescriptorUpdateTemplateCreateInfo>& into, const host_layout<VkDescriptorUpdateTemplateCreateInfo>& from) {
+  DeleteRepackedStructArray(from.data.descriptorUpdateEntryCount, from.data.pDescriptorUpdateEntries, into.data.pDescriptorUpdateEntries);
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkPipelineShaderStageCreateInfo>& into, const guest_layout<VkPipelineShaderStageCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  if (from.data.pSpecializationInfo.get_pointer()) {
+    fprintf(stderr, "ERROR: Cannot repack non-null VkPipelineShaderStageCreateInfo::pSpecializationInfo yet");
+    std::abort();
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkPipelineShaderStageCreateInfo>& into, const host_layout<VkPipelineShaderStageCreateInfo>& from) {
+  // TODO
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkGraphicsPipelineCreateInfo>& into, const guest_layout<VkGraphicsPipelineCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pStages = RepackStructArray(from.data.stageCount.data, from.data.pStages).data();
+
+  if (!from.data.pVertexInputState.get_pointer()) {
+    into.data.pVertexInputState = nullptr;
+  } else {
+    into.data.pVertexInputState = &(new host_layout<VkPipelineVertexInputStateCreateInfo> { *from.data.pVertexInputState.get_pointer() })->data;
+  }
+
+  if (!from.data.pInputAssemblyState.get_pointer()) {
+    into.data.pInputAssemblyState = nullptr;
+  } else {
+    into.data.pInputAssemblyState = &(new host_layout<VkPipelineInputAssemblyStateCreateInfo> { *from.data.pInputAssemblyState.get_pointer() })->data;
+  }
+
+  if (!from.data.pTessellationState.get_pointer()) {
+    into.data.pTessellationState = nullptr;
+  } else {
+    into.data.pTessellationState = &(new host_layout<VkPipelineTessellationStateCreateInfo> { *from.data.pTessellationState.get_pointer() })->data;
+  }
+
+  if (!from.data.pViewportState.get_pointer()) {
+    into.data.pViewportState = nullptr;
+  } else {
+    into.data.pViewportState = &(new host_layout<VkPipelineViewportStateCreateInfo> { *from.data.pViewportState.get_pointer() })->data;
+  }
+
+  if (!from.data.pRasterizationState.get_pointer()) {
+    into.data.pRasterizationState = nullptr;
+  } else {
+    into.data.pRasterizationState = &(new host_layout<VkPipelineRasterizationStateCreateInfo> { *from.data.pRasterizationState.get_pointer() })->data;
+  }
+
+  if (!from.data.pMultisampleState.get_pointer()) {
+    into.data.pMultisampleState = nullptr;
+  } else {
+    into.data.pMultisampleState = &(new host_layout<VkPipelineMultisampleStateCreateInfo> { *from.data.pMultisampleState.get_pointer() })->data;
+  }
+
+  if (!from.data.pDepthStencilState.get_pointer()) {
+    into.data.pDepthStencilState = nullptr;
+  } else {
+    into.data.pDepthStencilState = &(new host_layout<VkPipelineDepthStencilStateCreateInfo> { *from.data.pDepthStencilState.get_pointer() })->data;
+  }
+
+  if (!from.data.pColorBlendState.get_pointer()) {
+    into.data.pColorBlendState = nullptr;
+  } else {
+    into.data.pColorBlendState = &(new host_layout<VkPipelineColorBlendStateCreateInfo> { *from.data.pColorBlendState.get_pointer() })->data;
+  }
+
+  if (!from.data.pDynamicState.get_pointer()) {
+    into.data.pDynamicState = nullptr;
+  } else {
+    into.data.pDynamicState = &(new host_layout<VkPipelineDynamicStateCreateInfo> { *from.data.pDynamicState.get_pointer() })->data;
+  }
+}
+
+bool fex_custom_repack_exit(guest_layout<VkGraphicsPipelineCreateInfo>& into, const host_layout<VkGraphicsPipelineCreateInfo>& from) {
+  delete[] from.data.pStages;
+  delete from.data.pVertexInputState;
+  delete from.data.pInputAssemblyState;
+  delete from.data.pTessellationState;
+  delete from.data.pViewportState;
+  delete from.data.pRasterizationState;
+  delete from.data.pMultisampleState;
+  delete from.data.pDepthStencilState;
+  delete from.data.pColorBlendState;
+  delete from.data.pDynamicState;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkSubmitInfo>& into, const guest_layout<VkSubmitInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+  into.data.pCommandBuffers = RepackStructArray<false>(from.data.commandBufferCount.data, from.data.pCommandBuffers).data();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkSubmitInfo>& into, const host_layout<VkSubmitInfo>& from) {
+  delete[] from.data.pCommandBuffers;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkCommandBufferBeginInfo>& into, const guest_layout<VkCommandBufferBeginInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  if (!from.data.pInheritanceInfo.get_pointer() || !from.data.pInheritanceInfo.data) {
+    into.data.pInheritanceInfo = nullptr;
+    return;
+  }
+  into.data.pInheritanceInfo = new VkCommandBufferInheritanceInfo;
+  auto src = host_layout<VkCommandBufferInheritanceInfo> { *from.data.pInheritanceInfo.get_pointer() }.data;
+  static_assert(sizeof(src) == sizeof(*into.data.pInheritanceInfo));
+  memcpy((void*)into.data.pInheritanceInfo, &src, sizeof(src));
+}
+
+bool fex_custom_repack_exit(guest_layout<VkCommandBufferBeginInfo>& into, const host_layout<VkCommandBufferBeginInfo>& from) {
+  delete from.data.pInheritanceInfo;
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkPipelineCacheCreateInfo>& into, const guest_layout<VkPipelineCacheCreateInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  // Same underlying layout, so there's nothing to do
+  into.data.pInitialData = from.data.pInitialData.get_pointer();
+}
+
+bool fex_custom_repack_exit(guest_layout<VkPipelineCacheCreateInfo>& into, const host_layout<VkPipelineCacheCreateInfo>& from) {
+  // Nothing to do
+  return false;
+}
+
+void fex_custom_repack_entry(host_layout<VkRenderPassBeginInfo>& into, const guest_layout<VkRenderPassBeginInfo>& from) {
+  default_fex_custom_repack_entry(into, from);
+
+  // Same underlying layout, so there's nothing to do
+  into.data.pClearValues = reinterpret_cast<const VkClearValue*>(from.data.pClearValues.get_pointer());
+}
+
+bool fex_custom_repack_exit(guest_layout<VkRenderPassBeginInfo>& into, const host_layout<VkRenderPassBeginInfo>& from) {
+  // Nothing to do
+  return false;
+}
+#endif
+
 EXPORTS(libvulkan)
diff --git a/ThunkLibs/libvulkan/libvulkan_interface.cpp b/ThunkLibs/libvulkan/libvulkan_interface.cpp
index 6bef1c9972..33a42e7894 100644
--- a/ThunkLibs/libvulkan/libvulkan_interface.cpp
+++ b/ThunkLibs/libvulkan/libvulkan_interface.cpp
@@ -60,7 +60,776 @@ template<> struct fex_gen_type<VkAccelerationStructureBuildRangeInfoKHR> {};
 template<> struct fex_gen_type<VkDebugReportCallbackCreateInfoEXT> : fexgen::emit_layout_wrappers {};
 template<> struct fex_gen_type<VkDebugUtilsMessengerCreateInfoEXT> : fexgen::emit_layout_wrappers {};
 
-#ifndef IS_32BIT_THUNK
+#ifdef IS_32BIT_THUNK
+template<> struct fex_gen_type<VkBaseOutStructure> : fexgen::emit_layout_wrappers {};
+
+// Register structs with an extension point (pNext). Any other members that need customization are listed below.
+// Generated using
+// for i in `grep VK_STRUCTURE_TYPE vk.xml -B1 | grep category=\"struct\" | cut -d'"' -f 4 | sort`
+// do
+//   grep $i vulkan_{core,wayland,xcb,xlib,xlib_xrandr}.h >& /dev/null && echo $i
+// done | awk '{ print "template<> struct fex_gen_config<&"$1"::pNext> : fexgen::custom_repack {};" }'
+//template<> struct fex_gen_config<&VkAccelerationStructureBuildGeometryInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureBuildSizesInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureCaptureDescriptorDataInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureDeviceAddressInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureGeometryAabbsDataKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureGeometryInstancesDataKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureGeometryKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureGeometryMotionTrianglesDataNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureGeometryTrianglesDataKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureMemoryRequirementsInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureMotionInfoNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkAccelerationStructureTrianglesOpacityMicromapEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAccelerationStructureVersionInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAcquireNextImageInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAcquireProfilingLockInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAmigoProfilingSubmitInfoSEC::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkApplicationInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentDescription2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentDescriptionStencilLayout::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentReference2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentReferenceStencilLayout::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkAttachmentSampleCountInfoAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindAccelerationStructureMemoryInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindBufferMemoryDeviceGroupInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindBufferMemoryInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindImageMemoryDeviceGroupInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindImageMemoryInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindImageMemorySwapchainInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindImagePlaneMemoryInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkBindSparseInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBindVideoSessionMemoryInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkBlitImageInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferCaptureDescriptorDataInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferCopy2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferDeviceAddressCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferDeviceAddressInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferImageCopy2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferMemoryBarrier::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferMemoryRequirementsInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferOpaqueCaptureAddressCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferUsageFlags2CreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkBufferViewCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCalibratedTimestampInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCheckpointData2NV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCheckpointDataNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferInheritanceConditionalRenderingInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferInheritanceInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferInheritanceRenderingInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferInheritanceRenderPassTransformInfoQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferInheritanceViewportScissorInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandBufferSubmitInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCommandPoolCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkComputePipelineCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkComputePipelineIndirectBufferInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkConditionalRenderingBeginInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCooperativeMatrixPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCooperativeMatrixPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCopyAccelerationStructureInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyAccelerationStructureToMemoryInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyBufferInfo2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyBufferToImageInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCopyCommandTransformInfoQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCopyDescriptorSet::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyImageInfo2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyImageToBufferInfo2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyImageToImageInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyImageToMemoryInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyMemoryToAccelerationStructureInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyMemoryToImageInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyMemoryToMicromapInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCopyMicromapInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCopyMicromapToMemoryInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkCuFunctionCreateInfoNVX::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCuLaunchInfoNVX::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkCuModuleCreateInfoNVX::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugMarkerMarkerInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugMarkerObjectNameInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDebugMarkerObjectTagInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugReportCallbackCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugUtilsLabelEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDebugUtilsMessengerCallbackDataEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugUtilsMessengerCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDebugUtilsObjectNameInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDebugUtilsObjectTagInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDedicatedAllocationBufferCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDedicatedAllocationImageCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDedicatedAllocationMemoryAllocateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDepthBiasInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDepthBiasRepresentationInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorAddressInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorBufferBindingInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorBufferBindingPushDescriptorBufferHandleEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorGetInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorPoolCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorPoolInlineUniformBlockCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetBindingReferenceVALVE::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutBindingFlagsCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutHostMappingInfoVALVE::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetLayoutSupport::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetVariableDescriptorCountAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorSetVariableDescriptorCountLayoutSupport::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceAddressBindingCallbackDataEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceBufferMemoryRequirements::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceDeviceMemoryReportCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceDiagnosticsConfigCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceEventInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceFaultCountsEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceFaultInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupBindSparseInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupCommandBufferBeginInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceGroupDeviceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupPresentCapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupPresentInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupRenderPassBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupSubmitInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceGroupSwapchainCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceImageMemoryRequirements::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDeviceImageSubresourceInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceMemoryOpaqueCaptureAddressInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceMemoryOverallocationCreateInfoAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceMemoryReportCallbackDataEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDevicePrivateDataCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceQueueCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceQueueGlobalPriorityCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceQueueInfo2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDirectDriverLoadingInfoLUNARG::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDirectDriverLoadingListLUNARG::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayEventInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayModeCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayModeProperties2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayNativeHdrSurfaceCapabilitiesAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayPlaneCapabilities2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayPlaneInfo2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayPlaneProperties2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayPowerInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayPresentInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplayProperties2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDisplaySurfaceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDrmFormatModifierPropertiesList2EXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkDrmFormatModifierPropertiesListEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkEventCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExportFenceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExportMemoryAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExportMemoryAllocateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExportSemaphoreCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalBufferProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalFenceProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalImageFormatProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalMemoryAcquireUnmodifiedEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalMemoryBufferCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalMemoryImageCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalMemoryImageCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkExternalSemaphoreProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFenceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFenceGetFdInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFilterCubicImageViewImageFormatPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFormatProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFormatProperties3::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkFragmentShadingRateAttachmentInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFramebufferAttachmentImageInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkFramebufferAttachmentsCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFramebufferCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkFramebufferMixedSamplesCombinationNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkGeneratedCommandsInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGeneratedCommandsMemoryRequirementsInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGeometryAABBNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGeometryNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGeometryTrianglesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineLibraryCreateInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkGraphicsPipelineShaderGroupsCreateInfoNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkGraphicsShaderGroupCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkHeadlessSurfaceCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkHostImageCopyDevicePerformanceQueryEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkHostImageLayoutTransitionInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageBlit2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageCaptureDescriptorDataInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageCompressionControlEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageCompressionPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageCopy2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageCreateInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkImageDrmFormatModifierExplicitCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageDrmFormatModifierListCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageDrmFormatModifierPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageFormatListCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageFormatProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryBarrier::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageMemoryRequirementsInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImagePlaneMemoryRequirementsInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageResolve2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageSparseMemoryRequirementsInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageStencilUsageCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageSubresource2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageSwapchainCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkImageToMemoryCopyEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewAddressPropertiesNVX::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewASTCDecodeModeEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewCaptureDescriptorDataInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewHandleInfoNVX::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewMinLodCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewSampleWeightCreateInfoQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewSlicedCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImageViewUsageCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImportFenceFdInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImportMemoryFdInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkImportMemoryHostPointerInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkImportSemaphoreFdInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkIndirectCommandsLayoutCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkIndirectCommandsLayoutTokenNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkInitializePerformanceApiInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMappedMemoryRange::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryAllocateFlagsInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryBarrier::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryBarrier2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryDedicatedAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryDedicatedRequirements::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryFdPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryGetFdInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryGetRemoteAddressInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryHostPointerPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryMapInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryOpaqueCaptureAddressAllocateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryPriorityAllocateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryRequirements2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkMemoryToImageCopyEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMemoryUnmapInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkMicromapBuildInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMicromapBuildSizesInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMicromapCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMicromapVersionInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMultisampledRenderToSingleSampledInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMultisamplePropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMultiviewPerViewAttributesInfoNVX::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkMutableDescriptorTypeCreateInfoEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkOpaqueCaptureDescriptorDataCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkOpticalFlowExecuteInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkOpticalFlowImageFormatInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkOpticalFlowImageFormatPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkOpticalFlowSessionCreateInfoNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkOpticalFlowSessionCreatePrivateDataInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceConfigurationAcquireInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceCounterDescriptionKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceCounterKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceMarkerInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceOverrideInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceQuerySubmitInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPerformanceStreamMarkerInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevice16BitStorageFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevice4444FormatsFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevice8BitStorageFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAccelerationStructureFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAccelerationStructurePropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAddressBindingReportFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAmigoProfilingFeaturesSEC::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceASTCDecodeFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceBorderColorSwizzleFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceBufferDeviceAddressFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCoherentMemoryFeaturesAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceColorWriteEnableFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceConditionalRenderingFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceConservativeRasterizationPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCooperativeMatrixFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCooperativeMatrixFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCooperativeMatrixPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCooperativeMatrixPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCopyMemoryIndirectFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCopyMemoryIndirectPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCornerSampledImageFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCoverageReductionModeFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCustomBorderColorFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceCustomBorderColorPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDepthBiasControlFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDepthClampZeroOneFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDepthClipControlFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDepthClipEnableFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDepthStencilResolveProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorBufferFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorBufferPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorIndexingFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorIndexingProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDeviceMemoryReportFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDiagnosticsConfigFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDiscardRectanglePropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDriverProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDrmPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDynamicRenderingFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExclusiveScissorFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExtendedDynamicState2FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExtendedDynamicState3FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExtendedDynamicState3PropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExtendedDynamicStateFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalBufferInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalFenceInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalImageFormatInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalMemoryHostPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalMemoryRDMAFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceExternalSemaphoreInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFaultFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFeatures2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFloatControlsProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMap2FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMap2PropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMapFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentDensityMapPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShadingRateFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShadingRateKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceFragmentShadingRatePropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPhysicalDeviceGroupProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceHostImageCopyFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceHostImageCopyPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceHostQueryResetFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceIDProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImage2DViewOf3DFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageCompressionControlFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageDrmFormatModifierInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageFormatInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImagelessFramebufferFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageProcessingFeaturesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageProcessingPropertiesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageRobustnessFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageViewImageFormatInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceImageViewMinLodFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceIndexTypeUint8FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceInheritedViewportScissorFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceInlineUniformBlockFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceInlineUniformBlockProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceInvocationMaskFeaturesHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceLegacyDitheringFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceLinearColorAttachmentFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceLineRasterizationFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceLineRasterizationPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMaintenance3Properties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMaintenance4Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMaintenance4Properties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMaintenance5FeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMaintenance5PropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMemoryBudgetPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMemoryDecompressionFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMemoryDecompressionPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMemoryPriorityFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMemoryProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMeshShaderFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMeshShaderFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMeshShaderPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMeshShaderPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiDrawFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiDrawPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiviewFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMultiviewProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceOpacityMicromapFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceOpacityMicromapPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceOpticalFlowFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceOpticalFlowPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePCIBusInfoPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePerformanceQueryFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePerformanceQueryPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineCreationCacheControlFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelinePropertiesFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineProtectedAccessFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineRobustnessFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePipelineRobustnessPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePointClippingProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePresentBarrierFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePresentIdFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePresentWaitFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePrivateDataFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceProtectedMemoryFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceProtectedMemoryProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceProvokingVertexFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceProvokingVertexPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDevicePushDescriptorPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayQueryFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingMotionBlurFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingPipelineFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingPipelinePropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRayTracingPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRobustness2FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceRobustness2PropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSampleLocationsPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSamplerFilterMinmaxProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSamplerYcbcrConversionFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceScalarBlockLayoutFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderAtomicFloatFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderAtomicInt64Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderClockFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderCoreProperties2AMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderCorePropertiesAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderCorePropertiesARM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderDrawParametersFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderFloat16Int8Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderImageFootprintFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderIntegerDotProductFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderIntegerDotProductProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderObjectFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderObjectPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderTerminateInvocationFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderTileImageFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShaderTileImagePropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShadingRateImageFeaturesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceShadingRateImagePropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSparseImageFormatInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubgroupProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubgroupSizeControlFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubgroupSizeControlProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubpassShadingFeaturesHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSubpassShadingPropertiesHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSurfaceInfo2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceSynchronization2Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTexelBufferAlignmentProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTextureCompressionASTCHDRFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTilePropertiesFeaturesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTimelineSemaphoreFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTimelineSemaphoreProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceToolProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTransformFeedbackFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceTransformFeedbackPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceUniformBufferStandardLayoutFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVariablePointersFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVideoFormatInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan11Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan11Properties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan12Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan12Properties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan13Features::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkan13Properties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceVulkanMemoryModelFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCacheCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineColorBlendAdvancedStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineColorBlendStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineColorWriteCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCompilerControlCreateInfoAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCoverageModulationStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCoverageReductionStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCoverageToColorStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineCreateFlags2CreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPipelineCreationFeedbackCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineDepthStencilStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineDiscardRectangleStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineDynamicStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineExecutableInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPipelineExecutableInternalRepresentationKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineExecutablePropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineExecutableStatisticKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineFragmentShadingRateEnumStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineFragmentShadingRateStateCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineIndirectDeviceAddressInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineInputAssemblyStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineLayoutCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineLibraryCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineMultisampleStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelinePropertiesIdentifierEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationConservativeStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationDepthClipStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationLineStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationProvokingVertexStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationStateRasterizationOrderAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRasterizationStateStreamCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRenderingCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRepresentativeFragmentTestStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineRobustnessCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineSampleLocationsStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineShaderStageCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineShaderStageModuleIdentifierCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineShaderStageRequiredSubgroupSizeCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineTessellationDomainOriginStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineTessellationStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineVertexInputDivisorStateCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineVertexInputStateCreateInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineViewportDepthClipControlCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineViewportExclusiveScissorStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPipelineViewportShadingRateImageStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineViewportStateCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineViewportSwizzleStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPipelineViewportWScalingStateCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPresentIdKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPresentInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPresentRegionsKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkPresentTimesInfoGOOGLE::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkPrivateDataSlotCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkProtectedSubmitInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkQueryLowLatencySupportNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueryPoolCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueryPoolPerformanceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueryPoolPerformanceQueryCreateInfoINTEL::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyCheckpointProperties2NV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyCheckpointPropertiesNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyGlobalPriorityPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyQueryResultStatusPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkQueueFamilyVideoPropertiesKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkRayTracingPipelineCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkRayTracingPipelineCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRayTracingPipelineInterfaceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkRayTracingShaderGroupCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRayTracingShaderGroupCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkReleaseSwapchainImagesInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingAreaInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingAttachmentInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingFragmentDensityMapAttachmentInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingFragmentShadingRateAttachmentInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassAttachmentBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreationControlEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreationFeedbackCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassFragmentDensityMapCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassInputAttachmentAspectCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassMultiviewCreateInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkRenderPassSampleLocationsBeginInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassSubpassFeedbackCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassTransformBeginInfoQCOM::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkResolveImageInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSampleLocationsInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerBorderColorComponentMappingCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerCaptureDescriptorDataInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerCustomBorderColorCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerReductionModeCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerYcbcrConversionCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerYcbcrConversionImageFormatProperties::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSamplerYcbcrConversionInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreGetFdInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreSignalInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreSubmitInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreTypeCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSemaphoreWaitInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkShaderCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkShaderModuleCreateInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkShaderModuleIdentifierEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkShaderModuleValidationCacheCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSharedPresentSurfaceCapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSparseImageFormatProperties2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSparseImageMemoryRequirements2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubmitInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkSubmitInfo2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassBeginInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDependency2::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDescription2::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkSubpassDescriptionDepthStencilResolve::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassEndInfo::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassFragmentDensityMapOffsetEndInfoQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassResolvePerformanceQueryEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassShadingPipelineCreateInfoHUAWEI::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubresourceHostMemcpySizeEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubresourceLayout2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfaceCapabilities2EXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfaceCapabilities2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfaceCapabilitiesPresentBarrierNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfaceFormat2KHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfacePresentModeCompatibilityEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfacePresentModeEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfacePresentScalingCapabilitiesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSurfaceProtectedCapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainCounterCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainDisplayNativeHdrCreateInfoAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainPresentBarrierCreateInfoNV::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainPresentFenceInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainPresentModeInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainPresentModesCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSwapchainPresentScalingCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkTextureLODGatherFormatPropertiesAMD::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkTilePropertiesQCOM::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkTimelineSemaphoreSubmitInfo::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkValidationCacheCreateInfoEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkValidationFeaturesEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkValidationFlagsEXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVertexInputAttributeDescription2EXT::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVertexInputBindingDescription2EXT::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoBeginCodingInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoCapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoCodingControlInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeCapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH264CapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH264DpbSlotInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH264PictureInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH264ProfileInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoDecodeH264SessionParametersAddInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoDecodeH264SessionParametersCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH265CapabilitiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH265DpbSlotInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH265PictureInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeH265ProfileInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoDecodeH265SessionParametersAddInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoDecodeH265SessionParametersCreateInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoDecodeInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoDecodeUsageInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoEndCodingInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoFormatPropertiesKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoPictureResourceInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoProfileInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoProfileListInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoReferenceSlotInfoKHR::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkVideoSessionCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoSessionMemoryRequirementsKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoSessionParametersCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkVideoSessionParametersUpdateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkWaylandSurfaceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkWriteDescriptorSet::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkWriteDescriptorSetAccelerationStructureKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkWriteDescriptorSetAccelerationStructureNV::pNext> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkWriteDescriptorSetInlineUniformBlock::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkXcbSurfaceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkXlibSurfaceCreateInfoKHR::pNext> : fexgen::custom_repack {};
+
+
+template<> struct fex_gen_config<&VkCommandBufferBeginInfo::pInheritanceInfo> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDeviceCreateInfo::pQueueCreateInfos> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDeviceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDependencyInfo::pMemoryBarriers> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pBufferMemoryBarriers> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkDependencyInfo::pImageMemoryBarriers> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDescriptorGetInfoEXT::data> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDescriptorSetLayoutCreateInfo::pBindings> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkDescriptorUpdateTemplateCreateInfo::pDescriptorUpdateEntries> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pStages> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pVertexInputState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pInputAssemblyState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pTessellationState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pViewportState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pRasterizationState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pMultisampleState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDepthStencilState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pColorBlendState> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkGraphicsPipelineCreateInfo::pDynamicState> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkInstanceCreateInfo::pApplicationInfo> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledLayerNames> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkInstanceCreateInfo::ppEnabledExtensionNames> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkRenderPassCreateInfo::pSubpasses> : fexgen::custom_repack {};
+// NOTE: pDependencies and pAttachments point to ABI-compatible data
+
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pSubpasses> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderPassCreateInfo2::pDependencies> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkPipelineShaderStageCreateInfo::pSpecializationInfo> : fexgen::custom_repack {};
+//template<> struct fex_gen_config<&VkSpecializationInfo::pMapEntries> : fexgen::custom_repack {};
+
+// TODO: Support annotating as assume_compatible_data_layout instead
+template<> struct fex_gen_config<&VkPipelineCacheCreateInfo::pInitialData> : fexgen::custom_repack {};
+
+// Command buffers are dispatchable handles, so on 32-bit they need to be repacked
+template<> struct fex_gen_config<&VkSubmitInfo::pCommandBuffers> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkRenderingInfo::pColorAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingInfo::pDepthAttachment> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkRenderingInfo::pStencilAttachment> : fexgen::custom_repack {};
+
+// TODO: Support annotating as assume_compatible_data_layout instead
+template<> struct fex_gen_config<&VkRenderPassBeginInfo::pClearValues> : fexgen::custom_repack {};
+
+template<> struct fex_gen_config<&VkSubpassDescription2::pInputAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDescription2::pColorAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDescription2::pResolveAttachments> : fexgen::custom_repack {};
+template<> struct fex_gen_config<&VkSubpassDescription2::pDepthStencilAttachment> : fexgen::custom_repack {};
+
+// These types have incompatible data layout but we use their layout wrappers elsewhere
+template<> struct fex_gen_type<VkWriteDescriptorSet> : fexgen::emit_layout_wrappers {};
+#else
 // The pNext member of this is a pointer to another VkBaseOutStructure, so data layout compatibility can't be inferred automatically
 template<> struct fex_gen_type<VkBaseOutStructure> : fexgen::assume_compatible_data_layout {};
 #endif
@@ -90,7 +859,14 @@ struct fex_gen_config : fexgen::generate_guest_symtable, fexgen::indirect_guest_
 template<> struct fex_gen_config<vkCreateInstance> : fexgen::custom_host_impl {};
 template<> struct fex_gen_param<vkCreateInstance, 2, VkInstance*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyInstance> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkEnumeratePhysicalDevices> {};
+#else
+template<> struct fex_gen_config<vkEnumeratePhysicalDevices> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkEnumeratePhysicalDevices, 2, VkPhysicalDevice*> : fexgen::ptr_passthrough {};
+#endif
+
+
 template<> struct fex_gen_config<vkGetPhysicalDeviceFeatures> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties> {};
@@ -105,31 +881,54 @@ template<> struct fex_gen_config<vkEnumerateInstanceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceExtensionProperties> {};
 template<> struct fex_gen_config<vkEnumerateInstanceLayerProperties> {};
 template<> struct fex_gen_config<vkEnumerateDeviceLayerProperties> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceQueue> {};
+#else
+template<> struct fex_gen_config<vkGetDeviceQueue> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkGetDeviceQueue, 3, VkQueue*> : fexgen::ptr_passthrough {};
+#endif
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkQueueSubmit> {};
+#else
+// Needs array repacking for multiple submit infos
+template<> struct fex_gen_config<vkQueueSubmit> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkQueueSubmit, 2, const VkSubmitInfo*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkQueueWaitIdle> {};
 template<> struct fex_gen_config<vkDeviceWaitIdle> {};
 template<> struct fex_gen_config<vkAllocateMemory> : fexgen::custom_host_impl {};
 template<> struct fex_gen_config<vkFreeMemory> : fexgen::custom_host_impl {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkMapMemory> {};
+#else
+template<> struct fex_gen_config<vkMapMemory> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkMapMemory, 5, void**> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkUnmapMemory> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkFlushMappedMemoryRanges> {};
 template<> struct fex_gen_config<vkInvalidateMappedMemoryRanges> {};
 template<> struct fex_gen_config<vkGetDeviceMemoryCommitment> {};
+#endif
 template<> struct fex_gen_config<vkBindBufferMemory> {};
 template<> struct fex_gen_config<vkBindImageMemory> {};
 template<> struct fex_gen_config<vkGetBufferMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetImageMemoryRequirements> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetImageSparseMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties> {};
 template<> struct fex_gen_config<vkQueueBindSparse> {};
+#endif
 template<> struct fex_gen_config<vkCreateFence> {};
 template<> struct fex_gen_config<vkDestroyFence> {};
 template<> struct fex_gen_config<vkResetFences> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetFenceStatus> {};
+#endif
 template<> struct fex_gen_config<vkWaitForFences> {};
 template<> struct fex_gen_config<vkCreateSemaphore> {};
 template<> struct fex_gen_config<vkDestroySemaphore> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateEvent> {};
 template<> struct fex_gen_config<vkDestroyEvent> {};
 template<> struct fex_gen_config<vkGetEventStatus> {};
@@ -139,6 +938,7 @@ template<> struct fex_gen_config<vkCreateQueryPool> {};
 template<> struct fex_gen_config<vkDestroyQueryPool> {};
 template<> struct fex_gen_config<vkGetQueryPoolResults> {};
 template<> struct fex_gen_param<vkGetQueryPoolResults, 5, void*> : fexgen::assume_compatible_data_layout {};
+#endif
 template<> struct fex_gen_config<vkCreateBuffer> {};
 template<> struct fex_gen_config<vkDestroyBuffer> {};
 template<> struct fex_gen_config<vkCreateBufferView> {};
@@ -152,10 +952,21 @@ template<> struct fex_gen_config<vkCreateShaderModule> : fexgen::custom_host_imp
 template<> struct fex_gen_config<vkDestroyShaderModule> {};
 template<> struct fex_gen_config<vkCreatePipelineCache> {};
 template<> struct fex_gen_config<vkDestroyPipelineCache> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPipelineCacheData> {};
+#else
+template<> struct fex_gen_config<vkGetPipelineCacheData> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkGetPipelineCacheData, 2, size_t*> : fexgen::ptr_passthrough {};
+#endif
+template<> struct fex_gen_param<vkGetPipelineCacheData, 3, void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkMergePipelineCaches> {};
+#endif
+// TODO: Should be custom_host_impl since there may be more than one VkGraphicsPipelineCreateInfo and more than one output pipeline
 template<> struct fex_gen_config<vkCreateGraphicsPipelines> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateComputePipelines> {};
+#endif
 template<> struct fex_gen_config<vkDestroyPipeline> {};
 template<> struct fex_gen_config<vkCreatePipelineLayout> {};
 template<> struct fex_gen_config<vkDestroyPipelineLayout> {};
@@ -168,7 +979,13 @@ template<> struct fex_gen_config<vkDestroyDescriptorPool> {};
 template<> struct fex_gen_config<vkResetDescriptorPool> {};
 template<> struct fex_gen_config<vkAllocateDescriptorSets> {};
 template<> struct fex_gen_config<vkFreeDescriptorSets> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkUpdateDescriptorSets> {};
+#else
+template<> struct fex_gen_config<vkUpdateDescriptorSets> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkUpdateDescriptorSets, 2, const VkWriteDescriptorSet*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_param<vkUpdateDescriptorSets, 4, const VkCopyDescriptorSet*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkCreateFramebuffer> {};
 template<> struct fex_gen_config<vkDestroyFramebuffer> {};
 template<> struct fex_gen_config<vkCreateRenderPass> {};
@@ -177,8 +994,19 @@ template<> struct fex_gen_config<vkGetRenderAreaGranularity> {};
 template<> struct fex_gen_config<vkCreateCommandPool> {};
 template<> struct fex_gen_config<vkDestroyCommandPool> {};
 template<> struct fex_gen_config<vkResetCommandPool> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkAllocateCommandBuffers> {};
+#else
+template<> struct fex_gen_config<vkAllocateCommandBuffers> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkAllocateCommandBuffers, 2, VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
+
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkFreeCommandBuffers> {};
+#else
+template<> struct fex_gen_config<vkFreeCommandBuffers> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkFreeCommandBuffers, 3, const VkCommandBuffer*> : fexgen::ptr_passthrough {};
+#endif
 template<> struct fex_gen_config<vkBeginCommandBuffer> {};
 template<> struct fex_gen_config<vkEndCommandBuffer> {};
 template<> struct fex_gen_config<vkResetCommandBuffer> {};
@@ -196,6 +1024,7 @@ template<> struct fex_gen_config<vkCmdBindDescriptorSets> {};
 template<> struct fex_gen_config<vkCmdBindIndexBuffer> {};
 template<> struct fex_gen_config<vkCmdBindVertexBuffers> {};
 template<> struct fex_gen_config<vkCmdDraw> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawIndexed> {};
 template<> struct fex_gen_config<vkCmdDrawIndirect> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirect> {};
@@ -204,42 +1033,60 @@ template<> struct fex_gen_config<vkCmdDispatchIndirect> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer> {};
 template<> struct fex_gen_config<vkCmdCopyImage> {};
 template<> struct fex_gen_config<vkCmdBlitImage> {};
+#endif
 template<> struct fex_gen_config<vkCmdCopyBufferToImage> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdCopyImageToBuffer> {};
 template<> struct fex_gen_config<vkCmdUpdateBuffer> {};
+template<> struct fex_gen_param<vkCmdUpdateBuffer, 4, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdFillBuffer> {};
 template<> struct fex_gen_config<vkCmdClearColorImage> {};
 template<> struct fex_gen_config<vkCmdClearDepthStencilImage> {};
+#endif
 template<> struct fex_gen_config<vkCmdClearAttachments> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdResolveImage> {};
 template<> struct fex_gen_config<vkCmdSetEvent> {};
 template<> struct fex_gen_config<vkCmdResetEvent> {};
 template<> struct fex_gen_config<vkCmdWaitEvents> {};
+#endif
 template<> struct fex_gen_config<vkCmdPipelineBarrier> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginQuery> {};
 template<> struct fex_gen_config<vkCmdEndQuery> {};
 template<> struct fex_gen_config<vkCmdResetQueryPool> {};
 template<> struct fex_gen_config<vkCmdWriteTimestamp> {};
 template<> struct fex_gen_config<vkCmdCopyQueryPoolResults> {};
 template<> struct fex_gen_config<vkCmdPushConstants> {};
+template<> struct fex_gen_param<vkCmdPushConstants, 5, const void*> : fexgen::assume_compatible_data_layout {};
+#endif
 template<> struct fex_gen_config<vkCmdBeginRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdNextSubpass> {};
+#endif
 template<> struct fex_gen_config<vkCmdEndRenderPass> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdExecuteCommands> {};
+#endif
 template<> struct fex_gen_config<vkEnumerateInstanceVersion> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkBindBufferMemory2> {};
 template<> struct fex_gen_config<vkBindImageMemory2> {};
 template<> struct fex_gen_config<vkGetDeviceGroupPeerMemoryFeatures> {};
 template<> struct fex_gen_config<vkCmdSetDeviceMask> {};
 template<> struct fex_gen_config<vkCmdDispatchBase> {};
 template<> struct fex_gen_config<vkEnumeratePhysicalDeviceGroups> {};
+#endif
 template<> struct fex_gen_config<vkGetImageMemoryRequirements2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetBufferMemoryRequirements2> {};
 template<> struct fex_gen_config<vkGetImageSparseMemoryRequirements2> {};
+#endif
 template<> struct fex_gen_config<vkGetPhysicalDeviceFeatures2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceFormatProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceImageFormatProperties2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceQueueFamilyProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMemoryProperties2> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSparseImageFormatProperties2> {};
@@ -247,25 +1094,35 @@ template<> struct fex_gen_config<vkTrimCommandPool> {};
 template<> struct fex_gen_config<vkGetDeviceQueue2> {};
 template<> struct fex_gen_config<vkCreateSamplerYcbcrConversion> {};
 template<> struct fex_gen_config<vkDestroySamplerYcbcrConversion> {};
+#endif
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplate> {};
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplate> {};
 template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplate, 3, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalBufferProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalFenceProperties> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphoreProperties> {};
+#endif
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutSupport> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdDrawIndirectCount> {};
 template<> struct fex_gen_config<vkCmdDrawIndexedIndirectCount> {};
+#endif
 template<> struct fex_gen_config<vkCreateRenderPass2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginRenderPass2> {};
 template<> struct fex_gen_config<vkCmdNextSubpass2> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2> {};
 template<> struct fex_gen_config<vkResetQueryPool> {};
 template<> struct fex_gen_config<vkGetSemaphoreCounterValue> {};
+#endif
 template<> struct fex_gen_config<vkWaitSemaphores> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkSignalSemaphore> {};
+#endif
 template<> struct fex_gen_config<vkGetBufferDeviceAddress> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetBufferOpaqueCaptureAddress> {};
 template<> struct fex_gen_config<vkGetDeviceMemoryOpaqueCaptureAddress> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceToolProperties> {};
@@ -276,7 +1133,9 @@ template<> struct fex_gen_config<vkGetPrivateData> {};
 template<> struct fex_gen_config<vkCmdSetEvent2> {};
 template<> struct fex_gen_config<vkCmdResetEvent2> {};
 template<> struct fex_gen_config<vkCmdWaitEvents2> {};
+#endif
 template<> struct fex_gen_config<vkCmdPipelineBarrier2> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdWriteTimestamp2> {};
 template<> struct fex_gen_config<vkQueueSubmit2> {};
 template<> struct fex_gen_config<vkCmdCopyBuffer2> {};
@@ -285,6 +1144,7 @@ template<> struct fex_gen_config<vkCmdCopyBufferToImage2> {};
 template<> struct fex_gen_config<vkCmdCopyImageToBuffer2> {};
 template<> struct fex_gen_config<vkCmdBlitImage2> {};
 template<> struct fex_gen_config<vkCmdResolveImage2> {};
+#endif
 template<> struct fex_gen_config<vkCmdBeginRendering> {};
 template<> struct fex_gen_config<vkCmdEndRendering> {};
 template<> struct fex_gen_config<vkCmdSetCullMode> {};
@@ -302,19 +1162,22 @@ template<> struct fex_gen_config<vkCmdSetStencilOp> {};
 template<> struct fex_gen_config<vkCmdSetRasterizerDiscardEnable> {};
 template<> struct fex_gen_config<vkCmdSetDepthBiasEnable> {};
 template<> struct fex_gen_config<vkCmdSetPrimitiveRestartEnable> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceBufferMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageMemoryRequirements> {};
 template<> struct fex_gen_config<vkGetDeviceImageSparseMemoryRequirements> {};
+#endif
 template<> struct fex_gen_config<vkDestroySurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceSupportKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceCapabilitiesKHR> {};
-template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {};
+template<> struct fex_gen_config<vkGetPhysicalDeviceSurfaceFormatsKHR> {}; // TODO: Need to figure out how *not* to repack the last parameter on input...
 template<> struct fex_gen_config<vkGetPhysicalDeviceSurfacePresentModesKHR> {};
 template<> struct fex_gen_config<vkCreateSwapchainKHR> {};
 template<> struct fex_gen_config<vkDestroySwapchainKHR> {};
 template<> struct fex_gen_config<vkGetSwapchainImagesKHR> {};
 template<> struct fex_gen_config<vkAcquireNextImageKHR> {};
 template<> struct fex_gen_config<vkQueuePresentKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceGroupPresentCapabilitiesKHR> {};
 template<> struct fex_gen_config<vkGetDeviceGroupSurfacePresentModesKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDevicePresentRectanglesKHR> {};
@@ -361,13 +1224,17 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceExternalSemaphorePropertiesK
 template<> struct fex_gen_config<vkImportSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkGetSemaphoreFdKHR> {};
 template<> struct fex_gen_config<vkCmdPushDescriptorSetKHR> {};
+#endif
 template<> struct fex_gen_config<vkCmdPushDescriptorSetWithTemplateKHR> {};
 template<> struct fex_gen_param<vkCmdPushDescriptorSetWithTemplateKHR, 4, const void*> : fexgen::assume_compatible_data_layout {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateDescriptorUpdateTemplateKHR> {};
 template<> struct fex_gen_config<vkDestroyDescriptorUpdateTemplateKHR> {};
+#endif
 template<> struct fex_gen_config<vkUpdateDescriptorSetWithTemplateKHR> {};
 template<> struct fex_gen_param<vkUpdateDescriptorSetWithTemplateKHR, 3, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCreateRenderPass2KHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBeginRenderPass2KHR> {};
 template<> struct fex_gen_config<vkCmdNextSubpass2KHR> {};
 template<> struct fex_gen_config<vkCmdEndRenderPass2KHR> {};
@@ -451,9 +1318,11 @@ template<> struct fex_gen_config<vkCmdPushDescriptorSet2KHR> {};
 template<> struct fex_gen_config<vkCmdPushDescriptorSetWithTemplate2KHR> {};
 template<> struct fex_gen_config<vkCmdSetDescriptorBufferOffsets2EXT> {};
 template<> struct fex_gen_config<vkCmdBindDescriptorBufferEmbeddedSamplers2EXT> {};
+#endif
 template<> struct fex_gen_config<vkCreateDebugReportCallbackEXT> : fexgen::custom_host_impl {};
 template<> struct fex_gen_param<vkCreateDebugReportCallbackEXT, 1, const VkDebugReportCallbackCreateInfoEXT*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyDebugReportCallbackEXT> : fexgen::custom_host_impl {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkDebugReportMessageEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectTagEXT> {};
 template<> struct fex_gen_config<vkDebugMarkerSetObjectNameEXT> {};
@@ -501,9 +1370,11 @@ template<> struct fex_gen_config<vkQueueInsertDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdBeginDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdEndDebugUtilsLabelEXT> {};
 template<> struct fex_gen_config<vkCmdInsertDebugUtilsLabelEXT> {};
+#endif
 template<> struct fex_gen_config<vkCreateDebugUtilsMessengerEXT> : fexgen::custom_host_impl {};
 template<> struct fex_gen_param<vkCreateDebugUtilsMessengerEXT, 1, const VkDebugUtilsMessengerCreateInfoEXT*> : fexgen::ptr_passthrough {};
 template<> struct fex_gen_config<vkDestroyDebugUtilsMessengerEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkSubmitDebugUtilsMessageEXT> {};
 template<> struct fex_gen_config<vkCmdSetSampleLocationsEXT> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceMultisamplePropertiesEXT> {};
@@ -535,7 +1406,9 @@ template<> struct fex_gen_config<vkCompileDeferredNV> {};
 template<> struct fex_gen_config<vkGetMemoryHostPointerPropertiesEXT> {};
 template<> struct fex_gen_param<vkGetMemoryHostPointerPropertiesEXT, 2, const void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdWriteBufferMarkerAMD> {};
+#endif
 template<> struct fex_gen_config<vkGetPhysicalDeviceCalibrateableTimeDomainsEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetCalibratedTimestampsEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksNV> {};
 template<> struct fex_gen_config<vkCmdDrawMeshTasksIndirectNV> {};
@@ -560,7 +1433,9 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceToolPropertiesEXT> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceCooperativeMatrixPropertiesNV> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV> {};
 template<> struct fex_gen_config<vkCreateHeadlessSurfaceEXT> {};
+#endif
 template<> struct fex_gen_config<vkCmdSetLineStippleEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkResetQueryPoolEXT> {};
 template<> struct fex_gen_config<vkCmdSetCullModeEXT> {};
 template<> struct fex_gen_config<vkCmdSetFrontFaceEXT> {};
@@ -599,11 +1474,14 @@ template<> struct fex_gen_config<vkCreateCudaFunctionNV> {};
 template<> struct fex_gen_config<vkDestroyCudaModuleNV> {};
 template<> struct fex_gen_config<vkDestroyCudaFunctionNV> {};
 template<> struct fex_gen_config<vkCmdCudaLaunchKernelNV> {};
+#endif
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutSizeEXT> {};
 template<> struct fex_gen_config<vkGetDescriptorSetLayoutBindingOffsetEXT> {};
 template<> struct fex_gen_config<vkGetDescriptorEXT> {};
+template<> struct fex_gen_param<vkGetDescriptorEXT, 3, void*> : fexgen::assume_compatible_data_layout {};
 template<> struct fex_gen_config<vkCmdBindDescriptorBuffersEXT> {};
 template<> struct fex_gen_config<vkCmdSetDescriptorBufferOffsetsEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdBindDescriptorBufferEmbeddedSamplersEXT> {};
 template<> struct fex_gen_config<vkGetBufferOpaqueCaptureDescriptorDataEXT> {};
 template<> struct fex_gen_config<vkGetImageOpaqueCaptureDescriptorDataEXT> {};
@@ -612,12 +1490,24 @@ template<> struct fex_gen_config<vkGetSamplerOpaqueCaptureDescriptorDataEXT> {};
 template<> struct fex_gen_config<vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT> {};
 template<> struct fex_gen_config<vkCmdSetFragmentShadingRateEnumNV> {};
 template<> struct fex_gen_config<vkGetDeviceFaultInfoEXT> {};
+#endif
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdSetVertexInputEXT> {};
+#else
+template<> struct fex_gen_config<vkCmdSetVertexInputEXT> : fexgen::custom_host_impl {};
+template<> struct fex_gen_param<vkCmdSetVertexInputEXT, 2, const VkVertexInputBindingDescription2EXT*> : fexgen::ptr_passthrough {};
+template<> struct fex_gen_param<vkCmdSetVertexInputEXT, 4, const VkVertexInputAttributeDescription2EXT*> : fexgen::ptr_passthrough {};
+#endif
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI> {};
 template<> struct fex_gen_config<vkCmdSubpassShadingHUAWEI> {};
 template<> struct fex_gen_config<vkCmdBindInvocationMaskHUAWEI> {};
+#ifndef IS_32BIT_THUNK
+// VkRemoteAddressNV* expands to void**, so it needs custom repacking on on 32-bit
 template<> struct fex_gen_config<vkGetMemoryRemoteAddressNV> {};
+#endif
 template<> struct fex_gen_config<vkGetPipelinePropertiesEXT> {};
+#endif
 template<> struct fex_gen_config<vkCmdSetPatchControlPointsEXT> {};
 template<> struct fex_gen_config<vkCmdSetRasterizerDiscardEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetDepthBiasEnableEXT> {};
@@ -626,6 +1516,7 @@ template<> struct fex_gen_config<vkCmdSetPrimitiveRestartEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetColorWriteEnableEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMultiEXT> {};
 template<> struct fex_gen_config<vkCmdDrawMultiIndexedEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCreateMicromapEXT> {};
 template<> struct fex_gen_config<vkDestroyMicromapEXT> {};
 template<> struct fex_gen_config<vkCmdBuildMicromapsEXT> {};
@@ -653,6 +1544,7 @@ template<> struct fex_gen_config<vkCmdDecompressMemoryIndirectCountNV> {};
 template<> struct fex_gen_config<vkGetPipelineIndirectMemoryRequirementsNV> {};
 template<> struct fex_gen_config<vkCmdUpdatePipelineIndirectBufferNV> {};
 template<> struct fex_gen_config<vkGetPipelineIndirectDeviceAddressNV> {};
+#endif
 template<> struct fex_gen_config<vkCmdSetDepthClampEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetPolygonModeEXT> {};
 template<> struct fex_gen_config<vkCmdSetRasterizationSamplesEXT> {};
@@ -674,6 +1566,7 @@ template<> struct fex_gen_config<vkCmdSetProvokingVertexModeEXT> {};
 template<> struct fex_gen_config<vkCmdSetLineRasterizationModeEXT> {};
 template<> struct fex_gen_config<vkCmdSetLineStippleEnableEXT> {};
 template<> struct fex_gen_config<vkCmdSetDepthClipNegativeOneToOneEXT> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkCmdSetViewportWScalingEnableNV> {};
 template<> struct fex_gen_config<vkCmdSetViewportSwizzleNV> {};
 template<> struct fex_gen_config<vkCmdSetCoverageToColorEnableNV> {};
@@ -736,7 +1629,9 @@ template<> struct fex_gen_config<vkAcquireXlibDisplayEXT> {};
 template<> struct fex_gen_config<vkGetRandROutputDisplayEXT> {};
 
 // vulkan_wayland.h
+#endif
 template<> struct fex_gen_config<vkCreateWaylandSurfaceKHR> {};
+#ifndef IS_32BIT_THUNK
 template<> struct fex_gen_config<vkGetPhysicalDeviceWaylandPresentationSupportKHR> {};
 
 // vulkan_xcb.h
@@ -746,4 +1641,5 @@ template<> struct fex_gen_config<vkGetPhysicalDeviceXcbPresentationSupportKHR> {
 // vulkan_xlib.h
 template<> struct fex_gen_config<vkCreateXlibSurfaceKHR> {};
 template<> struct fex_gen_config<vkGetPhysicalDeviceXlibPresentationSupportKHR> {};
+#endif
 } // namespace internal
diff --git a/unittests/FEXLinuxTests/CMakeLists.txt b/unittests/FEXLinuxTests/CMakeLists.txt
index 1986a7ba46..1d2e57b4b6 100644
--- a/unittests/FEXLinuxTests/CMakeLists.txt
+++ b/unittests/FEXLinuxTests/CMakeLists.txt
@@ -35,12 +35,6 @@ list(REMOVE_ITEM TESTS ${TESTS_32_ONLY})
 function(AddTests Tests BinDirectory Bitness)
   foreach(TEST ${Tests})
     get_filename_component(TEST_NAME ${TEST} NAME_WE)
-
-    file(READ ${TEST} TEST_CODE)
-
-    # Used to insert a configuration dependency to the test file
-    CONFIGURE_FILE(${TEST} ${CMAKE_BINARY_DIR}/junk.file)
-
     set(BIN_PATH "${CMAKE_CURRENT_BINARY_DIR}/${BinDirectory}/${TEST_NAME}.${Bitness}")
     set(TEST_CASE "${TEST_NAME}.${Bitness}")
 
diff --git a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
index e3ab7d1cab..f34db77f1c 100644
--- a/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
+++ b/unittests/FEXLinuxTests/tests/thunks/thunk_testlib.cpp
@@ -36,6 +36,8 @@ struct Fixture {
   GET_SYMBOL(RanCustomRepack);
 
   GET_SYMBOL(FunctionWithDivergentSignature);
+
+  GET_SYMBOL(ReadData1);
 };
 
 TEST_CASE_METHOD(Fixture, "Trivial") {
@@ -89,3 +91,24 @@ TEST_CASE_METHOD(Fixture, "Assisted struct repacking") {
 TEST_CASE_METHOD(Fixture, "Function signature with differing parameter sizes") {
   CHECK(FunctionWithDivergentSignature(DivType{1}, DivType{2}, DivType{3}, DivType{4}) == 0x01020304);
 }
+
+// Test Vulkan-like linked lists
+TEST_CASE_METHOD(Fixture, "Assisted repacking of linked lists") {
+  const int s2_data = 0xcddeeff;
+  TestStruct2 s2 {
+    .Next = nullptr,
+    .Type = StructType::Struct2,
+    .Data1 = s2_data,
+  };
+
+  const int s1_data = 0x1234567;
+  TestStruct1 s1 {
+    .Next = &s2,
+    .Type = StructType::Struct1,
+    .Data2 = 0xab,
+    .Data1 = s1_data,
+  };
+
+  CHECK(ReadData1(&s1, 0) == s1_data);
+  CHECK(ReadData1(&s1, 1) == s2_data);
+}
diff --git a/unittests/ThunkLibs/generator.cpp b/unittests/ThunkLibs/generator.cpp
index 291df0ce2a..99fd6c674c 100644
--- a/unittests/ThunkLibs/generator.cpp
+++ b/unittests/ThunkLibs/generator.cpp
@@ -287,6 +287,12 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "  T data;\n"
         "};\n"
         "\n"
+        "template<typename T, std::size_t N>\n"
+        "struct guest_layout<T[N]> {\n"
+        "  using type = std::enable_if_t<!std::is_pointer_v<T>, T>;\n"
+        "  std::array<guest_layout<type>, N> data;\n"
+        "};\n"
+        "\n"
         "template<typename T>\n"
         "struct guest_layout<T*> {\n"
         "#ifdef IS_32BIT_THUNK\n"
@@ -329,6 +335,12 @@ SourceWithAST Fixture::run_thunkgen_host(std::string_view prelude, std::string_v
         "#endif\n"
         "};\n"
         "\n"
+        "template<typename T, size_t N>\n"
+        "struct host_layout<T[N]> {\n"
+        "  std::array<T, N> data;\n"
+        "  host_layout(const guest_layout<T[N]>& from);\n"
+        "};\n"
+        "\n"
         "template<typename T, typename GuestT>\n"
         "struct repack_wrapper {};\n"
         "template<typename T, typename GuestT>\n"