[PATCH 2/7] winevulkan: Use PTR32 for pointer-size variables in 32-bit structs.

[Jacek Caban]

From: Jacek Caban

---
 dlls/winevulkan/make_vulkan     |  167 +-
 dlls/winevulkan/vulkan_thunks.c | 7436 +++++++++++++++----------------
 2 files changed, 3844 insertions(+), 3759 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index b215493ca0e..79cc1c8f4af 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -774,7 +774,7 @@ class VkFunction(object):
         if needs_alloc:
             body += "    struct conversion_context ctx;\n"
         body += "\n"
-        body += "    {0}\n".format(self.trace(params_prefix=params_prefix))
+        body += "    {0}\n".format(self.trace(params_prefix=params_prefix, conv=conv))

if self.params[0].optional and self.params[0].is_handle():
             if self.type != "void":
@@ -792,16 +792,19 @@ class VkFunction(object):
                 body += p.copy(Direction.INPUT, conv, unwrap, prefix=params_prefix)
             elif p.is_dynamic_array() and p.needs_conversion(conv, unwrap, Direction.OUTPUT):
                 body += "    {0}_host = ({2}{0} && {1}) ? conversion_context_alloc(&ctx, sizeof(*{0}_host) * {1}) : NULL;\n".format(
-                    p.name, p.get_dyn_array_len(params_prefix), params_prefix)
+                    p.name, p.get_dyn_array_len(params_prefix, conv), params_prefix)

# Build list of parameters containing converted and non-converted parameters.
         # The param itself knows if conversion is needed and applies it when we set conv=True.
         params = ", ".join([p.variable(conv=conv, unwrap=unwrap, params_prefix=params_prefix) for p in self.params])
         if self.extra_param:
-            params += ", {0}{1}".format(params_prefix, self.extra_param)
+            if conv:
+                params += ", UlongToPtr({0}{1})".format(params_prefix, self.extra_param)
+            else:
+                params += ", {0}{1}".format(params_prefix, self.extra_param)

if unwrap or self.thunk_type == ThunkType.PUBLIC:
-            func_prefix = "{0}.p_".format(self.params[0].dispatch_table(params_prefix))
+            func_prefix = "{0}.p_".format(self.params[0].dispatch_table(params_prefix, conv))
         else:
             func_prefix = "wine_"

@@ -869,7 +872,7 @@ class VkFunction(object):
             for p in self.params:
                 thunk += "        {0};\n".format(p.definition(conv=True, is_member=True))
             if self.extra_param:
-                thunk += "        void *{0};\n".format(self.extra_param)
+                thunk += "        PTR32 {0};\n".format(self.extra_param)
             if self.type != "void":
                 thunk += "        {0} result;\n".format(self.type)
             thunk += "    } *params = args;\n"
@@ -886,7 +889,7 @@ class VkFunction(object):
         thunk += "}\n\n"
         return thunk

-    def trace(self, message=None, trace_func=None, params_prefix=""):
+    def trace(self, message=None, trace_func=None, params_prefix="", conv=False):
         """ Create a trace string including all parameters.

Args:
@@ -902,7 +905,7 @@ class VkFunction(object):
             trace += message

# First loop is for all the format strings.
-        trace += ", ".join([p.format_string() for p in self.params])
+        trace += ", ".join([p.format_string(conv) for p in self.params])
         trace += "\n""

# Second loop for parameter names and optional conversions.
@@ -1131,7 +1134,7 @@ class VkVariable(object):
         self.handle = type_info["data"] if type_info["category"] == "handle" else None
         self.struct = type_info["data"] if type_info["category"] == "struct" else None

-    def get_dyn_array_len(self, prefix):
+    def get_dyn_array_len(self, prefix, conv):
         if isinstance(self.dyn_array_len, int):
             return self.dyn_array_len

@@ -1144,14 +1147,16 @@ class VkVariable(object):
         if i != -1:
             var = parent[parent.index(len_str[0:i])]
             len_str = len_str[i+2:]
-            len += var.name + "->"
-            parent = var.struct.members
+            len = "({0})->".format(var.value(len, conv))
+            parent = var.struct

-        len += len_str
         if len_str in parent:
             var = parent[parent.index(len_str)]
+            len = var.value(len, conv);
             if var.is_pointer():
                 len = "*" + len
+        else:
+            len += len_str

if isinstance(self.parent, VkStruct) and self.parent.name in MEMBER_LENGTH_EXPRESSIONS:
             exprs = MEMBER_LENGTH_EXPRESSIONS[self.parent.name]
@@ -1290,6 +1295,39 @@ class VkVariable(object):

return conversions

+    def needs_ptr32_type(self):
+        """ Check if variable needs to use PTR32 type. """
+
+        return self.is_pointer() or self.is_pointer_size() or self.is_static_array()
+
+    def value(self, prefix, conv):
+        """ Returns code accessing member value, casting 32-bit pointers when needed. """
+
+        if not conv or not self.needs_ptr32_type() or (not self.is_pointer() and self.type == "size_t"):
+            return prefix + self.name
+
+        # FIXME: Use conversion instead
+        if self.name in ["ppUsageCounts", "ppEnabledLayerNames", "ppEnabledExtensionNames"]:
+            return "UlongToPtr({0}{1})".format(prefix, self.name)
+
+        cast_type = ""
+        if self.const:
+            cast_type += "const "
+
+        if self.pointer_array or ((self.is_dynamic_array() or self.is_static_array()) and self.is_pointer_size()):
+            cast_type += "PTR32 *"
+        else:
+            cast_type += self.type
+            if self.needs_host_type():
+                cast_type += "32"
+
+            if self.is_pointer():
+                cast_type += " {0}".format(self.pointer)
+            elif self.is_static_array():
+                cast_type += " *"
+
+        return "({0})UlongToPtr({1}{2})".format(cast_type, prefix, self.name)
+

class VkMember(VkVariable):
     def __init__(self, const=False, struct_fwd_decl=False,_type=None, pointer=None, name=None, array_len=None,
@@ -1383,15 +1421,17 @@ class VkMember(VkVariable):
         if self.needs_conversion(conv, unwrap, direction, False):
             if self.is_dynamic_array():
                 # Array length is either a variable name (string) or an int.
-                count = self.get_dyn_array_len(input)
+                count = self.get_dyn_array_len(input, conv)
                 host_part = "host" if unwrap else "unwrapped_host"
                 pointer_part = "pointer_" if self.pointer_array else ""
                 if direction == Direction.OUTPUT:
-                    return "convert_{2}_{7}array_{6}_to_{5}({3}{1}, {0}{1}, {4});\n".format(
-                        output, self.name, self.type, input, count, win_type, host_part, pointer_part)
+                    return "convert_{2}_{7}array_{6}_to_{5}({3}{1}, {0}, {4});\n".format(
+                        self.value(output, conv), self.name, self.type, input, count, win_type,
+                        host_part, pointer_part)
                 else:
-                    return "{0}{1} = convert_{2}_{7}array_{5}_to_{6}(ctx, {3}{1}, {4});\n".format(
-                        output, self.name, self.type, input, count, win_type, host_part, pointer_part)
+                    return "{0}{1} = convert_{2}_{7}array_{5}_to_{6}(ctx, {3}, {4});\n".format(
+                        output, self.name, self.type, self.value(input, conv), count, win_type,
+                        host_part, pointer_part)
             elif self.is_static_array():
                 count = self.array_len
                 if direction == Direction.OUTPUT:
@@ -1407,7 +1447,7 @@ class VkMember(VkVariable):
                     LOGGER.err("OUTPUT parameter {0}.{1} cannot be unwrapped".format(self.type, self.name))
                 else:
                     handle = self.type_info["data"]
-                    return "{0}{1} = {2};\n".format(output, self.name, handle.driver_handle("{0}{1}".format(input, self.name)))
+                    return "{0}{1} = {2};\n".format(output, self.name, handle.driver_handle(self.value(input, conv)))
             elif self.is_generic_handle():
                 if direction == Direction.OUTPUT:
                     LOGGER.err("OUTPUT parameter {0}.{1} cannot be unwrapped".format(self.type, self.name))
@@ -1423,6 +1463,10 @@ class VkMember(VkVariable):
         elif self.is_static_array():
             bytes_count = "{0} * sizeof({1})".format(self.array_len, self.type)
             return "memcpy({0}{1}, {2}{1}, {3});\n".format(output, self.name, input, bytes_count)
+        elif direction == Direction.INPUT:
+            return "{0}{1} = {2};\n".format(output, self.name, self.value(input, conv))
+        elif conv and direction == Direction.OUTPUT and self.is_pointer():
+            return "{0}{1} = PtrToUlong({2}{1});\n".format(output, self.name, input)
         else:
             return "{0}{1} = {2}{1};\n".format(output, self.name, input)

@@ -1434,6 +1478,12 @@ class VkMember(VkVariable):
             conv (bool, optional): Enable conversion if a type needs it. This appends '_host' to the name.
         """

+        if conv and (self.is_pointer() or self.is_pointer_size()):
+            text = "PTR32 " + self.name
+            if self.is_static_array():
+                text += "[{0}]".format(self.array_len)
+            return text
+
         text = ""
         if self.is_const():
             text += "const "
@@ -1612,33 +1662,40 @@ class VkParam(VkVariable):
         if direction == Direction.INPUT:
             ctx_param = "&ctx, " if self.needs_alloc(conv, unwrap) else ""
             if self.is_dynamic_array():
-                return "    {1}_host = convert_{2}_array_{4}_to_{6}host({5}{0}{1}, {3});\n".format(
-                    prefix, self.name, self.type, self.get_dyn_array_len(prefix), win_type, ctx_param, wrap_part)
+                return "    {0}_host = convert_{2}_array_{4}_to_{6}host({5}{1}, {3});\n".format(
+                    self.name, self.value(prefix, conv), self.type, self.get_dyn_array_len(prefix, conv),
+                    win_type, ctx_param, wrap_part)
             elif self.optional:
                 ret  = "    if ({0}{1})\n".format(prefix, self.name)
                 ret += "    {\n"
                 ret += "        {0}_host = conversion_context_alloc(&ctx, sizeof(*{0}_host));\n".format(self.name)
-                ret += "        convert_{0}_{3}_to_{5}host({4}{1}{2}, {2}_host);\n".format(self.type, prefix, self.name, win_type, ctx_param, wrap_part)
+                ret += "        convert_{0}_{3}_to_{5}host({4}{1}, {2}_host);\n".format(
+                    self.type, self.value(prefix, conv), self.name, win_type, ctx_param, wrap_part)
                 ret += "    }\n"
                 return ret
             elif self.is_struct():
-                return "    convert_{0}_{3}_to_{5}host({4}{1}{2}, &{2}_host);\n".format(self.type, prefix, self.name, win_type, ctx_param, wrap_part)
+                return "    convert_{0}_{3}_to_{5}host({4}{1}, &{2}_host);\n".format(
+                    self.type, self.value(prefix, conv), self.name, win_type, ctx_param, wrap_part)
             else:
-                return "    {1}_host = *{0}{1};\n".format(prefix, self.name)
+                return "    {0}_host = *{1};\n".format(self.name, self.value(prefix, conv))
         else:
             if self.is_dynamic_array():
-                return "    convert_{0}_array_{1}host_to_{2}({3}_host, {4}{3}, {5});\n".format(
-                    self.type, wrap_part, win_type, self.name, prefix, self.get_dyn_array_len(prefix))
+                return "    convert_{0}_array_{1}host_to_{2}({3}_host, {4}, {5});\n".format(
+                    self.type, wrap_part, win_type, self.name, self.value(prefix, conv),
+                    self.get_dyn_array_len(prefix, conv))
             elif self.is_struct():
                 ref_part = "" if self.optional else "&"
-                return "    convert_{0}_host_to_{3}({4}{2}_host, {1}{2});\n".format(
-                    self.type, prefix, self.name, win_type, ref_part)
+                return "    convert_{0}_host_to_{3}({4}{2}_host, {1});\n".format(
+                    self.type, self.value(prefix, conv), self.name, win_type, ref_part)
             else:
-                return "    *{0}{1} = {1}_host;\n".format(prefix, self.name)
+                return "    *{0} = {1}_host;\n".format(self.value(prefix, conv), self.name)

def definition(self, postfix=None, is_member=False, conv=False):
         """ Return prototype for the parameter. E.g. 'const char *foo' """

+        if is_member and conv and self.needs_ptr32_type():
+            return "PTR32 {0}".format(self.name)
+
         proto = ""
         if self.const:
             proto += self.const + " "
@@ -1668,15 +1725,17 @@ class VkParam(VkVariable):

return proto

-    def dispatch_table(self, params_prefix=""):
+    def dispatch_table(self, params_prefix, conv):
         """ Return functions dispatch table pointer for dispatchable objects. """

if not self.is_dispatchable():
             return None

-        return self.handle.dispatch_table(params_prefix + self.name)
+        return self.handle.dispatch_table(self.value(params_prefix, conv))

-    def format_string(self):
+    def format_string(self, conv):
+        if conv and self.needs_ptr32_type() and (self.type != "size_t" or self.is_pointer()):
+            return "%#x"
         return self.format_str

def is_dispatchable(self):
@@ -1765,17 +1824,20 @@ class VkParam(VkVariable):
                 return "{0}_host".format(self.name)
             else:
                 return "&{0}_host".format(self.name)
-        elif unwrap:
+
+        p = self.value(params_prefix, conv)
+
+        if unwrap:
             if self.object_type != None and self.type == "uint64_t":
                 return "wine_vk_unwrap_handle({0}{1}, {0}{2})".format(params_prefix, self.object_type, self.name)

# We need to pass the native handle to the native Vulkan calls and
             # the wine driver's handle to calls which are wrapped by the driver.
-            p = "{0}{1}".format(params_prefix, self.name)
             driver_handle = self.handle.driver_handle(p) if self.is_handle() else None
-            return driver_handle if driver_handle else p
-        else:
-            return "{0}{1}".format(params_prefix, self.name)
+            if driver_handle:
+                return driver_handle
+
+        return p

class VkStruct(Sequence):
@@ -2327,8 +2389,11 @@ class ArrayConversionFunction(object):
         needs_alloc = self.direction != Direction.OUTPUT and self.array.needs_alloc(self.conv, self.unwrap)

win_type = self.type
-        if self.conv and self.array.needs_host_type():
-            win_type += "32"
+        if self.conv:
+            if self.array.needs_host_type():
+                win_type += "32"
+            elif self.array.is_handle() and self.array.handle.is_dispatchable():
+                win_type = "PTR32"
         if self.direction == Direction.OUTPUT and self.array.is_const():
             win_type = "const " + win_type
         pointer_part = self.array.pointer if self.array.pointer else "*"
@@ -2337,6 +2402,9 @@ class ArrayConversionFunction(object):
             params = ["const {0} {1}in".format(self.type, pointer_part),
                       "{0} {1}out".format(win_type, pointer_part), "uint32_t count"]
             return_type = None
+        elif self.conv and self.array.pointer_array:
+            params = ["const PTR32 *in", "uint32_t count"]
+            return_type = self.type
         else:
             params = ["const {0} {1}in".format(win_type, pointer_part), "uint32_t count"]
             return_type = self.type
@@ -2393,17 +2461,34 @@ class ArrayConversionFunction(object):
                     body += "        {\n"
                     body += "            out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));\n"
                     if struct.needs_conversion(self.conv, self.unwrap, self.direction, False):
-                        body += "            convert_{0}_{1}({2}in[i], out[i]);\n".format(
-                            struct.name, conv_suffix, ctx_part)
+                        if self.conv:
+                            in_param = "({0} *)UlongToPtr(in[i])".format(win_type)
+                        else:
+                            in_param = "in[i]"
+                        body += "            convert_{0}_{1}({2}{3}, out[i]);\n".format(
+                            struct.name, conv_suffix, ctx_part, in_param)
                     else:
                         body += "            *out[i] = *in[i];\n".format(win_type)
                     body += "        }\n"
                     body += "        else\n"
                     body += "            out[i] = NULL;\n"
-            elif self.array.is_handle() and self.direction == Direction.INPUT and self.unwrap:
+            elif self.array.is_handle():
                 if self.array.pointer_array:
                     LOGGER.error("Unhandled handle pointer arrays")
-                body += "        out[i] = " + self.array.handle.driver_handle("in[i]") + ";\n"
+                handle = self.array.handle
+                if not self.conv or not handle.is_dispatchable():
+                    input = "in[i]"
+                elif self.direction == Direction.INPUT:
+                    input = "UlongToPtr(in[i])"
+                else:
+                    input = "PtrToUlong(in[i])"
+
+                if not self.unwrap or not handle.is_wrapped():
+                    body += "        out[i] = {0};\n".format(input)
+                elif self.direction == Direction.INPUT:
+                    body += "        out[i] = " + handle.driver_handle(input) + ";\n"
+                else:
+                    LOGGER.warning("Unhandled handle output conversion")
             else:
                 body += "        out[i] = in[i];\n"

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index f9412d124d0..303f3c640c4 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -26,7 +26,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
 typedef struct VkAcquireNextImageInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
     uint64_t DECLSPEC_ALIGN(8) timeout;
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
@@ -37,14 +37,14 @@ typedef struct VkAcquireNextImageInfoKHR32
 typedef struct VkPerformanceConfigurationAcquireInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPerformanceConfigurationTypeINTEL type;
 } VkPerformanceConfigurationAcquireInfoINTEL32;

typedef struct VkAcquireProfilingLockInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAcquireProfilingLockFlagsKHR flags;
     uint64_t DECLSPEC_ALIGN(8) timeout;
 } VkAcquireProfilingLockInfoKHR32;
@@ -52,7 +52,7 @@ typedef struct VkAcquireProfilingLockInfoKHR32
 typedef struct VkCommandBufferAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCommandPool DECLSPEC_ALIGN(8) commandPool;
     VkCommandBufferLevel level;
     uint32_t commandBufferCount;
@@ -61,25 +61,25 @@ typedef struct VkCommandBufferAllocateInfo32
 typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t descriptorSetCount;
-    const uint32_t *pDescriptorCounts;
+    PTR32 pDescriptorCounts;
 } VkDescriptorSetVariableDescriptorCountAllocateInfo32;
 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32;

typedef struct VkDescriptorSetAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
     uint32_t descriptorSetCount;
-    const VkDescriptorSetLayout *pSetLayouts;
+    PTR32 pSetLayouts;
 } VkDescriptorSetAllocateInfo32;

typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) image;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
 } VkDedicatedAllocationMemoryAllocateInfoNV32;
@@ -87,7 +87,7 @@ typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32
 typedef struct VkExportMemoryAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlags handleTypes;
 } VkExportMemoryAllocateInfo32;
 typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
@@ -95,7 +95,7 @@ typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;
 typedef struct VkImportMemoryWin32HandleInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlagBits handleType;
     HANDLE handle;
     LPCWSTR name;
@@ -104,8 +104,8 @@ typedef struct VkImportMemoryWin32HandleInfoKHR32
 typedef struct VkExportMemoryWin32HandleInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
-    const SECURITY_ATTRIBUTES *pAttributes;
+    PTR32 pNext;
+    PTR32 pAttributes;
     DWORD dwAccess;
     LPCWSTR name;
 } VkExportMemoryWin32HandleInfoKHR32;
@@ -113,7 +113,7 @@ typedef struct VkExportMemoryWin32HandleInfoKHR32
 typedef struct VkMemoryAllocateFlagsInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMemoryAllocateFlags flags;
     uint32_t deviceMask;
 } VkMemoryAllocateFlagsInfo32;
@@ -122,7 +122,7 @@ typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;
 typedef struct VkMemoryDedicatedAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) image;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
 } VkMemoryDedicatedAllocateInfo32;
@@ -131,22 +131,22 @@ typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;
 typedef struct VkImportMemoryHostPointerInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlagBits handleType;
-    void *pHostPointer;
+    PTR32 pHostPointer;
 } VkImportMemoryHostPointerInfoEXT32;

typedef struct VkMemoryPriorityAllocateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     float priority;
 } VkMemoryPriorityAllocateInfoEXT32;

typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 } VkMemoryOpaqueCaptureAddressAllocateInfo32;
 typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;
@@ -154,7 +154,7 @@ typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressA
 typedef struct VkMemoryAllocateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) allocationSize;
     uint32_t memoryTypeIndex;
 } VkMemoryAllocateInfo32;
@@ -162,14 +162,14 @@ typedef struct VkMemoryAllocateInfo32
 typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 conditionalRenderingEnable;
 } VkCommandBufferInheritanceConditionalRenderingInfoEXT32;

typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSurfaceTransformFlagBitsKHR transform;
     VkRect2D renderArea;
 } VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;
@@ -177,20 +177,20 @@ typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32
 typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 viewportScissor2D;
     uint32_t viewportDepthCount;
-    const VkViewport *pViewportDepths;
+    PTR32 pViewportDepths;
 } VkCommandBufferInheritanceViewportScissorInfoNV32;

typedef struct VkCommandBufferInheritanceRenderingInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderingFlags flags;
     uint32_t viewMask;
     uint32_t colorAttachmentCount;
-    const VkFormat *pColorAttachmentFormats;
+    PTR32 pColorAttachmentFormats;
     VkFormat depthAttachmentFormat;
     VkFormat stencilAttachmentFormat;
     VkSampleCountFlagBits rasterizationSamples;
@@ -200,9 +200,9 @@ typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRend
 typedef struct VkAttachmentSampleCountInfoAMD32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t colorAttachmentCount;
-    const VkSampleCountFlagBits *pColorAttachmentSamples;
+    PTR32 pColorAttachmentSamples;
     VkSampleCountFlagBits depthStencilAttachmentSamples;
 } VkAttachmentSampleCountInfoAMD32;
 typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
@@ -210,7 +210,7 @@ typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;
 typedef struct VkMultiviewPerViewAttributesInfoNVX32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 perViewAttributes;
     VkBool32 perViewAttributesPositionXOnly;
 } VkMultiviewPerViewAttributesInfoNVX32;
@@ -218,7 +218,7 @@ typedef struct VkMultiviewPerViewAttributesInfoNVX32
 typedef struct VkCommandBufferInheritanceInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
     uint32_t subpass;
     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
@@ -230,7 +230,7 @@ typedef struct VkCommandBufferInheritanceInfo32
 typedef struct VkDeviceGroupCommandBufferBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t deviceMask;
 } VkDeviceGroupCommandBufferBeginInfo32;
 typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32;
@@ -238,35 +238,35 @@ typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInf
 typedef struct VkCommandBufferBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCommandBufferUsageFlags flags;
-    const VkCommandBufferInheritanceInfo32 *pInheritanceInfo;
+    PTR32 pInheritanceInfo;
 } VkCommandBufferBeginInfo32;

typedef struct VkBindAccelerationStructureMemoryInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
     uint32_t deviceIndexCount;
-    const uint32_t *pDeviceIndices;
+    PTR32 pDeviceIndices;
 } VkBindAccelerationStructureMemoryInfoNV32;

typedef struct VkBindBufferMemoryDeviceGroupInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t deviceIndexCount;
-    const uint32_t *pDeviceIndices;
+    PTR32 pDeviceIndices;
 } VkBindBufferMemoryDeviceGroupInfo32;
 typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;

typedef struct VkBindBufferMemoryInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
@@ -276,18 +276,18 @@ typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;
 typedef struct VkBindImageMemoryDeviceGroupInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t deviceIndexCount;
-    const uint32_t *pDeviceIndices;
+    PTR32 pDeviceIndices;
     uint32_t splitInstanceBindRegionCount;
-    const VkRect2D *pSplitInstanceBindRegions;
+    PTR32 pSplitInstanceBindRegions;
 } VkBindImageMemoryDeviceGroupInfo32;
 typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;

typedef struct VkBindImageMemorySwapchainInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
     uint32_t imageIndex;
 } VkBindImageMemorySwapchainInfoKHR32;
@@ -295,7 +295,7 @@ typedef struct VkBindImageMemorySwapchainInfoKHR32
 typedef struct VkBindImagePlaneMemoryInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageAspectFlagBits planeAspect;
 } VkBindImagePlaneMemoryInfo32;
 typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
@@ -303,7 +303,7 @@ typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;
 typedef struct VkBindImageMemoryInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) image;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
@@ -313,7 +313,7 @@ typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;
 typedef struct VkAccelerationStructureGeometryKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkGeometryTypeKHR geometryType;
     VkAccelerationStructureGeometryDataKHR DECLSPEC_ALIGN(8) geometry;
     VkGeometryFlagsKHR flags;
@@ -322,29 +322,29 @@ typedef struct VkAccelerationStructureGeometryKHR32
 typedef struct VkAccelerationStructureBuildGeometryInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureTypeKHR type;
     VkBuildAccelerationStructureFlagsKHR flags;
     VkBuildAccelerationStructureModeKHR mode;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure;
     uint32_t geometryCount;
-    const VkAccelerationStructureGeometryKHR32 *pGeometries;
-    const VkAccelerationStructureGeometryKHR32 * const*ppGeometries;
+    PTR32 pGeometries;
+    PTR32 ppGeometries;
     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
 } VkAccelerationStructureBuildGeometryInfoKHR32;

typedef struct VkMicromapBuildInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMicromapTypeEXT type;
     VkBuildMicromapFlagsEXT flags;
     VkBuildMicromapModeEXT mode;
     VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap;
     uint32_t usageCountsCount;
-    const VkMicromapUsageEXT *pUsageCounts;
-    const VkMicromapUsageEXT * const*ppUsageCounts;
+    PTR32 pUsageCounts;
+    PTR32 ppUsageCounts;
     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data;
     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData;
     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray;
@@ -354,7 +354,7 @@ typedef struct VkMicromapBuildInfoEXT32
 typedef struct VkConditionalRenderingBeginInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkDeviceSize DECLSPEC_ALIGN(8) offset;
     VkConditionalRenderingFlagsEXT flags;
@@ -363,19 +363,19 @@ typedef struct VkConditionalRenderingBeginInfoEXT32
 typedef struct VkDebugUtilsLabelEXT32
 {
     VkStructureType sType;
-    const void *pNext;
-    const char *pLabelName;
+    PTR32 pNext;
+    PTR32 pLabelName;
     float color[4];
 } VkDebugUtilsLabelEXT32;

typedef struct VkSampleLocationsInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSampleCountFlagBits sampleLocationsPerPixel;
     VkExtent2D sampleLocationGridSize;
     uint32_t sampleLocationsCount;
-    const VkSampleLocationEXT *pSampleLocations;
+    PTR32 pSampleLocations;
 } VkSampleLocationsInfoEXT32;

typedef struct VkAttachmentSampleLocationsEXT32
@@ -393,54 +393,54 @@ typedef struct VkSubpassSampleLocationsEXT32
 typedef struct VkDeviceGroupRenderPassBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t deviceMask;
     uint32_t deviceRenderAreaCount;
-    const VkRect2D *pDeviceRenderAreas;
+    PTR32 pDeviceRenderAreas;
 } VkDeviceGroupRenderPassBeginInfo32;
 typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;

typedef struct VkRenderPassSampleLocationsBeginInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t attachmentInitialSampleLocationsCount;
-    const VkAttachmentSampleLocationsEXT32 *pAttachmentInitialSampleLocations;
+    PTR32 pAttachmentInitialSampleLocations;
     uint32_t postSubpassSampleLocationsCount;
-    const VkSubpassSampleLocationsEXT32 *pPostSubpassSampleLocations;
+    PTR32 pPostSubpassSampleLocations;
 } VkRenderPassSampleLocationsBeginInfoEXT32;

typedef struct VkRenderPassAttachmentBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t attachmentCount;
-    const VkImageView *pAttachments;
+    PTR32 pAttachments;
 } VkRenderPassAttachmentBeginInfo32;
 typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;

typedef struct VkRenderPassTransformBeginInfoQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSurfaceTransformFlagBitsKHR transform;
 } VkRenderPassTransformBeginInfoQCOM32;

typedef struct VkRenderPassBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
     VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
     VkRect2D renderArea;
     uint32_t clearValueCount;
-    const VkClearValue *pClearValues;
+    PTR32 pClearValues;
 } VkRenderPassBeginInfo32;

typedef struct VkSubpassBeginInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSubpassContents contents;
 } VkSubpassBeginInfo32;
 typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
@@ -448,7 +448,7 @@ typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;
 typedef struct VkRenderingAttachmentInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageView DECLSPEC_ALIGN(8) imageView;
     VkImageLayout imageLayout;
     VkResolveModeFlagBits resolveMode;
@@ -463,7 +463,7 @@ typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;
 typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 multisampledRenderToSingleSampledEnable;
     VkSampleCountFlagBits rasterizationSamples;
 } VkMultisampledRenderToSingleSampledInfoEXT32;
@@ -471,7 +471,7 @@ typedef struct VkMultisampledRenderToSingleSampledInfoEXT32
 typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageView DECLSPEC_ALIGN(8) imageView;
     VkImageLayout imageLayout;
     VkExtent2D shadingRateAttachmentTexelSize;
@@ -480,7 +480,7 @@ typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32
 typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageView DECLSPEC_ALIGN(8) imageView;
     VkImageLayout imageLayout;
 } VkRenderingFragmentDensityMapAttachmentInfoEXT32;
@@ -488,29 +488,29 @@ typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32
 typedef struct VkRenderingInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderingFlags flags;
     VkRect2D renderArea;
     uint32_t layerCount;
     uint32_t viewMask;
     uint32_t colorAttachmentCount;
-    const VkRenderingAttachmentInfo32 *pColorAttachments;
-    const VkRenderingAttachmentInfo32 *pDepthAttachment;
-    const VkRenderingAttachmentInfo32 *pStencilAttachment;
+    PTR32 pColorAttachments;
+    PTR32 pDepthAttachment;
+    PTR32 pStencilAttachment;
 } VkRenderingInfo32;
 typedef VkRenderingInfo32 VkRenderingInfoKHR32;

typedef struct VkCopyCommandTransformInfoQCOM32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSurfaceTransformFlagBitsKHR transform;
 } VkCopyCommandTransformInfoQCOM32;

typedef struct VkImageBlit232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageSubresourceLayers srcSubresource;
     VkOffset3D srcOffsets[2];
     VkImageSubresourceLayers dstSubresource;
@@ -521,13 +521,13 @@ typedef VkImageBlit232 VkImageBlit2KHR32;
 typedef struct VkBlitImageInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) srcImage;
     VkImageLayout srcImageLayout;
     VkImage DECLSPEC_ALIGN(8) dstImage;
     VkImageLayout dstImageLayout;
     uint32_t regionCount;
-    const VkImageBlit232 *pRegions;
+    PTR32 pRegions;
     VkFilter filter;
 } VkBlitImageInfo232;
 typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
@@ -535,7 +535,7 @@ typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;
 typedef struct VkGeometryTrianglesNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) vertexData;
     VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset;
     uint32_t vertexCount;
@@ -552,7 +552,7 @@ typedef struct VkGeometryTrianglesNV32
 typedef struct VkGeometryAABBNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) aabbData;
     uint32_t numAABBs;
     uint32_t stride;
@@ -568,7 +568,7 @@ typedef struct VkGeometryDataNV32
 typedef struct VkGeometryNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkGeometryTypeKHR geometryType;
     VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry;
     VkGeometryFlagsKHR flags;
@@ -577,18 +577,18 @@ typedef struct VkGeometryNV32
 typedef struct VkAccelerationStructureInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureTypeNV type;
     VkBuildAccelerationStructureFlagsNV flags;
     uint32_t instanceCount;
     uint32_t geometryCount;
-    const VkGeometryNV32 *pGeometries;
+    PTR32 pGeometries;
 } VkAccelerationStructureInfoNV32;

typedef struct VkCopyAccelerationStructureInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
     VkCopyAccelerationStructureModeKHR mode;
@@ -597,7 +597,7 @@ typedef struct VkCopyAccelerationStructureInfoKHR32
 typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src;
     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
     VkCopyAccelerationStructureModeKHR mode;
@@ -613,7 +613,7 @@ typedef struct VkBufferCopy32
 typedef struct VkBufferCopy232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) srcOffset;
     VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
     VkDeviceSize DECLSPEC_ALIGN(8) size;
@@ -623,11 +623,11 @@ typedef VkBufferCopy232 VkBufferCopy2KHR32;
 typedef struct VkCopyBufferInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
     uint32_t regionCount;
-    const VkBufferCopy232 *pRegions;
+    PTR32 pRegions;
 } VkCopyBufferInfo232;
 typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;

@@ -644,7 +644,7 @@ typedef struct VkBufferImageCopy32
 typedef struct VkBufferImageCopy232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset;
     uint32_t bufferRowLength;
     uint32_t bufferImageHeight;
@@ -657,19 +657,19 @@ typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;
 typedef struct VkCopyBufferToImageInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
     VkImage DECLSPEC_ALIGN(8) dstImage;
     VkImageLayout dstImageLayout;
     uint32_t regionCount;
-    const VkBufferImageCopy232 *pRegions;
+    PTR32 pRegions;
 } VkCopyBufferToImageInfo232;
 typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;

typedef struct VkImageCopy232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageSubresourceLayers srcSubresource;
     VkOffset3D srcOffset;
     VkImageSubresourceLayers dstSubresource;
@@ -681,32 +681,32 @@ typedef VkImageCopy232 VkImageCopy2KHR32;
 typedef struct VkCopyImageInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) srcImage;
     VkImageLayout srcImageLayout;
     VkImage DECLSPEC_ALIGN(8) dstImage;
     VkImageLayout dstImageLayout;
     uint32_t regionCount;
-    const VkImageCopy232 *pRegions;
+    PTR32 pRegions;
 } VkCopyImageInfo232;
 typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;

typedef struct VkCopyImageToBufferInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) srcImage;
     VkImageLayout srcImageLayout;
     VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
     uint32_t regionCount;
-    const VkBufferImageCopy232 *pRegions;
+    PTR32 pRegions;
 } VkCopyImageToBufferInfo232;
 typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;

typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst;
     VkCopyAccelerationStructureModeKHR mode;
@@ -715,7 +715,7 @@ typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32
 typedef struct VkCopyMemoryToMicromapInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src;
     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
     VkCopyMicromapModeEXT mode;
@@ -724,7 +724,7 @@ typedef struct VkCopyMemoryToMicromapInfoEXT32
 typedef struct VkCopyMicromapInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMicromapEXT DECLSPEC_ALIGN(8) src;
     VkMicromapEXT DECLSPEC_ALIGN(8) dst;
     VkCopyMicromapModeEXT mode;
@@ -733,7 +733,7 @@ typedef struct VkCopyMicromapInfoEXT32
 typedef struct VkCopyMicromapToMemoryInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMicromapEXT DECLSPEC_ALIGN(8) src;
     VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst;
     VkCopyMicromapModeEXT mode;
@@ -742,7 +742,7 @@ typedef struct VkCopyMicromapToMemoryInfoEXT32
 typedef struct VkCuLaunchInfoNVX32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
     uint32_t gridDimX;
     uint32_t gridDimY;
@@ -751,17 +751,17 @@ typedef struct VkCuLaunchInfoNVX32
     uint32_t blockDimY;
     uint32_t blockDimZ;
     uint32_t sharedMemBytes;
-    size_t paramCount;
-    const void * const *pParams;
-    size_t extraCount;
-    const void * const *pExtras;
+    PTR32 paramCount;
+    PTR32 pParams;
+    PTR32 extraCount;
+    PTR32 pExtras;
 } VkCuLaunchInfoNVX32;

typedef struct VkDebugMarkerMarkerInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
-    const char *pMarkerName;
+    PTR32 pNext;
+    PTR32 pMarkerName;
     float color[4];
 } VkDebugMarkerMarkerInfoEXT32;

@@ -777,15 +777,15 @@ typedef struct VkDecompressMemoryRegionNV32
 typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t fragmentDensityOffsetCount;
-    const VkOffset2D *pFragmentDensityOffsets;
+    PTR32 pFragmentDensityOffsets;
 } VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;

typedef struct VkSubpassEndInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
 } VkSubpassEndInfo32;
 typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;

@@ -798,12 +798,12 @@ typedef struct VkIndirectCommandsStreamNV32
 typedef struct VkGeneratedCommandsInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineBindPoint pipelineBindPoint;
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
     uint32_t streamCount;
-    const VkIndirectCommandsStreamNV32 *pStreams;
+    PTR32 pStreams;
     uint32_t sequencesCount;
     VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer;
     VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset;
@@ -817,16 +817,16 @@ typedef struct VkGeneratedCommandsInfoNV32
 typedef struct VkOpticalFlowExecuteInfoNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkOpticalFlowExecuteFlagsNV flags;
     uint32_t regionCount;
-    const VkRect2D *pRegions;
+    PTR32 pRegions;
 } VkOpticalFlowExecuteInfoNV32;

typedef struct VkMemoryBarrier32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccessFlags srcAccessMask;
     VkAccessFlags dstAccessMask;
 } VkMemoryBarrier32;
@@ -834,7 +834,7 @@ typedef struct VkMemoryBarrier32
 typedef struct VkBufferMemoryBarrier32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccessFlags srcAccessMask;
     VkAccessFlags dstAccessMask;
     uint32_t srcQueueFamilyIndex;
@@ -847,7 +847,7 @@ typedef struct VkBufferMemoryBarrier32
 typedef struct VkImageMemoryBarrier32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccessFlags srcAccessMask;
     VkAccessFlags dstAccessMask;
     VkImageLayout oldLayout;
@@ -861,7 +861,7 @@ typedef struct VkImageMemoryBarrier32
 typedef struct VkMemoryBarrier232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
@@ -872,7 +872,7 @@ typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;
 typedef struct VkBufferMemoryBarrier232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
@@ -888,7 +888,7 @@ typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;
 typedef struct VkImageMemoryBarrier232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask;
     VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask;
@@ -905,14 +905,14 @@ typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;
 typedef struct VkDependencyInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDependencyFlags dependencyFlags;
     uint32_t memoryBarrierCount;
-    const VkMemoryBarrier232 *pMemoryBarriers;
+    PTR32 pMemoryBarriers;
     uint32_t bufferMemoryBarrierCount;
-    const VkBufferMemoryBarrier232 *pBufferMemoryBarriers;
+    PTR32 pBufferMemoryBarriers;
     uint32_t imageMemoryBarrierCount;
-    const VkImageMemoryBarrier232 *pImageMemoryBarriers;
+    PTR32 pImageMemoryBarriers;
 } VkDependencyInfo32;
 typedef VkDependencyInfo32 VkDependencyInfoKHR32;

@@ -933,46 +933,46 @@ typedef struct VkDescriptorBufferInfo32
 typedef struct VkWriteDescriptorSetInlineUniformBlock32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t dataSize;
-    const void *pData;
+    PTR32 pData;
 } VkWriteDescriptorSetInlineUniformBlock32;
 typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;

typedef struct VkWriteDescriptorSetAccelerationStructureKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t accelerationStructureCount;
-    const VkAccelerationStructureKHR *pAccelerationStructures;
+    PTR32 pAccelerationStructures;
 } VkWriteDescriptorSetAccelerationStructureKHR32;

typedef struct VkWriteDescriptorSetAccelerationStructureNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t accelerationStructureCount;
-    const VkAccelerationStructureNV *pAccelerationStructures;
+    PTR32 pAccelerationStructures;
 } VkWriteDescriptorSetAccelerationStructureNV32;

typedef struct VkWriteDescriptorSet32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorSet DECLSPEC_ALIGN(8) dstSet;
     uint32_t dstBinding;
     uint32_t dstArrayElement;
     uint32_t descriptorCount;
     VkDescriptorType descriptorType;
-    const VkDescriptorImageInfo32 *pImageInfo;
-    const VkDescriptorBufferInfo32 *pBufferInfo;
-    const VkBufferView *pTexelBufferView;
+    PTR32 pImageInfo;
+    PTR32 pBufferInfo;
+    PTR32 pTexelBufferView;
 } VkWriteDescriptorSet32;

typedef struct VkImageResolve232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageSubresourceLayers srcSubresource;
     VkOffset3D srcOffset;
     VkImageSubresourceLayers dstSubresource;
@@ -984,13 +984,13 @@ typedef VkImageResolve232 VkImageResolve2KHR32;
 typedef struct VkResolveImageInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) srcImage;
     VkImageLayout srcImageLayout;
     VkImage DECLSPEC_ALIGN(8) dstImage;
     VkImageLayout dstImageLayout;
     uint32_t regionCount;
-    const VkImageResolve232 *pRegions;
+    PTR32 pRegions;
 } VkResolveImageInfo232;
 typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32;

@@ -999,20 +999,20 @@ typedef struct VkCoarseSampleOrderCustomNV32
     VkShadingRatePaletteEntryNV shadingRate;
     uint32_t sampleCount;
     uint32_t sampleLocationCount;
-    const VkCoarseSampleLocationNV *pSampleLocations;
+    PTR32 pSampleLocations;
 } VkCoarseSampleOrderCustomNV32;

typedef struct VkPerformanceMarkerInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) marker;
 } VkPerformanceMarkerInfoINTEL32;

typedef struct VkPerformanceOverrideInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPerformanceOverrideTypeINTEL type;
     VkBool32 enable;
     uint64_t DECLSPEC_ALIGN(8) parameter;
@@ -1021,14 +1021,14 @@ typedef struct VkPerformanceOverrideInfoINTEL32
 typedef struct VkPerformanceStreamMarkerInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t marker;
 } VkPerformanceStreamMarkerInfoINTEL32;

typedef struct VkVertexInputBindingDescription2EXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t binding;
     uint32_t stride;
     VkVertexInputRate inputRate;
@@ -1038,7 +1038,7 @@ typedef struct VkVertexInputBindingDescription2EXT32
 typedef struct VkVertexInputAttributeDescription2EXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t location;
     uint32_t binding;
     VkFormat format;
@@ -1048,7 +1048,7 @@ typedef struct VkVertexInputAttributeDescription2EXT32
 typedef struct VkShadingRatePaletteNV32
 {
     uint32_t shadingRatePaletteEntryCount;
-    const VkShadingRatePaletteEntryNV *pShadingRatePaletteEntries;
+    PTR32 pShadingRatePaletteEntries;
 } VkShadingRatePaletteNV32;

typedef struct VkStridedDeviceAddressRegionKHR32
@@ -1061,7 +1061,7 @@ typedef struct VkStridedDeviceAddressRegionKHR32
 typedef struct VkAccelerationStructureMotionInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t maxInstances;
     VkAccelerationStructureMotionInfoFlagsNV flags;
 } VkAccelerationStructureMotionInfoNV32;
@@ -1069,7 +1069,7 @@ typedef struct VkAccelerationStructureMotionInfoNV32
 typedef struct VkAccelerationStructureCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureCreateFlagsKHR createFlags;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkDeviceSize DECLSPEC_ALIGN(8) offset;
@@ -1081,7 +1081,7 @@ typedef struct VkAccelerationStructureCreateInfoKHR32
 typedef struct VkAccelerationStructureCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) compactedSize;
     VkAccelerationStructureInfoNV32 info;
 } VkAccelerationStructureCreateInfoNV32;
@@ -1089,14 +1089,14 @@ typedef struct VkAccelerationStructureCreateInfoNV32
 typedef struct VkDedicatedAllocationBufferCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 dedicatedAllocation;
 } VkDedicatedAllocationBufferCreateInfoNV32;

typedef struct VkExternalMemoryBufferCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlags handleTypes;
 } VkExternalMemoryBufferCreateInfo32;
 typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;
@@ -1104,7 +1104,7 @@ typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32
 typedef struct VkBufferOpaqueCaptureAddressCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress;
 } VkBufferOpaqueCaptureAddressCreateInfo32;
 typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;
@@ -1112,26 +1112,26 @@ typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCre
 typedef struct VkBufferDeviceAddressCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
 } VkBufferDeviceAddressCreateInfoEXT32;

typedef struct VkBufferCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBufferCreateFlags flags;
     VkDeviceSize DECLSPEC_ALIGN(8) size;
     VkBufferUsageFlags usage;
     VkSharingMode sharingMode;
     uint32_t queueFamilyIndexCount;
-    const uint32_t *pQueueFamilyIndices;
+    PTR32 pQueueFamilyIndices;
 } VkBufferCreateInfo32;

typedef struct VkBufferViewCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBufferViewCreateFlags flags;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkFormat format;
@@ -1142,7 +1142,7 @@ typedef struct VkBufferViewCreateInfo32
 typedef struct VkCommandPoolCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCommandPoolCreateFlags flags;
     uint32_t queueFamilyIndex;
 } VkCommandPoolCreateInfo32;
@@ -1158,46 +1158,46 @@ typedef struct VkSpecializationMapEntry32
 {
     uint32_t constantID;
     uint32_t offset;
-    size_t size;
+    PTR32 size;
 } VkSpecializationMapEntry32;

typedef struct VkSpecializationInfo32
 {
     uint32_t mapEntryCount;
-    const VkSpecializationMapEntry32 *pMapEntries;
-    size_t dataSize;
-    const void *pData;
+    PTR32 pMapEntries;
+    PTR32 dataSize;
+    PTR32 pData;
 } VkSpecializationInfo32;

typedef struct VkShaderModuleCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkShaderModuleCreateFlags flags;
-    size_t codeSize;
-    const uint32_t *pCode;
+    PTR32 codeSize;
+    PTR32 pCode;
 } VkShaderModuleCreateInfo32;

typedef struct VkShaderModuleValidationCacheCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
 } VkShaderModuleValidationCacheCreateInfoEXT32;

typedef struct VkDebugUtilsObjectNameInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkObjectType objectType;
     uint64_t DECLSPEC_ALIGN(8) objectHandle;
-    const char *pObjectName;
+    PTR32 pObjectName;
 } VkDebugUtilsObjectNameInfoEXT32;

typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t requiredSubgroupSize;
 } VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32;
 typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32;
@@ -1205,15 +1205,15 @@ typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderSt
 typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t identifierSize;
-    const uint8_t *pIdentifier;
+    PTR32 pIdentifier;
 } VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;

typedef struct VkPipelineRobustnessCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineRobustnessBufferBehaviorEXT storageBuffers;
     VkPipelineRobustnessBufferBehaviorEXT uniformBuffers;
     VkPipelineRobustnessBufferBehaviorEXT vertexInputs;
@@ -1223,28 +1223,28 @@ typedef struct VkPipelineRobustnessCreateInfoEXT32
 typedef struct VkPipelineShaderStageCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineShaderStageCreateFlags flags;
     VkShaderStageFlagBits stage;
     VkShaderModule DECLSPEC_ALIGN(8) module;
-    const char *pName;
-    const VkSpecializationInfo32 *pSpecializationInfo;
+    PTR32 pName;
+    PTR32 pSpecializationInfo;
 } VkPipelineShaderStageCreateInfo32;

typedef struct VkPipelineCreationFeedbackCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
-    VkPipelineCreationFeedback32 *pPipelineCreationFeedback;
+    PTR32 pNext;
+    PTR32 pPipelineCreationFeedback;
     uint32_t pipelineStageCreationFeedbackCount;
-    VkPipelineCreationFeedback32 *pPipelineStageCreationFeedbacks;
+    PTR32 pPipelineStageCreationFeedbacks;
 } VkPipelineCreationFeedbackCreateInfo32;
 typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;

typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
     uint32_t subpass;
 } VkSubpassShadingPipelineCreateInfoHUAWEI32;
@@ -1252,14 +1252,14 @@ typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32
 typedef struct VkPipelineCompilerControlCreateInfoAMD32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCompilerControlFlagsAMD compilerControlFlags;
 } VkPipelineCompilerControlCreateInfoAMD32;

typedef struct VkComputePipelineCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCreateFlags flags;
     VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage;
     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
@@ -1270,50 +1270,50 @@ typedef struct VkComputePipelineCreateInfo32
 typedef struct VkCuFunctionCreateInfoNVX32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCuModuleNVX DECLSPEC_ALIGN(8) module;
-    const char *pName;
+    PTR32 pName;
 } VkCuFunctionCreateInfoNVX32;

typedef struct VkCuModuleCreateInfoNVX32
 {
     VkStructureType sType;
-    const void *pNext;
-    size_t dataSize;
-    const void *pData;
+    PTR32 pNext;
+    PTR32 dataSize;
+    PTR32 pData;
 } VkCuModuleCreateInfoNVX32;

typedef struct VkDebugReportCallbackCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDebugReportFlagsEXT flags;
     PFN_vkDebugReportCallbackEXT pfnCallback;
-    void *pUserData;
+    PTR32 pUserData;
 } VkDebugReportCallbackCreateInfoEXT32;

typedef struct VkDebugUtilsMessengerCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDebugUtilsMessengerCreateFlagsEXT flags;
     VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;
     VkDebugUtilsMessageTypeFlagsEXT messageType;
     PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;
-    void *pUserData;
+    PTR32 pUserData;
 } VkDebugUtilsMessengerCreateInfoEXT32;

typedef struct VkMutableDescriptorTypeListEXT32
 {
     uint32_t descriptorTypeCount;
-    const VkDescriptorType *pDescriptorTypes;
+    PTR32 pDescriptorTypes;
 } VkMutableDescriptorTypeListEXT32;
 typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;

typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t maxInlineUniformBlockBindings;
 } VkDescriptorPoolInlineUniformBlockCreateInfo32;
 typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;
@@ -1321,20 +1321,20 @@ typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUni
 typedef struct VkMutableDescriptorTypeCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t mutableDescriptorTypeListCount;
-    const VkMutableDescriptorTypeListEXT32 *pMutableDescriptorTypeLists;
+    PTR32 pMutableDescriptorTypeLists;
 } VkMutableDescriptorTypeCreateInfoEXT32;
 typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;

typedef struct VkDescriptorPoolCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorPoolCreateFlags flags;
     uint32_t maxSets;
     uint32_t poolSizeCount;
-    const VkDescriptorPoolSize *pPoolSizes;
+    PTR32 pPoolSizes;
 } VkDescriptorPoolCreateInfo32;

typedef struct VkDescriptorSetLayoutBinding32
@@ -1343,25 +1343,25 @@ typedef struct VkDescriptorSetLayoutBinding32
     VkDescriptorType descriptorType;
     uint32_t descriptorCount;
     VkShaderStageFlags stageFlags;
-    const VkSampler *pImmutableSamplers;
+    PTR32 pImmutableSamplers;
 } VkDescriptorSetLayoutBinding32;

typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t bindingCount;
-    const VkDescriptorBindingFlags *pBindingFlags;
+    PTR32 pBindingFlags;
 } VkDescriptorSetLayoutBindingFlagsCreateInfo32;
 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo32 VkDescriptorSetLayoutBindingFlagsCreateInfoEXT32;

typedef struct VkDescriptorSetLayoutCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorSetLayoutCreateFlags flags;
     uint32_t bindingCount;
-    const VkDescriptorSetLayoutBinding32 *pBindings;
+    PTR32 pBindings;
 } VkDescriptorSetLayoutCreateInfo32;

typedef struct VkDescriptorUpdateTemplateEntry32
@@ -1370,18 +1370,18 @@ typedef struct VkDescriptorUpdateTemplateEntry32
     uint32_t dstArrayElement;
     uint32_t descriptorCount;
     VkDescriptorType descriptorType;
-    size_t offset;
-    size_t stride;
+    PTR32 offset;
+    PTR32 stride;
 } VkDescriptorUpdateTemplateEntry32;
 typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32;

typedef struct VkDescriptorUpdateTemplateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorUpdateTemplateCreateFlags flags;
     uint32_t descriptorUpdateEntryCount;
-    const VkDescriptorUpdateTemplateEntry32 *pDescriptorUpdateEntries;
+    PTR32 pDescriptorUpdateEntries;
     VkDescriptorUpdateTemplateType templateType;
     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
     VkPipelineBindPoint pipelineBindPoint;
@@ -1393,7 +1393,7 @@ typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateI
 typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkQueueGlobalPriorityKHR globalPriority;
 } VkDeviceQueueGlobalPriorityCreateInfoKHR32;
 typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;
@@ -1401,24 +1401,24 @@ typedef VkDeviceQueueGlobalPriorityCreateInfoKHR32 VkDeviceQueueGlobalPriorityCr
 typedef struct VkDeviceQueueCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceQueueCreateFlags flags;
     uint32_t queueFamilyIndex;
     uint32_t queueCount;
-    const float *pQueuePriorities;
+    PTR32 pQueuePriorities;
 } VkDeviceQueueCreateInfo32;

typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 deviceGeneratedCommands;
 } VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;

typedef struct VkDevicePrivateDataCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t privateDataSlotRequestCount;
 } VkDevicePrivateDataCreateInfo32;
 typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
@@ -1426,7 +1426,7 @@ typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;
 typedef struct VkPhysicalDevicePrivateDataFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 privateData;
 } VkPhysicalDevicePrivateDataFeatures32;
 typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;
@@ -1434,7 +1434,7 @@ typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeature
 typedef struct VkPhysicalDeviceFeatures232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPhysicalDeviceFeatures features;
 } VkPhysicalDeviceFeatures232;
 typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
@@ -1442,7 +1442,7 @@ typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;
 typedef struct VkPhysicalDeviceVariablePointersFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 variablePointersStorageBuffer;
     VkBool32 variablePointers;
 } VkPhysicalDeviceVariablePointersFeatures32;
@@ -1453,7 +1453,7 @@ typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePoint
 typedef struct VkPhysicalDeviceMultiviewFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 multiview;
     VkBool32 multiviewGeometryShader;
     VkBool32 multiviewTessellationShader;
@@ -1463,30 +1463,30 @@ typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR
 typedef struct VkDeviceGroupDeviceCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t physicalDeviceCount;
-    const VkPhysicalDevice *pPhysicalDevices;
+    PTR32 pPhysicalDevices;
 } VkDeviceGroupDeviceCreateInfo32;
 typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32;

typedef struct VkPhysicalDevicePresentIdFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 presentId;
 } VkPhysicalDevicePresentIdFeaturesKHR32;

typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 presentWait;
 } VkPhysicalDevicePresentWaitFeaturesKHR32;

typedef struct VkPhysicalDevice16BitStorageFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 storageBuffer16BitAccess;
     VkBool32 uniformAndStorageBuffer16BitAccess;
     VkBool32 storagePushConstant16;
@@ -1497,7 +1497,7 @@ typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeatu
 typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderSubgroupExtendedTypes;
 } VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32;
 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;
@@ -1505,7 +1505,7 @@ typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceSh
 typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 samplerYcbcrConversion;
 } VkPhysicalDeviceSamplerYcbcrConversionFeatures32;
 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;
@@ -1513,28 +1513,28 @@ typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSampler
 typedef struct VkPhysicalDeviceProtectedMemoryFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 protectedMemory;
 } VkPhysicalDeviceProtectedMemoryFeatures32;

typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 advancedBlendCoherentOperations;
 } VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;

typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 multiDraw;
 } VkPhysicalDeviceMultiDrawFeaturesEXT32;

typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 inlineUniformBlock;
     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
 } VkPhysicalDeviceInlineUniformBlockFeatures32;
@@ -1543,7 +1543,7 @@ typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUnifo
 typedef struct VkPhysicalDeviceMaintenance4Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 maintenance4;
 } VkPhysicalDeviceMaintenance4Features32;
 typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;
@@ -1551,7 +1551,7 @@ typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4Featu
 typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderDrawParameters;
 } VkPhysicalDeviceShaderDrawParametersFeatures32;
 typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;
@@ -1559,7 +1559,7 @@ typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDra
 typedef struct VkPhysicalDeviceShaderFloat16Int8Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderFloat16;
     VkBool32 shaderInt8;
 } VkPhysicalDeviceShaderFloat16Int8Features32;
@@ -1569,7 +1569,7 @@ typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8F
 typedef struct VkPhysicalDeviceHostQueryResetFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 hostQueryReset;
 } VkPhysicalDeviceHostQueryResetFeatures32;
 typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;
@@ -1577,7 +1577,7 @@ typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetF
 typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 globalPriorityQuery;
 } VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32;
 typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;
@@ -1585,7 +1585,7 @@ typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32 VkPhysicalDeviceGlobalP
 typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderInputAttachmentArrayDynamicIndexing;
     VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;
     VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;
@@ -1612,7 +1612,7 @@ typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorI
 typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 timelineSemaphore;
 } VkPhysicalDeviceTimelineSemaphoreFeatures32;
 typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;
@@ -1620,7 +1620,7 @@ typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSema
 typedef struct VkPhysicalDevice8BitStorageFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 storageBuffer8BitAccess;
     VkBool32 uniformAndStorageBuffer8BitAccess;
     VkBool32 storagePushConstant8;
@@ -1630,7 +1630,7 @@ typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeature
 typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 conditionalRendering;
     VkBool32 inheritedConditionalRendering;
 } VkPhysicalDeviceConditionalRenderingFeaturesEXT32;
@@ -1638,7 +1638,7 @@ typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32
 typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 vulkanMemoryModel;
     VkBool32 vulkanMemoryModelDeviceScope;
     VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;
@@ -1648,7 +1648,7 @@ typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemory
 typedef struct VkPhysicalDeviceShaderAtomicInt64Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderBufferInt64Atomics;
     VkBool32 shaderSharedInt64Atomics;
 } VkPhysicalDeviceShaderAtomicInt64Features32;
@@ -1657,7 +1657,7 @@ typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomic
 typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderBufferFloat32Atomics;
     VkBool32 shaderBufferFloat32AtomicAdd;
     VkBool32 shaderBufferFloat64Atomics;
@@ -1675,7 +1675,7 @@ typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32
 typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderBufferFloat16Atomics;
     VkBool32 shaderBufferFloat16AtomicAdd;
     VkBool32 shaderBufferFloat16AtomicMinMax;
@@ -1693,7 +1693,7 @@ typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32
 typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 vertexAttributeInstanceRateDivisor;
     VkBool32 vertexAttributeInstanceRateZeroDivisor;
 } VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;
@@ -1701,14 +1701,14 @@ typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32
 typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 decodeModeSharedExponent;
 } VkPhysicalDeviceASTCDecodeFeaturesEXT32;

typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 transformFeedback;
     VkBool32 geometryStreams;
 } VkPhysicalDeviceTransformFeedbackFeaturesEXT32;
@@ -1716,28 +1716,28 @@ typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32
 typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 representativeFragmentTest;
 } VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;

typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 exclusiveScissor;
 } VkPhysicalDeviceExclusiveScissorFeaturesNV32;

typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 cornerSampledImage;
 } VkPhysicalDeviceCornerSampledImageFeaturesNV32;

typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 computeDerivativeGroupQuads;
     VkBool32 computeDerivativeGroupLinear;
 } VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;
@@ -1745,35 +1745,35 @@ typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32
 typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 imageFootprint;
 } VkPhysicalDeviceShaderImageFootprintFeaturesNV32;

typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 dedicatedAllocationImageAliasing;
 } VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;

typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 indirectCopy;
 } VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;

typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 memoryDecompression;
 } VkPhysicalDeviceMemoryDecompressionFeaturesNV32;

typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shadingRateImage;
     VkBool32 shadingRateCoarseSampleOrder;
 } VkPhysicalDeviceShadingRateImageFeaturesNV32;
@@ -1781,14 +1781,14 @@ typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32
 typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 invocationMask;
 } VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;

typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 taskShader;
     VkBool32 meshShader;
 } VkPhysicalDeviceMeshShaderFeaturesNV32;
@@ -1796,7 +1796,7 @@ typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32
 typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 taskShader;
     VkBool32 meshShader;
     VkBool32 multiviewMeshShader;
@@ -1807,7 +1807,7 @@ typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32
 typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 accelerationStructure;
     VkBool32 accelerationStructureCaptureReplay;
     VkBool32 accelerationStructureIndirectBuild;
@@ -1818,7 +1818,7 @@ typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32
 typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rayTracingPipeline;
     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;
     VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
@@ -1829,14 +1829,14 @@ typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32
 typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rayQuery;
 } VkPhysicalDeviceRayQueryFeaturesKHR32;

typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rayTracingMaintenance1;
     VkBool32 rayTracingPipelineTraceRaysIndirect2;
 } VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;
@@ -1844,14 +1844,14 @@ typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32
 typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMemoryOverallocationBehaviorAMD overallocationBehavior;
 } VkDeviceMemoryOverallocationCreateInfoAMD32;

typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentDensityMap;
     VkBool32 fragmentDensityMapDynamic;
     VkBool32 fragmentDensityMapNonSubsampledImages;
@@ -1860,21 +1860,21 @@ typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32
 typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentDensityMapDeferred;
 } VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;

typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentDensityMapOffset;
 } VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;

typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 scalarBlockLayout;
 } VkPhysicalDeviceScalarBlockLayoutFeatures32;
 typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;
@@ -1882,7 +1882,7 @@ typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockL
 typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 uniformBufferStandardLayout;
 } VkPhysicalDeviceUniformBufferStandardLayoutFeatures32;
 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;
@@ -1890,28 +1890,28 @@ typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUn
 typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 depthClipEnable;
 } VkPhysicalDeviceDepthClipEnableFeaturesEXT32;

typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 memoryPriority;
 } VkPhysicalDeviceMemoryPriorityFeaturesEXT32;

typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pageableDeviceLocalMemory;
 } VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;

typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 bufferDeviceAddress;
     VkBool32 bufferDeviceAddressCaptureReplay;
     VkBool32 bufferDeviceAddressMultiDevice;
@@ -1921,7 +1921,7 @@ typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDevi
 typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 bufferDeviceAddress;
     VkBool32 bufferDeviceAddressCaptureReplay;
     VkBool32 bufferDeviceAddressMultiDevice;
@@ -1931,7 +1931,7 @@ typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferA
 typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 imagelessFramebuffer;
 } VkPhysicalDeviceImagelessFramebufferFeatures32;
 typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;
@@ -1939,7 +1939,7 @@ typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImageless
 typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 textureCompressionASTC_HDR;
 } VkPhysicalDeviceTextureCompressionASTCHDRFeatures32;
 typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;
@@ -1947,7 +1947,7 @@ typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceText
 typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 cooperativeMatrix;
     VkBool32 cooperativeMatrixRobustBufferAccess;
 } VkPhysicalDeviceCooperativeMatrixFeaturesNV32;
@@ -1955,21 +1955,21 @@ typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32
 typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 ycbcrImageArrays;
 } VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;

typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 presentBarrier;
 } VkPhysicalDevicePresentBarrierFeaturesNV32;

typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 performanceCounterQueryPools;
     VkBool32 performanceCounterMultipleQueryPools;
 } VkPhysicalDevicePerformanceQueryFeaturesKHR32;
@@ -1977,21 +1977,21 @@ typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32
 typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 coverageReductionMode;
 } VkPhysicalDeviceCoverageReductionModeFeaturesNV32;

typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderIntegerFunctions2;
 } VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;

typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderSubgroupClock;
     VkBool32 shaderDeviceClock;
 } VkPhysicalDeviceShaderClockFeaturesKHR32;
@@ -1999,21 +1999,21 @@ typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32
 typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 indexTypeUint8;
 } VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;

typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderSMBuiltins;
 } VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;

typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentShaderSampleInterlock;
     VkBool32 fragmentShaderPixelInterlock;
     VkBool32 fragmentShaderShadingRateInterlock;
@@ -2022,7 +2022,7 @@ typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32
 typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 separateDepthStencilLayouts;
 } VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32;
 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;
@@ -2030,7 +2030,7 @@ typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSe
 typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 primitiveTopologyListRestart;
     VkBool32 primitiveTopologyPatchListRestart;
 } VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;
@@ -2038,14 +2038,14 @@ typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32
 typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelineExecutableInfo;
 } VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;

typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderDemoteToHelperInvocation;
 } VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32;
 typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;
@@ -2053,14 +2053,14 @@ typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDevic
 typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 texelBufferAlignment;
 } VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;

typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 subgroupSizeControl;
     VkBool32 computeFullSubgroups;
 } VkPhysicalDeviceSubgroupSizeControlFeatures32;
@@ -2069,7 +2069,7 @@ typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSi
 typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rectangularLines;
     VkBool32 bresenhamLines;
     VkBool32 smoothLines;
@@ -2081,7 +2081,7 @@ typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT32
 typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelineCreationCacheControl;
 } VkPhysicalDevicePipelineCreationCacheControlFeatures32;
 typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;
@@ -2089,7 +2089,7 @@ typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDeviceP
 typedef struct VkPhysicalDeviceVulkan11Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 storageBuffer16BitAccess;
     VkBool32 uniformAndStorageBuffer16BitAccess;
     VkBool32 storagePushConstant16;
@@ -2107,7 +2107,7 @@ typedef struct VkPhysicalDeviceVulkan11Features32
 typedef struct VkPhysicalDeviceVulkan12Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 samplerMirrorClampToEdge;
     VkBool32 drawIndirectCount;
     VkBool32 storageBuffer8BitAccess;
@@ -2160,7 +2160,7 @@ typedef struct VkPhysicalDeviceVulkan12Features32
 typedef struct VkPhysicalDeviceVulkan13Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 robustImageAccess;
     VkBool32 inlineUniformBlock;
     VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;
@@ -2181,14 +2181,14 @@ typedef struct VkPhysicalDeviceVulkan13Features32
 typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 deviceCoherentMemory;
 } VkPhysicalDeviceCoherentMemoryFeaturesAMD32;

typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 customBorderColors;
     VkBool32 customBorderColorWithoutFormat;
 } VkPhysicalDeviceCustomBorderColorFeaturesEXT32;
@@ -2196,7 +2196,7 @@ typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32
 typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 borderColorSwizzle;
     VkBool32 borderColorSwizzleFromImage;
 } VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;
@@ -2204,14 +2204,14 @@ typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32
 typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 extendedDynamicState;
 } VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;

typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 extendedDynamicState2;
     VkBool32 extendedDynamicState2LogicOp;
     VkBool32 extendedDynamicState2PatchControlPoints;
@@ -2220,7 +2220,7 @@ typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32
 typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 extendedDynamicState3TessellationDomainOrigin;
     VkBool32 extendedDynamicState3DepthClampEnable;
     VkBool32 extendedDynamicState3PolygonMode;
@@ -2257,21 +2257,21 @@ typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32
 typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 diagnosticsConfig;
 } VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;

typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceDiagnosticsConfigFlagsNV flags;
 } VkDeviceDiagnosticsConfigCreateInfoNV32;

typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderZeroInitializeWorkgroupMemory;
 } VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32;
 typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;
@@ -2279,14 +2279,14 @@ typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDevice
 typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderSubgroupUniformControlFlow;
 } VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;

typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 robustBufferAccess2;
     VkBool32 robustImageAccess2;
     VkBool32 nullDescriptor;
@@ -2295,7 +2295,7 @@ typedef struct VkPhysicalDeviceRobustness2FeaturesEXT32
 typedef struct VkPhysicalDeviceImageRobustnessFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 robustImageAccess;
 } VkPhysicalDeviceImageRobustnessFeatures32;
 typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;
@@ -2303,7 +2303,7 @@ typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnes
 typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 workgroupMemoryExplicitLayout;
     VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;
     VkBool32 workgroupMemoryExplicitLayout8BitAccess;
@@ -2313,7 +2313,7 @@ typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32
 typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 formatA4R4G4B4;
     VkBool32 formatA4B4G4R4;
 } VkPhysicalDevice4444FormatsFeaturesEXT32;
@@ -2321,14 +2321,14 @@ typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32
 typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 subpassShading;
 } VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;

typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderImageInt64Atomics;
     VkBool32 sparseImageInt64Atomics;
 } VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;
@@ -2336,7 +2336,7 @@ typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32
 typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelineFragmentShadingRate;
     VkBool32 primitiveFragmentShadingRate;
     VkBool32 attachmentFragmentShadingRate;
@@ -2345,7 +2345,7 @@ typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32
 typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderTerminateInvocation;
 } VkPhysicalDeviceShaderTerminateInvocationFeatures32;
 typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;
@@ -2353,7 +2353,7 @@ typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShad
 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentShadingRateEnums;
     VkBool32 supersampleFragmentShadingRates;
     VkBool32 noInvocationFragmentShadingRates;
@@ -2362,7 +2362,7 @@ typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32
 typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 image2DViewOf3D;
     VkBool32 sampler2DViewOf3D;
 } VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;
@@ -2370,7 +2370,7 @@ typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32
 typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 mutableDescriptorType;
 } VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32;
 typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;
@@ -2378,28 +2378,28 @@ typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutab
 typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 depthClipControl;
 } VkPhysicalDeviceDepthClipControlFeaturesEXT32;

typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 vertexInputDynamicState;
 } VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;

typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 colorWriteEnable;
 } VkPhysicalDeviceColorWriteEnableFeaturesEXT32;

typedef struct VkPhysicalDeviceSynchronization2Features32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 synchronization2;
 } VkPhysicalDeviceSynchronization2Features32;
 typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;
@@ -2407,7 +2407,7 @@ typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronizati
 typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 primitivesGeneratedQuery;
     VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;
     VkBool32 primitivesGeneratedQueryWithNonZeroStreams;
@@ -2416,42 +2416,42 @@ typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32
 typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 legacyDithering;
 } VkPhysicalDeviceLegacyDitheringFeaturesEXT32;

typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 multisampledRenderToSingleSampled;
 } VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;

typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelineProtectedAccess;
 } VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;

typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 inheritedViewportScissor2D;
 } VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;

typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 ycbcr2plane444Formats;
 } VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;

typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 provokingVertexLast;
     VkBool32 transformFeedbackPreservesProvokingVertex;
 } VkPhysicalDeviceProvokingVertexFeaturesEXT32;
@@ -2459,7 +2459,7 @@ typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32
 typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderIntegerDotProduct;
 } VkPhysicalDeviceShaderIntegerDotProductFeatures32;
 typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;
@@ -2467,7 +2467,7 @@ typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShader
 typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 fragmentShaderBarycentric;
 } VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32;
 typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;
@@ -2475,7 +2475,7 @@ typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceF
 typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rayTracingMotionBlur;
     VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;
 } VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;
@@ -2483,14 +2483,14 @@ typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32
 typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 formatRgba10x6WithoutYCbCrSampler;
 } VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;

typedef struct VkPhysicalDeviceDynamicRenderingFeatures32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 dynamicRendering;
 } VkPhysicalDeviceDynamicRenderingFeatures32;
 typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;
@@ -2498,14 +2498,14 @@ typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRender
 typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 minLod;
 } VkPhysicalDeviceImageViewMinLodFeaturesEXT32;

typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rasterizationOrderColorAttachmentAccess;
     VkBool32 rasterizationOrderDepthAttachmentAccess;
     VkBool32 rasterizationOrderStencilAttachmentAccess;
@@ -2515,56 +2515,56 @@ typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysic
 typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 linearColorAttachment;
 } VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;

typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 graphicsPipelineLibrary;
 } VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;

typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 descriptorSetHostMapping;
 } VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;

typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderModuleIdentifier;
 } VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;

typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 imageCompressionControl;
 } VkPhysicalDeviceImageCompressionControlFeaturesEXT32;

typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 imageCompressionControlSwapchain;
 } VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;

typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 subpassMergeFeedback;
 } VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;

typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 micromap;
     VkBool32 micromapCaptureReplay;
     VkBool32 micromapHostCommands;
@@ -2573,35 +2573,35 @@ typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32
 typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelinePropertiesIdentifier;
 } VkPhysicalDevicePipelinePropertiesFeaturesEXT32;

typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderEarlyAndLateFragmentTests;
 } VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;

typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 nonSeamlessCubeMap;
 } VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;

typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 pipelineRobustness;
 } VkPhysicalDevicePipelineRobustnessFeaturesEXT32;

typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 textureSampleWeighted;
     VkBool32 textureBoxFilter;
     VkBool32 textureBlockMatch;
@@ -2610,42 +2610,42 @@ typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32
 typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 tileProperties;
 } VkPhysicalDeviceTilePropertiesFeaturesQCOM32;

typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 attachmentFeedbackLoopLayout;
 } VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;

typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 depthClampZeroOne;
 } VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;

typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 reportAddressBinding;
 } VkPhysicalDeviceAddressBindingReportFeaturesEXT32;

typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 opticalFlow;
 } VkPhysicalDeviceOpticalFlowFeaturesNV32;

typedef struct VkPhysicalDeviceFaultFeaturesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 deviceFault;
     VkBool32 deviceFaultVendorBinary;
 } VkPhysicalDeviceFaultFeaturesEXT32;
@@ -2653,42 +2653,42 @@ typedef struct VkPhysicalDeviceFaultFeaturesEXT32
 typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 shaderCoreBuiltins;
 } VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;

typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 rayTracingInvocationReorder;
 } VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;

typedef struct VkDeviceCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceCreateFlags flags;
     uint32_t queueCreateInfoCount;
-    const VkDeviceQueueCreateInfo32 *pQueueCreateInfos;
+    PTR32 pQueueCreateInfos;
     uint32_t enabledLayerCount;
-    const char * const*ppEnabledLayerNames;
+    PTR32 ppEnabledLayerNames;
     uint32_t enabledExtensionCount;
-    const char * const*ppEnabledExtensionNames;
-    const VkPhysicalDeviceFeatures *pEnabledFeatures;
+    PTR32 ppEnabledExtensionNames;
+    PTR32 pEnabledFeatures;
 } VkDeviceCreateInfo32;

typedef struct VkEventCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkEventCreateFlags flags;
 } VkEventCreateInfo32;

typedef struct VkExportFenceCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalFenceHandleTypeFlags handleTypes;
 } VkExportFenceCreateInfo32;
 typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
@@ -2696,41 +2696,41 @@ typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;
 typedef struct VkFenceCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFenceCreateFlags flags;
 } VkFenceCreateInfo32;

typedef struct VkFramebufferAttachmentImageInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageCreateFlags flags;
     VkImageUsageFlags usage;
     uint32_t width;
     uint32_t height;
     uint32_t layerCount;
     uint32_t viewFormatCount;
-    const VkFormat *pViewFormats;
+    PTR32 pViewFormats;
 } VkFramebufferAttachmentImageInfo32;
 typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32;

typedef struct VkFramebufferAttachmentsCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t attachmentImageInfoCount;
-    const VkFramebufferAttachmentImageInfo32 *pAttachmentImageInfos;
+    PTR32 pAttachmentImageInfos;
 } VkFramebufferAttachmentsCreateInfo32;
 typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;

typedef struct VkFramebufferCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFramebufferCreateFlags flags;
     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
     uint32_t attachmentCount;
-    const VkImageView *pAttachments;
+    PTR32 pAttachments;
     uint32_t width;
     uint32_t height;
     uint32_t layers;
@@ -2739,26 +2739,26 @@ typedef struct VkFramebufferCreateInfo32
 typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t vertexBindingDivisorCount;
-    const VkVertexInputBindingDivisorDescriptionEXT *pVertexBindingDivisors;
+    PTR32 pVertexBindingDivisors;
 } VkPipelineVertexInputDivisorStateCreateInfoEXT32;

typedef struct VkPipelineVertexInputStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineVertexInputStateCreateFlags flags;
     uint32_t vertexBindingDescriptionCount;
-    const VkVertexInputBindingDescription *pVertexBindingDescriptions;
+    PTR32 pVertexBindingDescriptions;
     uint32_t vertexAttributeDescriptionCount;
-    const VkVertexInputAttributeDescription *pVertexAttributeDescriptions;
+    PTR32 pVertexAttributeDescriptions;
 } VkPipelineVertexInputStateCreateInfo32;

typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkTessellationDomainOrigin domainOrigin;
 } VkPipelineTessellationDomainOriginStateCreateInfo32;
 typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;
@@ -2766,7 +2766,7 @@ typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellati
 typedef struct VkPipelineTessellationStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineTessellationStateCreateFlags flags;
     uint32_t patchControlPoints;
 } VkPipelineTessellationStateCreateInfo32;
@@ -2774,17 +2774,17 @@ typedef struct VkPipelineTessellationStateCreateInfo32
 typedef struct VkGraphicsShaderGroupCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t stageCount;
-    const VkPipelineShaderStageCreateInfo32 *pStages;
-    const VkPipelineVertexInputStateCreateInfo32 *pVertexInputState;
-    const VkPipelineTessellationStateCreateInfo32 *pTessellationState;
+    PTR32 pStages;
+    PTR32 pVertexInputState;
+    PTR32 pTessellationState;
 } VkGraphicsShaderGroupCreateInfoNV32;

typedef struct VkPipelineInputAssemblyStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineInputAssemblyStateCreateFlags flags;
     VkPrimitiveTopology topology;
     VkBool32 primitiveRestartEnable;
@@ -2793,76 +2793,76 @@ typedef struct VkPipelineInputAssemblyStateCreateInfo32
 typedef struct VkPipelineViewportWScalingStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 viewportWScalingEnable;
     uint32_t viewportCount;
-    const VkViewportWScalingNV *pViewportWScalings;
+    PTR32 pViewportWScalings;
 } VkPipelineViewportWScalingStateCreateInfoNV32;

typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineViewportSwizzleStateCreateFlagsNV flags;
     uint32_t viewportCount;
-    const VkViewportSwizzleNV *pViewportSwizzles;
+    PTR32 pViewportSwizzles;
 } VkPipelineViewportSwizzleStateCreateInfoNV32;

typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t exclusiveScissorCount;
-    const VkRect2D *pExclusiveScissors;
+    PTR32 pExclusiveScissors;
 } VkPipelineViewportExclusiveScissorStateCreateInfoNV32;

typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 shadingRateImageEnable;
     uint32_t viewportCount;
-    const VkShadingRatePaletteNV32 *pShadingRatePalettes;
+    PTR32 pShadingRatePalettes;
 } VkPipelineViewportShadingRateImageStateCreateInfoNV32;

typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkCoarseSampleOrderTypeNV sampleOrderType;
     uint32_t customSampleOrderCount;
-    const VkCoarseSampleOrderCustomNV32 *pCustomSampleOrders;
+    PTR32 pCustomSampleOrders;
 } VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;

typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 negativeOneToOne;
 } VkPipelineViewportDepthClipControlCreateInfoEXT32;

typedef struct VkPipelineViewportStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineViewportStateCreateFlags flags;
     uint32_t viewportCount;
-    const VkViewport *pViewports;
+    PTR32 pViewports;
     uint32_t scissorCount;
-    const VkRect2D *pScissors;
+    PTR32 pScissors;
 } VkPipelineViewportStateCreateInfo32;

typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRasterizationOrderAMD rasterizationOrder;
 } VkPipelineRasterizationStateRasterizationOrderAMD32;

typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;
     VkConservativeRasterizationModeEXT conservativeRasterizationMode;
     float extraPrimitiveOverestimationSize;
@@ -2871,7 +2871,7 @@ typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32
 typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineRasterizationStateStreamCreateFlagsEXT flags;
     uint32_t rasterizationStream;
 } VkPipelineRasterizationStateStreamCreateInfoEXT32;
@@ -2879,7 +2879,7 @@ typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32
 typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;
     VkBool32 depthClipEnable;
 } VkPipelineRasterizationDepthClipStateCreateInfoEXT32;
@@ -2887,7 +2887,7 @@ typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32
 typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkLineRasterizationModeEXT lineRasterizationMode;
     VkBool32 stippledLineEnable;
     uint32_t lineStippleFactor;
@@ -2897,14 +2897,14 @@ typedef struct VkPipelineRasterizationLineStateCreateInfoEXT32
 typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkProvokingVertexModeEXT provokingVertexMode;
 } VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;

typedef struct VkPipelineRasterizationStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineRasterizationStateCreateFlags flags;
     VkBool32 depthClampEnable;
     VkBool32 rasterizerDiscardEnable;
@@ -2921,7 +2921,7 @@ typedef struct VkPipelineRasterizationStateCreateInfo32
 typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCoverageToColorStateCreateFlagsNV flags;
     VkBool32 coverageToColorEnable;
     uint32_t coverageToColorLocation;
@@ -2930,7 +2930,7 @@ typedef struct VkPipelineCoverageToColorStateCreateInfoNV32
 typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 sampleLocationsEnable;
     VkSampleLocationsInfoEXT32 sampleLocationsInfo;
 } VkPipelineSampleLocationsStateCreateInfoEXT32;
@@ -2938,18 +2938,18 @@ typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32
 typedef struct VkPipelineCoverageModulationStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCoverageModulationStateCreateFlagsNV flags;
     VkCoverageModulationModeNV coverageModulationMode;
     VkBool32 coverageModulationTableEnable;
     uint32_t coverageModulationTableCount;
-    const float *pCoverageModulationTable;
+    PTR32 pCoverageModulationTable;
 } VkPipelineCoverageModulationStateCreateInfoNV32;

typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCoverageReductionStateCreateFlagsNV flags;
     VkCoverageReductionModeNV coverageReductionMode;
 } VkPipelineCoverageReductionStateCreateInfoNV32;
@@ -2957,12 +2957,12 @@ typedef struct VkPipelineCoverageReductionStateCreateInfoNV32
 typedef struct VkPipelineMultisampleStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineMultisampleStateCreateFlags flags;
     VkSampleCountFlagBits rasterizationSamples;
     VkBool32 sampleShadingEnable;
     float minSampleShading;
-    const VkSampleMask *pSampleMask;
+    PTR32 pSampleMask;
     VkBool32 alphaToCoverageEnable;
     VkBool32 alphaToOneEnable;
 } VkPipelineMultisampleStateCreateInfo32;
@@ -2970,7 +2970,7 @@ typedef struct VkPipelineMultisampleStateCreateInfo32
 typedef struct VkPipelineDepthStencilStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineDepthStencilStateCreateFlags flags;
     VkBool32 depthTestEnable;
     VkBool32 depthWriteEnable;
@@ -2986,7 +2986,7 @@ typedef struct VkPipelineDepthStencilStateCreateInfo32
 typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 srcPremultiplied;
     VkBool32 dstPremultiplied;
     VkBlendOverlapEXT blendOverlap;
@@ -2995,71 +2995,71 @@ typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32
 typedef struct VkPipelineColorWriteCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t attachmentCount;
-    const VkBool32 *pColorWriteEnables;
+    PTR32 pColorWriteEnables;
 } VkPipelineColorWriteCreateInfoEXT32;

typedef struct VkPipelineColorBlendStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineColorBlendStateCreateFlags flags;
     VkBool32 logicOpEnable;
     VkLogicOp logicOp;
     uint32_t attachmentCount;
-    const VkPipelineColorBlendAttachmentState *pAttachments;
+    PTR32 pAttachments;
     float blendConstants[4];
 } VkPipelineColorBlendStateCreateInfo32;

typedef struct VkPipelineDynamicStateCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineDynamicStateCreateFlags flags;
     uint32_t dynamicStateCount;
-    const VkDynamicState *pDynamicStates;
+    PTR32 pDynamicStates;
 } VkPipelineDynamicStateCreateInfo32;

typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t groupCount;
-    const VkGraphicsShaderGroupCreateInfoNV32 *pGroups;
+    PTR32 pGroups;
     uint32_t pipelineCount;
-    const VkPipeline *pPipelines;
+    PTR32 pPipelines;
 } VkGraphicsPipelineShaderGroupsCreateInfoNV32;

typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineDiscardRectangleStateCreateFlagsEXT flags;
     VkDiscardRectangleModeEXT discardRectangleMode;
     uint32_t discardRectangleCount;
-    const VkRect2D *pDiscardRectangles;
+    PTR32 pDiscardRectangles;
 } VkPipelineDiscardRectangleStateCreateInfoEXT32;

typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 representativeFragmentTestEnable;
 } VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;

typedef struct VkPipelineLibraryCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t libraryCount;
-    const VkPipeline *pLibraries;
+    PTR32 pLibraries;
 } VkPipelineLibraryCreateInfoKHR32;

typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExtent2D fragmentSize;
     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
 } VkPipelineFragmentShadingRateStateCreateInfoKHR32;
@@ -3067,7 +3067,7 @@ typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32
 typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFragmentShadingRateTypeNV shadingRateType;
     VkFragmentShadingRateNV shadingRate;
     VkFragmentShadingRateCombinerOpKHR combinerOps[2];
@@ -3076,10 +3076,10 @@ typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32
 typedef struct VkPipelineRenderingCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t viewMask;
     uint32_t colorAttachmentCount;
-    const VkFormat *pColorAttachmentFormats;
+    PTR32 pColorAttachmentFormats;
     VkFormat depthAttachmentFormat;
     VkFormat stencilAttachmentFormat;
 } VkPipelineRenderingCreateInfo32;
@@ -3088,26 +3088,26 @@ typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;
 typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkGraphicsPipelineLibraryFlagsEXT flags;
 } VkGraphicsPipelineLibraryCreateInfoEXT32;

typedef struct VkGraphicsPipelineCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCreateFlags flags;
     uint32_t stageCount;
-    const VkPipelineShaderStageCreateInfo32 *pStages;
-    const VkPipelineVertexInputStateCreateInfo32 *pVertexInputState;
-    const VkPipelineInputAssemblyStateCreateInfo32 *pInputAssemblyState;
-    const VkPipelineTessellationStateCreateInfo32 *pTessellationState;
-    const VkPipelineViewportStateCreateInfo32 *pViewportState;
-    const VkPipelineRasterizationStateCreateInfo32 *pRasterizationState;
-    const VkPipelineMultisampleStateCreateInfo32 *pMultisampleState;
-    const VkPipelineDepthStencilStateCreateInfo32 *pDepthStencilState;
-    const VkPipelineColorBlendStateCreateInfo32 *pColorBlendState;
-    const VkPipelineDynamicStateCreateInfo32 *pDynamicState;
+    PTR32 pStages;
+    PTR32 pVertexInputState;
+    PTR32 pInputAssemblyState;
+    PTR32 pTessellationState;
+    PTR32 pViewportState;
+    PTR32 pRasterizationState;
+    PTR32 pMultisampleState;
+    PTR32 pDepthStencilState;
+    PTR32 pColorBlendState;
+    PTR32 pDynamicState;
     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
     VkRenderPass DECLSPEC_ALIGN(8) renderPass;
     uint32_t subpass;
@@ -3118,14 +3118,14 @@ typedef struct VkGraphicsPipelineCreateInfo32
 typedef struct VkDedicatedAllocationImageCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 dedicatedAllocation;
 } VkDedicatedAllocationImageCreateInfoNV32;

typedef struct VkExternalMemoryImageCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlags handleTypes;
 } VkExternalMemoryImageCreateInfo32;
 typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
@@ -3133,23 +3133,23 @@ typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;
 typedef struct VkImageSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
 } VkImageSwapchainCreateInfoKHR32;

typedef struct VkImageFormatListCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t viewFormatCount;
-    const VkFormat *pViewFormats;
+    PTR32 pViewFormats;
 } VkImageFormatListCreateInfo32;
 typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;

typedef struct VkImageStencilUsageCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageUsageFlags stencilUsage;
 } VkImageStencilUsageCreateInfo32;
 typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
@@ -3157,23 +3157,23 @@ typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;
 typedef struct VkImageCompressionControlEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageCompressionFlagsEXT flags;
     uint32_t compressionControlPlaneCount;
-    VkImageCompressionFixedRateFlagsEXT *pFixedRateFlags;
+    PTR32 pFixedRateFlags;
 } VkImageCompressionControlEXT32;

typedef struct VkOpticalFlowImageFormatInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkOpticalFlowUsageFlagsNV usage;
 } VkOpticalFlowImageFormatInfoNV32;

typedef struct VkImageCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageCreateFlags flags;
     VkImageType imageType;
     VkFormat format;
@@ -3185,14 +3185,14 @@ typedef struct VkImageCreateInfo32
     VkImageUsageFlags usage;
     VkSharingMode sharingMode;
     uint32_t queueFamilyIndexCount;
-    const uint32_t *pQueueFamilyIndices;
+    PTR32 pQueueFamilyIndices;
     VkImageLayout initialLayout;
 } VkImageCreateInfo32;

typedef struct VkImageViewUsageCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageUsageFlags usage;
 } VkImageViewUsageCreateInfo32;
 typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
@@ -3200,7 +3200,7 @@ typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;
 typedef struct VkSamplerYcbcrConversionInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion;
 } VkSamplerYcbcrConversionInfo32;
 typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
@@ -3208,21 +3208,21 @@ typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;
 typedef struct VkImageViewASTCDecodeModeEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFormat decodeMode;
 } VkImageViewASTCDecodeModeEXT32;

typedef struct VkImageViewMinLodCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     float minLod;
 } VkImageViewMinLodCreateInfoEXT32;

typedef struct VkImageViewSampleWeightCreateInfoQCOM32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkOffset2D filterCenter;
     VkExtent2D filterSize;
     uint32_t numPhases;
@@ -3231,7 +3231,7 @@ typedef struct VkImageViewSampleWeightCreateInfoQCOM32
 typedef struct VkImageViewCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageViewCreateFlags flags;
     VkImage DECLSPEC_ALIGN(8) image;
     VkImageViewType viewType;
@@ -3243,7 +3243,7 @@ typedef struct VkImageViewCreateInfo32
 typedef struct VkIndirectCommandsLayoutTokenNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkIndirectCommandsTokenTypeNV tokenType;
     uint32_t stream;
     uint32_t offset;
@@ -3255,29 +3255,29 @@ typedef struct VkIndirectCommandsLayoutTokenNV32
     uint32_t pushconstantSize;
     VkIndirectStateFlagsNV indirectStateFlags;
     uint32_t indexTypeCount;
-    const VkIndexType *pIndexTypes;
-    const uint32_t *pIndexTypeValues;
+    PTR32 pIndexTypes;
+    PTR32 pIndexTypeValues;
 } VkIndirectCommandsLayoutTokenNV32;

typedef struct VkIndirectCommandsLayoutCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkIndirectCommandsLayoutUsageFlagsNV flags;
     VkPipelineBindPoint pipelineBindPoint;
     uint32_t tokenCount;
-    const VkIndirectCommandsLayoutTokenNV32 *pTokens;
+    PTR32 pTokens;
     uint32_t streamCount;
-    const uint32_t *pStreamStrides;
+    PTR32 pStreamStrides;
 } VkIndirectCommandsLayoutCreateInfoNV32;

typedef struct VkApplicationInfo32
 {
     VkStructureType sType;
-    const void *pNext;
-    const char *pApplicationName;
+    PTR32 pNext;
+    PTR32 pApplicationName;
     uint32_t applicationVersion;
-    const char *pEngineName;
+    PTR32 pEngineName;
     uint32_t engineVersion;
     uint32_t apiVersion;
 } VkApplicationInfo32;
@@ -3285,37 +3285,37 @@ typedef struct VkApplicationInfo32
 typedef struct VkValidationFlagsEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t disabledValidationCheckCount;
-    const VkValidationCheckEXT *pDisabledValidationChecks;
+    PTR32 pDisabledValidationChecks;
 } VkValidationFlagsEXT32;

typedef struct VkValidationFeaturesEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t enabledValidationFeatureCount;
-    const VkValidationFeatureEnableEXT *pEnabledValidationFeatures;
+    PTR32 pEnabledValidationFeatures;
     uint32_t disabledValidationFeatureCount;
-    const VkValidationFeatureDisableEXT *pDisabledValidationFeatures;
+    PTR32 pDisabledValidationFeatures;
 } VkValidationFeaturesEXT32;

typedef struct VkInstanceCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkInstanceCreateFlags flags;
-    const VkApplicationInfo32 *pApplicationInfo;
+    PTR32 pApplicationInfo;
     uint32_t enabledLayerCount;
-    const char * const*ppEnabledLayerNames;
+    PTR32 ppEnabledLayerNames;
     uint32_t enabledExtensionCount;
-    const char * const*ppEnabledExtensionNames;
+    PTR32 ppEnabledExtensionNames;
 } VkInstanceCreateInfo32;

typedef struct VkMicromapCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkMicromapCreateFlagsEXT createFlags;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     VkDeviceSize DECLSPEC_ALIGN(8) offset;
@@ -3327,16 +3327,16 @@ typedef struct VkMicromapCreateInfoEXT32
 typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t id;
     uint32_t size;
-    const void *pPrivateData;
+    PTR32 pPrivateData;
 } VkOpticalFlowSessionCreatePrivateDataInfoNV32;

typedef struct VkOpticalFlowSessionCreateInfoNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t width;
     uint32_t height;
     VkFormat imageFormat;
@@ -3351,27 +3351,27 @@ typedef struct VkOpticalFlowSessionCreateInfoNV32
 typedef struct VkPipelineCacheCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCacheCreateFlags flags;
-    size_t initialDataSize;
-    const void *pInitialData;
+    PTR32 initialDataSize;
+    PTR32 pInitialData;
 } VkPipelineCacheCreateInfo32;

typedef struct VkPipelineLayoutCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineLayoutCreateFlags flags;
     uint32_t setLayoutCount;
-    const VkDescriptorSetLayout *pSetLayouts;
+    PTR32 pSetLayouts;
     uint32_t pushConstantRangeCount;
-    const VkPushConstantRange *pPushConstantRanges;
+    PTR32 pPushConstantRanges;
 } VkPipelineLayoutCreateInfo32;

typedef struct VkPrivateDataSlotCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPrivateDataSlotCreateFlags flags;
 } VkPrivateDataSlotCreateInfo32;
 typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
@@ -3379,16 +3379,16 @@ typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;
 typedef struct VkQueryPoolPerformanceCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t queueFamilyIndex;
     uint32_t counterIndexCount;
-    const uint32_t *pCounterIndices;
+    PTR32 pCounterIndices;
 } VkQueryPoolPerformanceCreateInfoKHR32;

typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkQueryPoolSamplingModeINTEL performanceCountersSampling;
 } VkQueryPoolPerformanceQueryCreateInfoINTEL32;
 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;
@@ -3396,7 +3396,7 @@ typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL3
 typedef struct VkQueryPoolCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkQueryPoolCreateFlags flags;
     VkQueryType queryType;
     uint32_t queryCount;
@@ -3406,19 +3406,19 @@ typedef struct VkQueryPoolCreateInfo32
 typedef struct VkRayTracingShaderGroupCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRayTracingShaderGroupTypeKHR type;
     uint32_t generalShader;
     uint32_t closestHitShader;
     uint32_t anyHitShader;
     uint32_t intersectionShader;
-    const void *pShaderGroupCaptureReplayHandle;
+    PTR32 pShaderGroupCaptureReplayHandle;
 } VkRayTracingShaderGroupCreateInfoKHR32;

typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t maxPipelineRayPayloadSize;
     uint32_t maxPipelineRayHitAttributeSize;
 } VkRayTracingPipelineInterfaceCreateInfoKHR32;
@@ -3426,16 +3426,16 @@ typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32
 typedef struct VkRayTracingPipelineCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCreateFlags flags;
     uint32_t stageCount;
-    const VkPipelineShaderStageCreateInfo32 *pStages;
+    PTR32 pStages;
     uint32_t groupCount;
-    const VkRayTracingShaderGroupCreateInfoKHR32 *pGroups;
+    PTR32 pGroups;
     uint32_t maxPipelineRayRecursionDepth;
-    const VkPipelineLibraryCreateInfoKHR32 *pLibraryInfo;
-    const VkRayTracingPipelineInterfaceCreateInfoKHR32 *pLibraryInterface;
-    const VkPipelineDynamicStateCreateInfo32 *pDynamicState;
+    PTR32 pLibraryInfo;
+    PTR32 pLibraryInterface;
+    PTR32 pDynamicState;
     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
     int32_t basePipelineIndex;
@@ -3444,7 +3444,7 @@ typedef struct VkRayTracingPipelineCreateInfoKHR32
 typedef struct VkRayTracingShaderGroupCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRayTracingShaderGroupTypeKHR type;
     uint32_t generalShader;
     uint32_t closestHitShader;
@@ -3455,12 +3455,12 @@ typedef struct VkRayTracingShaderGroupCreateInfoNV32
 typedef struct VkRayTracingPipelineCreateInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineCreateFlags flags;
     uint32_t stageCount;
-    const VkPipelineShaderStageCreateInfo32 *pStages;
+    PTR32 pStages;
     uint32_t groupCount;
-    const VkRayTracingShaderGroupCreateInfoNV32 *pGroups;
+    PTR32 pGroups;
     uint32_t maxRecursionDepth;
     VkPipelineLayout DECLSPEC_ALIGN(8) layout;
     VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle;
@@ -3472,61 +3472,61 @@ typedef struct VkSubpassDescription32
     VkSubpassDescriptionFlags flags;
     VkPipelineBindPoint pipelineBindPoint;
     uint32_t inputAttachmentCount;
-    const VkAttachmentReference *pInputAttachments;
+    PTR32 pInputAttachments;
     uint32_t colorAttachmentCount;
-    const VkAttachmentReference *pColorAttachments;
-    const VkAttachmentReference *pResolveAttachments;
-    const VkAttachmentReference *pDepthStencilAttachment;
+    PTR32 pColorAttachments;
+    PTR32 pResolveAttachments;
+    PTR32 pDepthStencilAttachment;
     uint32_t preserveAttachmentCount;
-    const uint32_t *pPreserveAttachments;
+    PTR32 pPreserveAttachments;
 } VkSubpassDescription32;

typedef struct VkRenderPassMultiviewCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t subpassCount;
-    const uint32_t *pViewMasks;
+    PTR32 pViewMasks;
     uint32_t dependencyCount;
-    const int32_t *pViewOffsets;
+    PTR32 pViewOffsets;
     uint32_t correlationMaskCount;
-    const uint32_t *pCorrelationMasks;
+    PTR32 pCorrelationMasks;
 } VkRenderPassMultiviewCreateInfo32;
 typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;

typedef struct VkRenderPassInputAttachmentAspectCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t aspectReferenceCount;
-    const VkInputAttachmentAspectReference *pAspectReferences;
+    PTR32 pAspectReferences;
 } VkRenderPassInputAttachmentAspectCreateInfo32;
 typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;

typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAttachmentReference fragmentDensityMapAttachment;
 } VkRenderPassFragmentDensityMapCreateInfoEXT32;

typedef struct VkRenderPassCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderPassCreateFlags flags;
     uint32_t attachmentCount;
-    const VkAttachmentDescription *pAttachments;
+    PTR32 pAttachments;
     uint32_t subpassCount;
-    const VkSubpassDescription32 *pSubpasses;
+    PTR32 pSubpasses;
     uint32_t dependencyCount;
-    const VkSubpassDependency *pDependencies;
+    PTR32 pDependencies;
 } VkRenderPassCreateInfo32;

typedef struct VkAttachmentDescriptionStencilLayout32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageLayout stencilInitialLayout;
     VkImageLayout stencilFinalLayout;
 } VkAttachmentDescriptionStencilLayout32;
@@ -3535,7 +3535,7 @@ typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLay
 typedef struct VkAttachmentDescription232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAttachmentDescriptionFlags flags;
     VkFormat format;
     VkSampleCountFlagBits samples;
@@ -3551,7 +3551,7 @@ typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;
 typedef struct VkAttachmentReferenceStencilLayout32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageLayout stencilLayout;
 } VkAttachmentReferenceStencilLayout32;
 typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;
@@ -3559,7 +3559,7 @@ typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutK
 typedef struct VkAttachmentReference232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t attachment;
     VkImageLayout layout;
     VkImageAspectFlags aspectMask;
@@ -3569,57 +3569,57 @@ typedef VkAttachmentReference232 VkAttachmentReference2KHR32;
 typedef struct VkSubpassDescriptionDepthStencilResolve32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkResolveModeFlagBits depthResolveMode;
     VkResolveModeFlagBits stencilResolveMode;
-    const VkAttachmentReference232 *pDepthStencilResolveAttachment;
+    PTR32 pDepthStencilResolveAttachment;
 } VkSubpassDescriptionDepthStencilResolve32;
 typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;

typedef struct VkFragmentShadingRateAttachmentInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
-    const VkAttachmentReference232 *pFragmentShadingRateAttachment;
+    PTR32 pNext;
+    PTR32 pFragmentShadingRateAttachment;
     VkExtent2D shadingRateAttachmentTexelSize;
 } VkFragmentShadingRateAttachmentInfoKHR32;

typedef struct VkRenderPassCreationControlEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 disallowMerging;
 } VkRenderPassCreationControlEXT32;

typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
-    VkRenderPassSubpassFeedbackInfoEXT *pSubpassFeedback;
+    PTR32 pNext;
+    PTR32 pSubpassFeedback;
 } VkRenderPassSubpassFeedbackCreateInfoEXT32;

typedef struct VkSubpassDescription232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSubpassDescriptionFlags flags;
     VkPipelineBindPoint pipelineBindPoint;
     uint32_t viewMask;
     uint32_t inputAttachmentCount;
-    const VkAttachmentReference232 *pInputAttachments;
+    PTR32 pInputAttachments;
     uint32_t colorAttachmentCount;
-    const VkAttachmentReference232 *pColorAttachments;
-    const VkAttachmentReference232 *pResolveAttachments;
-    const VkAttachmentReference232 *pDepthStencilAttachment;
+    PTR32 pColorAttachments;
+    PTR32 pResolveAttachments;
+    PTR32 pDepthStencilAttachment;
     uint32_t preserveAttachmentCount;
-    const uint32_t *pPreserveAttachments;
+    PTR32 pPreserveAttachments;
 } VkSubpassDescription232;
 typedef VkSubpassDescription232 VkSubpassDescription2KHR32;

typedef struct VkSubpassDependency232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t srcSubpass;
     uint32_t dstSubpass;
     VkPipelineStageFlags srcStageMask;
@@ -3634,30 +3634,30 @@ typedef VkSubpassDependency232 VkSubpassDependency2KHR32;
 typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
-    VkRenderPassCreationFeedbackInfoEXT *pRenderPassFeedback;
+    PTR32 pNext;
+    PTR32 pRenderPassFeedback;
 } VkRenderPassCreationFeedbackCreateInfoEXT32;

typedef struct VkRenderPassCreateInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkRenderPassCreateFlags flags;
     uint32_t attachmentCount;
-    const VkAttachmentDescription232 *pAttachments;
+    PTR32 pAttachments;
     uint32_t subpassCount;
-    const VkSubpassDescription232 *pSubpasses;
+    PTR32 pSubpasses;
     uint32_t dependencyCount;
-    const VkSubpassDependency232 *pDependencies;
+    PTR32 pDependencies;
     uint32_t correlatedViewMaskCount;
-    const uint32_t *pCorrelatedViewMasks;
+    PTR32 pCorrelatedViewMasks;
 } VkRenderPassCreateInfo232;
 typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;

typedef struct VkSamplerReductionModeCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSamplerReductionMode reductionMode;
 } VkSamplerReductionModeCreateInfo32;
 typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;
@@ -3665,7 +3665,7 @@ typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32
 typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkClearColorValue customBorderColor;
     VkFormat format;
 } VkSamplerCustomBorderColorCreateInfoEXT32;
@@ -3673,7 +3673,7 @@ typedef struct VkSamplerCustomBorderColorCreateInfoEXT32
 typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkComponentMapping components;
     VkBool32 srgb;
 } VkSamplerBorderColorComponentMappingCreateInfoEXT32;
@@ -3681,7 +3681,7 @@ typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32
 typedef struct VkSamplerCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSamplerCreateFlags flags;
     VkFilter magFilter;
     VkFilter minFilter;
@@ -3703,7 +3703,7 @@ typedef struct VkSamplerCreateInfo32
 typedef struct VkSamplerYcbcrConversionCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFormat format;
     VkSamplerYcbcrModelConversion ycbcrModel;
     VkSamplerYcbcrRange ycbcrRange;
@@ -3718,7 +3718,7 @@ typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoK
 typedef struct VkExportSemaphoreCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalSemaphoreHandleTypeFlags handleTypes;
 } VkExportSemaphoreCreateInfo32;
 typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
@@ -3726,7 +3726,7 @@ typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;
 typedef struct VkSemaphoreTypeCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSemaphoreType semaphoreType;
     uint64_t DECLSPEC_ALIGN(8) initialValue;
 } VkSemaphoreTypeCreateInfo32;
@@ -3735,28 +3735,28 @@ typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;
 typedef struct VkSemaphoreCreateInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSemaphoreCreateFlags flags;
 } VkSemaphoreCreateInfo32;

typedef struct VkDeviceGroupSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceGroupPresentModeFlagsKHR modes;
 } VkDeviceGroupSwapchainCreateInfoKHR32;

typedef struct VkSwapchainPresentBarrierCreateInfoNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 presentBarrierEnable;
 } VkSwapchainPresentBarrierCreateInfoNV32;

typedef struct VkSwapchainCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSwapchainCreateFlagsKHR flags;
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
     uint32_t minImageCount;
@@ -3767,7 +3767,7 @@ typedef struct VkSwapchainCreateInfoKHR32
     VkImageUsageFlags imageUsage;
     VkSharingMode imageSharingMode;
     uint32_t queueFamilyIndexCount;
-    const uint32_t *pQueueFamilyIndices;
+    PTR32 pQueueFamilyIndices;
     VkSurfaceTransformFlagBitsKHR preTransform;
     VkCompositeAlphaFlagBitsKHR compositeAlpha;
     VkPresentModeKHR presentMode;
@@ -3778,47 +3778,47 @@ typedef struct VkSwapchainCreateInfoKHR32
 typedef struct VkValidationCacheCreateInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkValidationCacheCreateFlagsEXT flags;
-    size_t initialDataSize;
-    const void *pInitialData;
+    PTR32 initialDataSize;
+    PTR32 pInitialData;
 } VkValidationCacheCreateInfoEXT32;

typedef struct VkWin32SurfaceCreateInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkWin32SurfaceCreateFlagsKHR flags;
-    HINSTANCE hinstance;
-    HWND hwnd;
+    PTR32 hinstance;
+    PTR32 hwnd;
 } VkWin32SurfaceCreateInfoKHR32;

typedef struct VkDebugMarkerObjectNameInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDebugReportObjectTypeEXT objectType;
     uint64_t DECLSPEC_ALIGN(8) object;
-    const char *pObjectName;
+    PTR32 pObjectName;
 } VkDebugMarkerObjectNameInfoEXT32;

typedef struct VkDebugMarkerObjectTagInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDebugReportObjectTypeEXT objectType;
     uint64_t DECLSPEC_ALIGN(8) object;
     uint64_t DECLSPEC_ALIGN(8) tagName;
-    size_t tagSize;
-    const void *pTag;
+    PTR32 tagSize;
+    PTR32 pTag;
 } VkDebugMarkerObjectTagInfoEXT32;

typedef struct VkPhysicalDeviceGroupProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t physicalDeviceCount;
-    VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
+    PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
     VkBool32 subsetAllocation;
 } VkPhysicalDeviceGroupProperties32;
 typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
@@ -3826,7 +3826,7 @@ typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;
 typedef struct VkPerformanceCounterKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPerformanceCounterUnitKHR unit;
     VkPerformanceCounterScopeKHR scope;
     VkPerformanceCounterStorageKHR storage;
@@ -3836,7 +3836,7 @@ typedef struct VkPerformanceCounterKHR32
 typedef struct VkPerformanceCounterDescriptionKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPerformanceCounterDescriptionFlagsKHR flags;
     char name[VK_MAX_DESCRIPTION_SIZE];
     char category[VK_MAX_DESCRIPTION_SIZE];
@@ -3846,7 +3846,7 @@ typedef struct VkPerformanceCounterDescriptionKHR32
 typedef struct VkMappedMemoryRange32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     VkDeviceSize DECLSPEC_ALIGN(8) offset;
     VkDeviceSize DECLSPEC_ALIGN(8) size;
@@ -3855,7 +3855,7 @@ typedef struct VkMappedMemoryRange32
 typedef struct VkAccelerationStructureBuildSizesInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize;
     VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize;
     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
@@ -3864,14 +3864,14 @@ typedef struct VkAccelerationStructureBuildSizesInfoKHR32
 typedef struct VkAccelerationStructureDeviceAddressInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
 } VkAccelerationStructureDeviceAddressInfoKHR32;

typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkAccelerationStructureMemoryRequirementsTypeNV type;
     VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
 } VkAccelerationStructureMemoryRequirementsInfoNV32;
@@ -3887,7 +3887,7 @@ typedef struct VkMemoryRequirements32
 typedef struct VkBufferDeviceAddressInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
 } VkBufferDeviceAddressInfo32;
 typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32;
@@ -3896,7 +3896,7 @@ typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;
 typedef struct VkBufferMemoryRequirementsInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBuffer DECLSPEC_ALIGN(8) buffer;
 } VkBufferMemoryRequirementsInfo232;
 typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
@@ -3904,7 +3904,7 @@ typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;
 typedef struct VkMemoryDedicatedRequirements32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 prefersDedicatedAllocation;
     VkBool32 requiresDedicatedAllocation;
 } VkMemoryDedicatedRequirements32;
@@ -3913,7 +3913,7 @@ typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;
 typedef struct VkMemoryRequirements232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
 } VkMemoryRequirements232;
 typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
@@ -3921,14 +3921,14 @@ typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;
 typedef struct VkCalibratedTimestampInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkTimeDomainEXT timeDomain;
 } VkCalibratedTimestampInfoEXT32;

typedef struct VkDescriptorSetBindingReferenceVALVE32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
     uint32_t binding;
 } VkDescriptorSetBindingReferenceVALVE32;
@@ -3936,15 +3936,15 @@ typedef struct VkDescriptorSetBindingReferenceVALVE32
 typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32
 {
     VkStructureType sType;
-    void *pNext;
-    size_t descriptorOffset;
+    PTR32 pNext;
+    PTR32 descriptorOffset;
     uint32_t descriptorSize;
 } VkDescriptorSetLayoutHostMappingInfoVALVE32;

typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxVariableDescriptorCount;
 } VkDescriptorSetVariableDescriptorCountLayoutSupport32;
 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;
@@ -3952,7 +3952,7 @@ typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVar
 typedef struct VkDescriptorSetLayoutSupport32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 supported;
 } VkDescriptorSetLayoutSupport32;
 typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
@@ -3960,22 +3960,22 @@ typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32;
 typedef struct VkAccelerationStructureVersionInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
-    const uint8_t *pVersionData;
+    PTR32 pNext;
+    PTR32 pVersionData;
 } VkAccelerationStructureVersionInfoKHR32;

typedef struct VkDeviceBufferMemoryRequirements32
 {
     VkStructureType sType;
-    const void *pNext;
-    const VkBufferCreateInfo32 *pCreateInfo;
+    PTR32 pNext;
+    PTR32 pCreateInfo;
 } VkDeviceBufferMemoryRequirements32;
 typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32;

typedef struct VkDeviceFaultCountsEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t addressInfoCount;
     uint32_t vendorInfoCount;
     VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize;
@@ -3998,17 +3998,17 @@ typedef struct VkDeviceFaultVendorInfoEXT32
 typedef struct VkDeviceFaultInfoEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     char description[VK_MAX_DESCRIPTION_SIZE];
-    VkDeviceFaultAddressInfoEXT32 *pAddressInfos;
-    VkDeviceFaultVendorInfoEXT32 *pVendorInfos;
-    void *pVendorBinaryData;
+    PTR32 pAddressInfos;
+    PTR32 pVendorInfos;
+    PTR32 pVendorBinaryData;
 } VkDeviceFaultInfoEXT32;

typedef struct VkDeviceGroupPresentCapabilitiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];
     VkDeviceGroupPresentModeFlagsKHR modes;
 } VkDeviceGroupPresentCapabilitiesKHR32;
@@ -4016,8 +4016,8 @@ typedef struct VkDeviceGroupPresentCapabilitiesKHR32
 typedef struct VkDeviceImageMemoryRequirements32
 {
     VkStructureType sType;
-    const void *pNext;
-    const VkImageCreateInfo32 *pCreateInfo;
+    PTR32 pNext;
+    PTR32 pCreateInfo;
     VkImageAspectFlagBits planeAspect;
 } VkDeviceImageMemoryRequirements32;
 typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;
@@ -4034,7 +4034,7 @@ typedef struct VkSparseImageMemoryRequirements32
 typedef struct VkSparseImageMemoryRequirements232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements;
 } VkSparseImageMemoryRequirements232;
 typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;
@@ -4042,7 +4042,7 @@ typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32
 typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceMemory DECLSPEC_ALIGN(8) memory;
 } VkDeviceMemoryOpaqueCaptureAddressInfo32;
 typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;
@@ -4050,14 +4050,14 @@ typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddr
 typedef struct VkMicromapVersionInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
-    const uint8_t *pVersionData;
+    PTR32 pNext;
+    PTR32 pVersionData;
 } VkMicromapVersionInfoEXT32;

typedef struct VkDeviceQueueInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceQueueCreateFlags flags;
     uint32_t queueFamilyIndex;
     uint32_t queueIndex;
@@ -4066,7 +4066,7 @@ typedef struct VkDeviceQueueInfo232
 typedef struct VkTilePropertiesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent3D tileSize;
     VkExtent2D apronSize;
     VkOffset2D origin;
@@ -4075,7 +4075,7 @@ typedef struct VkTilePropertiesQCOM32
 typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipelineBindPoint pipelineBindPoint;
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
     VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
@@ -4085,7 +4085,7 @@ typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32
 typedef struct VkImagePlaneMemoryRequirementsInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageAspectFlagBits planeAspect;
 } VkImagePlaneMemoryRequirementsInfo32;
 typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;
@@ -4093,7 +4093,7 @@ typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoK
 typedef struct VkImageMemoryRequirementsInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) image;
 } VkImageMemoryRequirementsInfo232;
 typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
@@ -4101,7 +4101,7 @@ typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;
 typedef struct VkImageSparseMemoryRequirementsInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImage DECLSPEC_ALIGN(8) image;
 } VkImageSparseMemoryRequirementsInfo232;
 typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;
@@ -4118,14 +4118,14 @@ typedef struct VkSubresourceLayout32
 typedef struct VkImageSubresource2EXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageSubresource imageSubresource;
 } VkImageSubresource2EXT32;

typedef struct VkImageCompressionPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageCompressionFlagsEXT imageCompressionFlags;
     VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags;
 } VkImageCompressionPropertiesEXT32;
@@ -4133,14 +4133,14 @@ typedef struct VkImageCompressionPropertiesEXT32
 typedef struct VkSubresourceLayout2EXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout;
 } VkSubresourceLayout2EXT32;

typedef struct VkImageViewAddressPropertiesNVX32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress;
     VkDeviceSize DECLSPEC_ALIGN(8) size;
 } VkImageViewAddressPropertiesNVX32;
@@ -4148,7 +4148,7 @@ typedef struct VkImageViewAddressPropertiesNVX32
 typedef struct VkImageViewHandleInfoNVX32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkImageView DECLSPEC_ALIGN(8) imageView;
     VkDescriptorType descriptorType;
     VkSampler DECLSPEC_ALIGN(8) sampler;
@@ -4157,14 +4157,14 @@ typedef struct VkImageViewHandleInfoNVX32
 typedef struct VkMemoryHostPointerPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t memoryTypeBits;
 } VkMemoryHostPointerPropertiesEXT32;

typedef struct VkMicromapBuildSizesInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) micromapSize;
     VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize;
     VkBool32 discardable;
@@ -4179,7 +4179,7 @@ typedef struct VkPerformanceValueINTEL32
 typedef struct VkCooperativeMatrixPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t MSize;
     uint32_t NSize;
     uint32_t KSize;
@@ -4193,7 +4193,7 @@ typedef struct VkCooperativeMatrixPropertiesNV32
 typedef struct VkPhysicalDeviceExternalBufferInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBufferCreateFlags flags;
     VkBufferUsageFlags usage;
     VkExternalMemoryHandleTypeFlagBits handleType;
@@ -4203,7 +4203,7 @@ typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoK
 typedef struct VkExternalBufferProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExternalMemoryProperties externalMemoryProperties;
 } VkExternalBufferProperties32;
 typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
@@ -4211,7 +4211,7 @@ typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;
 typedef struct VkPhysicalDeviceExternalFenceInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalFenceHandleTypeFlagBits handleType;
 } VkPhysicalDeviceExternalFenceInfo32;
 typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;
@@ -4219,7 +4219,7 @@ typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR
 typedef struct VkExternalFenceProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;
     VkExternalFenceHandleTypeFlags compatibleHandleTypes;
     VkExternalFenceFeatureFlags externalFenceFeatures;
@@ -4229,7 +4229,7 @@ typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;
 typedef struct VkPhysicalDeviceExternalSemaphoreInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalSemaphoreHandleTypeFlagBits handleType;
 } VkPhysicalDeviceExternalSemaphoreInfo32;
 typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;
@@ -4237,7 +4237,7 @@ typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphor
 typedef struct VkExternalSemaphoreProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;
     VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
     VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
@@ -4247,14 +4247,14 @@ typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;
 typedef struct VkSubpassResolvePerformanceQueryEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 optimal;
 } VkSubpassResolvePerformanceQueryEXT32;

typedef struct VkFormatProperties332
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures;
     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures;
     VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures;
@@ -4264,7 +4264,7 @@ typedef VkFormatProperties332 VkFormatProperties3KHR32;
 typedef struct VkFormatProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkFormatProperties formatProperties;
 } VkFormatProperties232;
 typedef VkFormatProperties232 VkFormatProperties2KHR32;
@@ -4272,7 +4272,7 @@ typedef VkFormatProperties232 VkFormatProperties2KHR32;
 typedef struct VkPhysicalDeviceFragmentShadingRateKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSampleCountFlags sampleCounts;
     VkExtent2D fragmentSize;
 } VkPhysicalDeviceFragmentShadingRateKHR32;
@@ -4289,7 +4289,7 @@ typedef struct VkImageFormatProperties32
 typedef struct VkPhysicalDeviceExternalImageFormatInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkExternalMemoryHandleTypeFlagBits handleType;
 } VkPhysicalDeviceExternalImageFormatInfo32;
 typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;
@@ -4297,14 +4297,14 @@ typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageF
 typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageViewType imageViewType;
 } VkPhysicalDeviceImageViewImageFormatInfoEXT32;

typedef struct VkPhysicalDeviceImageFormatInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFormat format;
     VkImageType type;
     VkImageTiling tiling;
@@ -4316,7 +4316,7 @@ typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32
 typedef struct VkExternalImageFormatProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExternalMemoryProperties externalMemoryProperties;
 } VkExternalImageFormatProperties32;
 typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
@@ -4324,7 +4324,7 @@ typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;
 typedef struct VkSamplerYcbcrConversionImageFormatProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t combinedImageSamplerDescriptorCount;
 } VkSamplerYcbcrConversionImageFormatProperties32;
 typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;
@@ -4332,14 +4332,14 @@ typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversion
 typedef struct VkTextureLODGatherFormatPropertiesAMD32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 supportsTextureGatherLODBiasAMD;
 } VkTextureLODGatherFormatPropertiesAMD32;

typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 filterCubic;
     VkBool32 filterCubicMinmax;
 } VkFilterCubicImageViewImageFormatPropertiesEXT32;
@@ -4347,7 +4347,7 @@ typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32
 typedef struct VkImageFormatProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties;
 } VkImageFormatProperties232;
 typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;
@@ -4369,7 +4369,7 @@ typedef struct VkPhysicalDeviceMemoryProperties32
 typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS];
     VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS];
 } VkPhysicalDeviceMemoryBudgetPropertiesEXT32;
@@ -4377,7 +4377,7 @@ typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32
 typedef struct VkPhysicalDeviceMemoryProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties;
 } VkPhysicalDeviceMemoryProperties232;
 typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;
@@ -4385,14 +4385,14 @@ typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR
 typedef struct VkMultisamplePropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent2D maxSampleLocationGridSize;
 } VkMultisamplePropertiesEXT32;

typedef struct VkOpticalFlowImageFormatPropertiesNV32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFormat format;
 } VkOpticalFlowImageFormatPropertiesNV32;

@@ -4464,7 +4464,7 @@ typedef struct VkPhysicalDeviceLimits32
     uint32_t maxViewportDimensions[2];
     float viewportBoundsRange[2];
     uint32_t viewportSubPixelBits;
-    size_t minMemoryMapAlignment;
+    PTR32 minMemoryMapAlignment;
     VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment;
     VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment;
     VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment;
@@ -4522,7 +4522,7 @@ typedef struct VkPhysicalDeviceProperties32
 typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxGraphicsShaderGroupCount;
     uint32_t maxIndirectSequenceCount;
     uint32_t maxIndirectCommandsTokenCount;
@@ -4537,21 +4537,21 @@ typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32
 typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxMultiDrawCount;
 } VkPhysicalDeviceMultiDrawPropertiesEXT32;

typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxPushDescriptors;
 } VkPhysicalDevicePushDescriptorPropertiesKHR32;

typedef struct VkPhysicalDeviceDriverProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDriverId driverID;
     char driverName[VK_MAX_DRIVER_NAME_SIZE];
     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
@@ -4562,7 +4562,7 @@ typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32
 typedef struct VkPhysicalDeviceIDProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint8_t deviceUUID[VK_UUID_SIZE];
     uint8_t driverUUID[VK_UUID_SIZE];
     uint8_t deviceLUID[VK_LUID_SIZE];
@@ -4574,7 +4574,7 @@ typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;
 typedef struct VkPhysicalDeviceMultiviewProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxMultiviewViewCount;
     uint32_t maxMultiviewInstanceIndex;
 } VkPhysicalDeviceMultiviewProperties32;
@@ -4583,14 +4583,14 @@ typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertie
 typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxDiscardRectangles;
 } VkPhysicalDeviceDiscardRectanglePropertiesEXT32;

typedef struct VkPhysicalDeviceSubgroupProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t subgroupSize;
     VkShaderStageFlags supportedStages;
     VkSubgroupFeatureFlags supportedOperations;
@@ -4600,7 +4600,7 @@ typedef struct VkPhysicalDeviceSubgroupProperties32
 typedef struct VkPhysicalDevicePointClippingProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPointClippingBehavior pointClippingBehavior;
 } VkPhysicalDevicePointClippingProperties32;
 typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;
@@ -4608,14 +4608,14 @@ typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingP
 typedef struct VkPhysicalDeviceProtectedMemoryProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 protectedNoFault;
 } VkPhysicalDeviceProtectedMemoryProperties32;

typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 filterMinmaxSingleComponentFormats;
     VkBool32 filterMinmaxImageComponentMapping;
 } VkPhysicalDeviceSamplerFilterMinmaxProperties32;
@@ -4624,7 +4624,7 @@ typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerF
 typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSampleCountFlags sampleLocationSampleCounts;
     VkExtent2D maxSampleLocationGridSize;
     float sampleLocationCoordinateRange[2];
@@ -4635,7 +4635,7 @@ typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32
 typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t advancedBlendMaxColorAttachments;
     VkBool32 advancedBlendIndependentBlend;
     VkBool32 advancedBlendNonPremultipliedSrcColor;
@@ -4647,7 +4647,7 @@ typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32
 typedef struct VkPhysicalDeviceInlineUniformBlockProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxInlineUniformBlockSize;
     uint32_t maxPerStageDescriptorInlineUniformBlocks;
     uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
@@ -4659,7 +4659,7 @@ typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUni
 typedef struct VkPhysicalDeviceMaintenance3Properties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxPerSetDescriptors;
     VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize;
 } VkPhysicalDeviceMaintenance3Properties32;
@@ -4668,7 +4668,7 @@ typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3Pro
 typedef struct VkPhysicalDeviceMaintenance4Properties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize;
 } VkPhysicalDeviceMaintenance4Properties32;
 typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;
@@ -4676,7 +4676,7 @@ typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4Pro
 typedef struct VkPhysicalDeviceFloatControlsProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkShaderFloatControlsIndependence denormBehaviorIndependence;
     VkShaderFloatControlsIndependence roundingModeIndependence;
     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
@@ -4700,14 +4700,14 @@ typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsP
 typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment;
 } VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;

typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     float primitiveOverestimationSize;
     float maxExtraPrimitiveOverestimationSize;
     float extraPrimitiveOverestimationSizeGranularity;
@@ -4722,7 +4722,7 @@ typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32
 typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t shaderEngineCount;
     uint32_t shaderArraysPerEngineCount;
     uint32_t computeUnitsPerShaderArray;
@@ -4742,7 +4742,7 @@ typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32
 typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
     uint32_t activeComputeUnitCount;
 } VkPhysicalDeviceShaderCoreProperties2AMD32;
@@ -4750,7 +4750,7 @@ typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32
 typedef struct VkPhysicalDeviceDescriptorIndexingProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxUpdateAfterBindDescriptorsInAllPools;
     VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;
     VkBool32 shaderSampledImageArrayNonUniformIndexingNative;
@@ -4780,7 +4780,7 @@ typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescripto
 typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference;
 } VkPhysicalDeviceTimelineSemaphoreProperties32;
 typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;
@@ -4788,14 +4788,14 @@ typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSe
 typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxVertexAttribDivisor;
 } VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;

typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t pciDomain;
     uint32_t pciBus;
     uint32_t pciDevice;
@@ -4805,7 +4805,7 @@ typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32
 typedef struct VkPhysicalDeviceDepthStencilResolveProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkResolveModeFlags supportedDepthResolveModes;
     VkResolveModeFlags supportedStencilResolveModes;
     VkBool32 independentResolveNone;
@@ -4816,7 +4816,7 @@ typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthSte
 typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxTransformFeedbackStreams;
     uint32_t maxTransformFeedbackBuffers;
     VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize;
@@ -4832,14 +4832,14 @@ typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32
 typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkQueueFlags supportedQueues;
 } VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;

typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods;
     uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount;
 } VkPhysicalDeviceMemoryDecompressionPropertiesNV32;
@@ -4847,7 +4847,7 @@ typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32
 typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent2D shadingRateTexelSize;
     uint32_t shadingRatePaletteSize;
     uint32_t shadingRateMaxCoarseSamples;
@@ -4856,7 +4856,7 @@ typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32
 typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxDrawMeshTasksCount;
     uint32_t maxTaskWorkGroupInvocations;
     uint32_t maxTaskWorkGroupSize[3];
@@ -4875,7 +4875,7 @@ typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32
 typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxTaskWorkGroupTotalCount;
     uint32_t maxTaskWorkGroupCount[3];
     uint32_t maxTaskWorkGroupInvocations;
@@ -4909,7 +4909,7 @@ typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32
 typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) maxGeometryCount;
     uint64_t DECLSPEC_ALIGN(8) maxInstanceCount;
     uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount;
@@ -4923,7 +4923,7 @@ typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32
 typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t shaderGroupHandleSize;
     uint32_t maxRayRecursionDepth;
     uint32_t maxShaderGroupStride;
@@ -4937,7 +4937,7 @@ typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32
 typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t shaderGroupHandleSize;
     uint32_t maxRecursionDepth;
     uint32_t maxShaderGroupStride;
@@ -4951,7 +4951,7 @@ typedef struct VkPhysicalDeviceRayTracingPropertiesNV32
 typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent2D minFragmentDensityTexelSize;
     VkExtent2D maxFragmentDensityTexelSize;
     VkBool32 fragmentDensityInvocations;
@@ -4960,7 +4960,7 @@ typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32
 typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 subsampledLoads;
     VkBool32 subsampledCoarseReconstructionEarlyAccess;
     uint32_t maxSubsampledArrayLayers;
@@ -4970,28 +4970,28 @@ typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32
 typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent2D fragmentDensityOffsetGranularity;
 } VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;

typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkShaderStageFlags cooperativeMatrixSupportedStages;
 } VkPhysicalDeviceCooperativeMatrixPropertiesNV32;

typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 allowCommandBufferQueryCopies;
 } VkPhysicalDevicePerformanceQueryPropertiesKHR32;

typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t shaderSMCount;
     uint32_t shaderWarpsPerSM;
 } VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;
@@ -4999,7 +4999,7 @@ typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32
 typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes;
     VkBool32 storageTexelBufferOffsetSingleTexelAlignment;
     VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes;
@@ -5010,7 +5010,7 @@ typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBu
 typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t minSubgroupSize;
     uint32_t maxSubgroupSize;
     uint32_t maxComputeWorkgroupSubgroups;
@@ -5021,21 +5021,21 @@ typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroup
 typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;
 } VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;

typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t lineSubPixelPrecisionBits;
 } VkPhysicalDeviceLineRasterizationPropertiesEXT32;

typedef struct VkPhysicalDeviceVulkan11Properties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint8_t deviceUUID[VK_UUID_SIZE];
     uint8_t driverUUID[VK_UUID_SIZE];
     uint8_t deviceLUID[VK_LUID_SIZE];
@@ -5056,7 +5056,7 @@ typedef struct VkPhysicalDeviceVulkan11Properties32
 typedef struct VkPhysicalDeviceVulkan12Properties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDriverId driverID;
     char driverName[VK_MAX_DRIVER_NAME_SIZE];
     char driverInfo[VK_MAX_DRIVER_INFO_SIZE];
@@ -5114,7 +5114,7 @@ typedef struct VkPhysicalDeviceVulkan12Properties32
 typedef struct VkPhysicalDeviceVulkan13Properties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t minSubgroupSize;
     uint32_t maxSubgroupSize;
     uint32_t maxComputeWorkgroupSubgroups;
@@ -5165,21 +5165,21 @@ typedef struct VkPhysicalDeviceVulkan13Properties32
 typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxCustomBorderColorSamplers;
 } VkPhysicalDeviceCustomBorderColorPropertiesEXT32;

typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 dynamicPrimitiveTopologyUnrestricted;
 } VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;

typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment;
     VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment;
 } VkPhysicalDeviceRobustness2PropertiesEXT32;
@@ -5187,7 +5187,7 @@ typedef struct VkPhysicalDeviceRobustness2PropertiesEXT32
 typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkExtent2D minFragmentShadingRateAttachmentTexelSize;
     VkExtent2D maxFragmentShadingRateAttachmentTexelSize;
     uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
@@ -5210,14 +5210,14 @@ typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32
 typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;
 } VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;

typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 provokingVertexModePerPipeline;
     VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;
 } VkPhysicalDeviceProvokingVertexPropertiesEXT32;
@@ -5225,7 +5225,7 @@ typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32
 typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 integerDotProduct8BitUnsignedAccelerated;
     VkBool32 integerDotProduct8BitSignedAccelerated;
     VkBool32 integerDotProduct8BitMixedSignednessAccelerated;
@@ -5262,14 +5262,14 @@ typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShad
 typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 triStripVertexOrderIndependentOfProvokingVertex;
 } VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;

typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 graphicsPipelineLibraryFastLinking;
     VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;
 } VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;
@@ -5277,14 +5277,14 @@ typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32
 typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE];
 } VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;

typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxOpacity2StateSubdivisionLevel;
     uint32_t maxOpacity4StateSubdivisionLevel;
 } VkPhysicalDeviceOpacityMicromapPropertiesEXT32;
@@ -5292,7 +5292,7 @@ typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32
 typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers;
     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers;
     VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs;
@@ -5302,7 +5302,7 @@ typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT32
 typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t maxWeightFilterPhases;
     VkExtent2D maxWeightFilterDimension;
     VkExtent2D maxBlockMatchRegion;
@@ -5312,7 +5312,7 @@ typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32
 typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes;
     VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes;
     VkBool32 hintSupported;
@@ -5329,7 +5329,7 @@ typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32
 typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint64_t DECLSPEC_ALIGN(8) shaderCoreMask;
     uint32_t shaderCoreCount;
     uint32_t shaderWarpsPerCore;
@@ -5338,14 +5338,14 @@ typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32
 typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint;
 } VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;

typedef struct VkPhysicalDeviceProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties;
 } VkPhysicalDeviceProperties232;
 typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
@@ -5353,7 +5353,7 @@ typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;
 typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t priorityCount;
     VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];
 } VkQueueFamilyGlobalPriorityPropertiesKHR32;
@@ -5362,21 +5362,21 @@ typedef VkQueueFamilyGlobalPriorityPropertiesKHR32 VkQueueFamilyGlobalPriorityPr
 typedef struct VkQueueFamilyCheckpointPropertiesNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags checkpointExecutionStageMask;
 } VkQueueFamilyCheckpointPropertiesNV32;

typedef struct VkQueueFamilyCheckpointProperties2NV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask;
 } VkQueueFamilyCheckpointProperties2NV32;

typedef struct VkQueueFamilyProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkQueueFamilyProperties queueFamilyProperties;
 } VkQueueFamilyProperties232;
 typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
@@ -5384,7 +5384,7 @@ typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;
 typedef struct VkPhysicalDeviceSparseImageFormatInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkFormat format;
     VkImageType type;
     VkSampleCountFlagBits samples;
@@ -5396,7 +5396,7 @@ typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageForm
 typedef struct VkSparseImageFormatProperties232
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSparseImageFormatProperties properties;
 } VkSparseImageFormatProperties232;
 typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
@@ -5404,7 +5404,7 @@ typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;
 typedef struct VkFramebufferMixedSamplesCombinationNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkCoverageReductionModeNV coverageReductionMode;
     VkSampleCountFlagBits rasterizationSamples;
     VkSampleCountFlags depthStencilSamples;
@@ -5414,35 +5414,35 @@ typedef struct VkFramebufferMixedSamplesCombinationNV32
 typedef struct VkPhysicalDeviceSurfaceInfo2KHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
 } VkPhysicalDeviceSurfaceInfo2KHR32;

typedef struct VkSurfaceCapabilitiesPresentBarrierNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkBool32 presentBarrierSupported;
 } VkSurfaceCapabilitiesPresentBarrierNV32;

typedef struct VkSurfaceCapabilities2KHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSurfaceCapabilitiesKHR surfaceCapabilities;
 } VkSurfaceCapabilities2KHR32;

typedef struct VkSurfaceFormat2KHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkSurfaceFormatKHR surfaceFormat;
 } VkSurfaceFormat2KHR32;

typedef struct VkPhysicalDeviceToolProperties32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     char name[VK_MAX_EXTENSION_NAME_SIZE];
     char version[VK_MAX_EXTENSION_NAME_SIZE];
     VkToolPurposeFlags purposes;
@@ -5454,7 +5454,7 @@ typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;
 typedef struct VkPipelineExecutableInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
     uint32_t executableIndex;
 } VkPipelineExecutableInfoKHR32;
@@ -5462,18 +5462,18 @@ typedef struct VkPipelineExecutableInfoKHR32
 typedef struct VkPipelineExecutableInternalRepresentationKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     char name[VK_MAX_DESCRIPTION_SIZE];
     char description[VK_MAX_DESCRIPTION_SIZE];
     VkBool32 isText;
-    size_t dataSize;
-    void *pData;
+    PTR32 dataSize;
+    PTR32 pData;
 } VkPipelineExecutableInternalRepresentationKHR32;

typedef struct VkPipelineInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkPipeline DECLSPEC_ALIGN(8) pipeline;
 } VkPipelineInfoKHR32;
 typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
@@ -5481,7 +5481,7 @@ typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;
 typedef struct VkPipelineExecutablePropertiesKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkShaderStageFlags stages;
     char name[VK_MAX_DESCRIPTION_SIZE];
     char description[VK_MAX_DESCRIPTION_SIZE];
@@ -5491,7 +5491,7 @@ typedef struct VkPipelineExecutablePropertiesKHR32
 typedef struct VkPipelineExecutableStatisticKHR32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     char name[VK_MAX_DESCRIPTION_SIZE];
     char description[VK_MAX_DESCRIPTION_SIZE];
     VkPipelineExecutableStatisticFormatKHR format;
@@ -5502,23 +5502,23 @@ typedef struct VkPipelineExecutableStatisticKHR32
 typedef struct VkCheckpointData2NV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
-    void *pCheckpointMarker;
+    PTR32 pCheckpointMarker;
 } VkCheckpointData2NV32;

typedef struct VkCheckpointDataNV32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkPipelineStageFlagBits stage;
-    void *pCheckpointMarker;
+    PTR32 pCheckpointMarker;
 } VkCheckpointDataNV32;

typedef struct VkShaderModuleIdentifierEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     uint32_t identifierSize;
     uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT];
 } VkShaderModuleIdentifierEXT32;
@@ -5526,8 +5526,8 @@ typedef struct VkShaderModuleIdentifierEXT32
 typedef struct VkInitializePerformanceApiInfoINTEL32
 {
     VkStructureType sType;
-    const void *pNext;
-    void *pUserData;
+    PTR32 pNext;
+    PTR32 pUserData;
 } VkInitializePerformanceApiInfoINTEL32;

typedef struct VkSparseMemoryBind32
@@ -5543,14 +5543,14 @@ typedef struct VkSparseBufferMemoryBindInfo32
 {
     VkBuffer DECLSPEC_ALIGN(8) buffer;
     uint32_t bindCount;
-    const VkSparseMemoryBind32 *pBinds;
+    PTR32 pBinds;
 } VkSparseBufferMemoryBindInfo32;

typedef struct VkSparseImageOpaqueMemoryBindInfo32
 {
     VkImage DECLSPEC_ALIGN(8) image;
     uint32_t bindCount;
-    const VkSparseMemoryBind32 *pBinds;
+    PTR32 pBinds;
 } VkSparseImageOpaqueMemoryBindInfo32;

typedef struct VkSparseImageMemoryBind32
@@ -5567,13 +5567,13 @@ typedef struct VkSparseImageMemoryBindInfo32
 {
     VkImage DECLSPEC_ALIGN(8) image;
     uint32_t bindCount;
-    const VkSparseImageMemoryBind32 *pBinds;
+    PTR32 pBinds;
 } VkSparseImageMemoryBindInfo32;

typedef struct VkDeviceGroupBindSparseInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t resourceDeviceIndex;
     uint32_t memoryDeviceIndex;
 } VkDeviceGroupBindSparseInfo32;
@@ -5582,117 +5582,117 @@ typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32;
 typedef struct VkTimelineSemaphoreSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t waitSemaphoreValueCount;
-    const uint64_t *pWaitSemaphoreValues;
+    PTR32 pWaitSemaphoreValues;
     uint32_t signalSemaphoreValueCount;
-    const uint64_t *pSignalSemaphoreValues;
+    PTR32 pSignalSemaphoreValues;
 } VkTimelineSemaphoreSubmitInfo32;
 typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;

typedef struct VkBindSparseInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t waitSemaphoreCount;
-    const VkSemaphore *pWaitSemaphores;
+    PTR32 pWaitSemaphores;
     uint32_t bufferBindCount;
-    const VkSparseBufferMemoryBindInfo32 *pBufferBinds;
+    PTR32 pBufferBinds;
     uint32_t imageOpaqueBindCount;
-    const VkSparseImageOpaqueMemoryBindInfo32 *pImageOpaqueBinds;
+    PTR32 pImageOpaqueBinds;
     uint32_t imageBindCount;
-    const VkSparseImageMemoryBindInfo32 *pImageBinds;
+    PTR32 pImageBinds;
     uint32_t signalSemaphoreCount;
-    const VkSemaphore *pSignalSemaphores;
+    PTR32 pSignalSemaphores;
 } VkBindSparseInfo32;

typedef struct VkPresentRegionKHR32
 {
     uint32_t rectangleCount;
-    const VkRectLayerKHR *pRectangles;
+    PTR32 pRectangles;
 } VkPresentRegionKHR32;

typedef struct VkPresentRegionsKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t swapchainCount;
-    const VkPresentRegionKHR32 *pRegions;
+    PTR32 pRegions;
 } VkPresentRegionsKHR32;

typedef struct VkDeviceGroupPresentInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t swapchainCount;
-    const uint32_t *pDeviceMasks;
+    PTR32 pDeviceMasks;
     VkDeviceGroupPresentModeFlagBitsKHR mode;
 } VkDeviceGroupPresentInfoKHR32;

typedef struct VkPresentIdKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t swapchainCount;
-    const uint64_t *pPresentIds;
+    PTR32 pPresentIds;
 } VkPresentIdKHR32;

typedef struct VkPresentInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t waitSemaphoreCount;
-    const VkSemaphore *pWaitSemaphores;
+    PTR32 pWaitSemaphores;
     uint32_t swapchainCount;
-    const VkSwapchainKHR *pSwapchains;
-    const uint32_t *pImageIndices;
-    VkResult *pResults;
+    PTR32 pSwapchains;
+    PTR32 pImageIndices;
+    PTR32 pResults;
 } VkPresentInfoKHR32;

typedef struct VkDeviceGroupSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t waitSemaphoreCount;
-    const uint32_t *pWaitSemaphoreDeviceIndices;
+    PTR32 pWaitSemaphoreDeviceIndices;
     uint32_t commandBufferCount;
-    const uint32_t *pCommandBufferDeviceMasks;
+    PTR32 pCommandBufferDeviceMasks;
     uint32_t signalSemaphoreCount;
-    const uint32_t *pSignalSemaphoreDeviceIndices;
+    PTR32 pSignalSemaphoreDeviceIndices;
 } VkDeviceGroupSubmitInfo32;
 typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;

typedef struct VkProtectedSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkBool32 protectedSubmit;
 } VkProtectedSubmitInfo32;

typedef struct VkPerformanceQuerySubmitInfoKHR32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t counterPassIndex;
 } VkPerformanceQuerySubmitInfoKHR32;

typedef struct VkSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     uint32_t waitSemaphoreCount;
-    const VkSemaphore *pWaitSemaphores;
-    const VkPipelineStageFlags *pWaitDstStageMask;
+    PTR32 pWaitSemaphores;
+    PTR32 pWaitDstStageMask;
     uint32_t commandBufferCount;
-    const VkCommandBuffer *pCommandBuffers;
+    PTR32 pCommandBuffers;
     uint32_t signalSemaphoreCount;
-    const VkSemaphore *pSignalSemaphores;
+    PTR32 pSignalSemaphores;
 } VkSubmitInfo32;

typedef struct VkSemaphoreSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
     uint64_t DECLSPEC_ALIGN(8) value;
     VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
@@ -5703,8 +5703,8 @@ typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;
 typedef struct VkCommandBufferSubmitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
-    VkCommandBuffer commandBuffer;
+    PTR32 pNext;
+    PTR32 commandBuffer;
     uint32_t deviceMask;
 } VkCommandBufferSubmitInfo32;
 typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
@@ -5712,32 +5712,32 @@ typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;
 typedef struct VkSubmitInfo232
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSubmitFlags flags;
     uint32_t waitSemaphoreInfoCount;
-    const VkSemaphoreSubmitInfo32 *pWaitSemaphoreInfos;
+    PTR32 pWaitSemaphoreInfos;
     uint32_t commandBufferInfoCount;
-    const VkCommandBufferSubmitInfo32 *pCommandBufferInfos;
+    PTR32 pCommandBufferInfos;
     uint32_t signalSemaphoreInfoCount;
-    const VkSemaphoreSubmitInfo32 *pSignalSemaphoreInfos;
+    PTR32 pSignalSemaphoreInfos;
 } VkSubmitInfo232;
 typedef VkSubmitInfo232 VkSubmitInfo2KHR32;

typedef struct VkDebugUtilsObjectTagInfoEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkObjectType objectType;
     uint64_t DECLSPEC_ALIGN(8) objectHandle;
     uint64_t DECLSPEC_ALIGN(8) tagName;
-    size_t tagSize;
-    const void *pTag;
+    PTR32 tagSize;
+    PTR32 pTag;
 } VkDebugUtilsObjectTagInfoEXT32;

typedef struct VkSemaphoreSignalInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSemaphore DECLSPEC_ALIGN(8) semaphore;
     uint64_t DECLSPEC_ALIGN(8) value;
 } VkSemaphoreSignalInfo32;
@@ -5746,7 +5746,7 @@ typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;
 typedef struct VkDeviceAddressBindingCallbackDataEXT32
 {
     VkStructureType sType;
-    void *pNext;
+    PTR32 pNext;
     VkDeviceAddressBindingFlagsEXT flags;
     VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress;
     VkDeviceSize DECLSPEC_ALIGN(8) size;
@@ -5756,23 +5756,23 @@ typedef struct VkDeviceAddressBindingCallbackDataEXT32
 typedef struct VkDebugUtilsMessengerCallbackDataEXT32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDebugUtilsMessengerCallbackDataFlagsEXT flags;
-    const char *pMessageIdName;
+    PTR32 pMessageIdName;
     int32_t messageIdNumber;
-    const char *pMessage;
+    PTR32 pMessage;
     uint32_t queueLabelCount;
-    const VkDebugUtilsLabelEXT32 *pQueueLabels;
+    PTR32 pQueueLabels;
     uint32_t cmdBufLabelCount;
-    const VkDebugUtilsLabelEXT32 *pCmdBufLabels;
+    PTR32 pCmdBufLabels;
     uint32_t objectCount;
-    const VkDebugUtilsObjectNameInfoEXT32 *pObjects;
+    PTR32 pObjects;
 } VkDebugUtilsMessengerCallbackDataEXT32;

typedef struct VkCopyDescriptorSet32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkDescriptorSet DECLSPEC_ALIGN(8) srcSet;
     uint32_t srcBinding;
     uint32_t srcArrayElement;
@@ -5785,11 +5785,11 @@ typedef struct VkCopyDescriptorSet32
 typedef struct VkSemaphoreWaitInfo32
 {
     VkStructureType sType;
-    const void *pNext;
+    PTR32 pNext;
     VkSemaphoreWaitFlags flags;
     uint32_t semaphoreCount;
-    const VkSemaphore *pSemaphores;
-    const uint64_t *pValues;
+    PTR32 pSemaphores;
+    PTR32 pValues;
 } VkSemaphoreWaitInfo32;
 typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;

@@ -5828,7 +5828,7 @@ static inline void convert_VkAcquireNextImageInfoKHR_win32_to_host(const VkAcqui
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->swapchain = in->swapchain;
     out->timeout = in->timeout;
     out->semaphore = in->semaphore;
@@ -5843,7 +5843,7 @@ static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_h
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -5854,7 +5854,7 @@ static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkA
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->timeout = in->timeout;
 }
@@ -5866,7 +5866,7 @@ static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(c
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->commandPool = in->commandPool;
     out->level = in->level;
     out->commandBufferCount = in->commandBufferCount;
@@ -5874,7 +5874,7 @@ static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(c
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
+static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkCommandBuffer *out;
     unsigned int i;
@@ -5884,7 +5884,7 @@ static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i] = in[i];
+        out[i] = UlongToPtr(in[i]);
     }

return out;
@@ -5903,7 +5903,7 @@ static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conv
     out->pNext = NULL;
     out->descriptorPool = in->descriptorPool;
     out->descriptorSetCount = in->descriptorSetCount;
-    out->pSetLayouts = in->pSetLayouts;
+    out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -5916,7 +5916,7 @@ static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conv
             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
             out_ext->pNext = NULL;
             out_ext->descriptorSetCount = in_ext->descriptorSetCount;
-            out_ext->pDescriptorCounts = in_ext->pDescriptorCounts;
+            out_ext->pDescriptorCounts = (const uint32_t *)UlongToPtr(in_ext->pDescriptorCounts);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -5988,7 +5988,7 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_
             const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->pAttributes = in_ext->pAttributes;
+            out_ext->pAttributes = (const SECURITY_ATTRIBUTES *)UlongToPtr(in_ext->pAttributes);
             out_ext->dwAccess = in_ext->dwAccess;
             out_ext->name = in_ext->name;
             out_header->pNext = (void *)out_ext;
@@ -6026,7 +6026,7 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->handleType = in_ext->handleType;
-            out_ext->pHostPointer = in_ext->pHostPointer;
+            out_ext->pHostPointer = (void *)UlongToPtr(in_ext->pHostPointer);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6113,7 +6113,7 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c
             out_ext->pNext = NULL;
             out_ext->viewportScissor2D = in_ext->viewportScissor2D;
             out_ext->viewportDepthCount = in_ext->viewportDepthCount;
-            out_ext->pViewportDepths = in_ext->pViewportDepths;
+            out_ext->pViewportDepths = (const VkViewport *)UlongToPtr(in_ext->pViewportDepths);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6127,7 +6127,7 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c
             out_ext->flags = in_ext->flags;
             out_ext->viewMask = in_ext->viewMask;
             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
+            out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
             out_ext->rasterizationSamples = in_ext->rasterizationSamples;
@@ -6142,7 +6142,7 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c
             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
             out_ext->pNext = NULL;
             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
+            out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -6197,7 +6197,7 @@ static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct convers
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, in->pInheritanceInfo, 1);
+    out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win32_to_host(ctx, (const VkCommandBufferInheritanceInfo32 *)UlongToPtr(in->pInheritanceInfo), 1);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -6228,12 +6228,12 @@ static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->accelerationStructure = in->accelerationStructure;
     out->memory = in->memory;
     out->memoryOffset = in->memoryOffset;
     out->deviceIndexCount = in->deviceIndexCount;
-    out->pDeviceIndices = in->pDeviceIndices;
+    out->pDeviceIndices = (const uint32_t *)UlongToPtr(in->pDeviceIndices);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -6280,7 +6280,7 @@ static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversio
             out_ext->sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
             out_ext->pNext = NULL;
             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
-            out_ext->pDeviceIndices = in_ext->pDeviceIndices;
+            out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6336,9 +6336,9 @@ static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion
             out_ext->sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
             out_ext->pNext = NULL;
             out_ext->deviceIndexCount = in_ext->deviceIndexCount;
-            out_ext->pDeviceIndices = in_ext->pDeviceIndices;
+            out_ext->pDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pDeviceIndices);
             out_ext->splitInstanceBindRegionCount = in_ext->splitInstanceBindRegionCount;
-            out_ext->pSplitInstanceBindRegions = in_ext->pSplitInstanceBindRegions;
+            out_ext->pSplitInstanceBindRegions = (const VkRect2D *)UlongToPtr(in_ext->pSplitInstanceBindRegions);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6398,7 +6398,7 @@ static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->geometryType = in->geometryType;
     out->geometry = in->geometry;
     out->flags = in->flags;
@@ -6424,7 +6424,7 @@ static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationSt
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 * const*in, uint32_t count)
+static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkAccelerationStructureGeometryKHR **out;
     unsigned int i;
@@ -6437,7 +6437,7 @@ static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAcceler
         if (in[i])
         {
             out[i] = conversion_context_alloc(ctx, sizeof(*out[i]));
-            convert_VkAccelerationStructureGeometryKHR_win32_to_host(in[i], out[i]);
+            convert_VkAccelerationStructureGeometryKHR_win32_to_host((VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in[i]), out[i]);
         }
         else
             out[i] = NULL;
@@ -6453,15 +6453,15 @@ static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->flags = in->flags;
     out->mode = in->mode;
     out->srcAccelerationStructure = in->srcAccelerationStructure;
     out->dstAccelerationStructure = in->dstAccelerationStructure;
     out->geometryCount = in->geometryCount;
-    out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
-    out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, in->ppGeometries, in->geometryCount);
+    out->pGeometries = convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(ctx, (const VkAccelerationStructureGeometryKHR32 *)UlongToPtr(in->pGeometries), in->geometryCount);
+    out->ppGeometries = convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->ppGeometries), in->geometryCount);
     out->scratchData = in->scratchData;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -6490,14 +6490,14 @@ static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(const VkMicromap
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->flags = in->flags;
     out->mode = in->mode;
     out->dstMicromap = in->dstMicromap;
     out->usageCountsCount = in->usageCountsCount;
-    out->pUsageCounts = in->pUsageCounts;
-    out->ppUsageCounts = in->ppUsageCounts;
+    out->pUsageCounts = (const VkMicromapUsageEXT *)UlongToPtr(in->pUsageCounts);
+    out->ppUsageCounts = UlongToPtr(in->ppUsageCounts);
     out->data = in->data;
     out->scratchData = in->scratchData;
     out->triangleArray = in->triangleArray;
@@ -6529,7 +6529,7 @@ static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->buffer = in->buffer;
     out->offset = in->offset;
     out->flags = in->flags;
@@ -6542,8 +6542,8 @@ static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtils
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pLabelName = in->pLabelName;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pLabelName = (const char *)UlongToPtr(in->pLabelName);
     memcpy(out->color, in->color, 4 * sizeof(float));
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -6554,11 +6554,11 @@ static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSample
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->sampleLocationsPerPixel = in->sampleLocationsPerPixel;
     out->sampleLocationGridSize = in->sampleLocationGridSize;
     out->sampleLocationsCount = in->sampleLocationsCount;
-    out->pSampleLocations = in->pSampleLocations;
+    out->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in->pSampleLocations);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -6632,7 +6632,7 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion
     out->framebuffer = in->framebuffer;
     out->renderArea = in->renderArea;
     out->clearValueCount = in->clearValueCount;
-    out->pClearValues = in->pClearValues;
+    out->pClearValues = (const VkClearValue *)UlongToPtr(in->pClearValues);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -6646,7 +6646,7 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion
             out_ext->pNext = NULL;
             out_ext->deviceMask = in_ext->deviceMask;
             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
-            out_ext->pDeviceRenderAreas = in_ext->pDeviceRenderAreas;
+            out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6658,9 +6658,9 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount;
-            out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, in_ext->pAttachmentInitialSampleLocations, in_ext->attachmentInitialSampleLocationsCount);
+            out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount);
             out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount;
-            out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, in_ext->pPostSubpassSampleLocations, in_ext->postSubpassSampleLocationsCount);
+            out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6672,7 +6672,7 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
             out_ext->pNext = NULL;
             out_ext->attachmentCount = in_ext->attachmentCount;
-            out_ext->pAttachments = in_ext->pAttachments;
+            out_ext->pAttachments = (const VkImageView *)UlongToPtr(in_ext->pAttachments);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6702,7 +6702,7 @@ static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBegin
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->contents = in->contents;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -6713,7 +6713,7 @@ static inline void convert_VkRenderingAttachmentInfo_win32_to_host(const VkRende
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->imageView = in->imageView;
     out->imageLayout = in->imageLayout;
     out->resolveMode = in->resolveMode;
@@ -6758,9 +6758,9 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte
     out->layerCount = in->layerCount;
     out->viewMask = in->viewMask;
     out->colorAttachmentCount = in->colorAttachmentCount;
-    out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pColorAttachments, in->colorAttachmentCount);
-    out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pDepthAttachment, 1);
-    out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, in->pStencilAttachment, 1);
+    out->pColorAttachments = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
+    out->pDepthAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pDepthAttachment), 1);
+    out->pStencilAttachment = convert_VkRenderingAttachmentInfo_array_win32_to_host(ctx, (const VkRenderingAttachmentInfo32 *)UlongToPtr(in->pStencilAttachment), 1);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -6774,7 +6774,7 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte
             out_ext->pNext = NULL;
             out_ext->deviceMask = in_ext->deviceMask;
             out_ext->deviceRenderAreaCount = in_ext->deviceRenderAreaCount;
-            out_ext->pDeviceRenderAreas = in_ext->pDeviceRenderAreas;
+            out_ext->pDeviceRenderAreas = (const VkRect2D *)UlongToPtr(in_ext->pDeviceRenderAreas);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -6898,13 +6898,13 @@ static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_cont
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcImage = in->srcImage;
     out->srcImageLayout = in->srcImageLayout;
     out->dstImage = in->dstImage;
     out->dstImageLayout = in->dstImageLayout;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkImageBlit2_array_win32_to_host(ctx, (const VkImageBlit232 *)UlongToPtr(in->pRegions), in->regionCount);
     out->filter = in->filter;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -6915,7 +6915,7 @@ static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryT
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->vertexData = in->vertexData;
     out->vertexOffset = in->vertexOffset;
     out->vertexCount = in->vertexCount;
@@ -6936,7 +6936,7 @@ static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->aabbData = in->aabbData;
     out->numAABBs = in->numAABBs;
     out->stride = in->stride;
@@ -6960,7 +6960,7 @@ static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in,
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->geometryType = in->geometryType;
     convert_VkGeometryDataNV_win32_to_host(&in->geometry, &out->geometry);
     out->flags = in->flags;
@@ -6991,12 +6991,12 @@ static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct co
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->flags = in->flags;
     out->instanceCount = in->instanceCount;
     out->geometryCount = in->geometryCount;
-    out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, in->pGeometries, in->geometryCount);
+    out->pGeometries = convert_VkGeometryNV_array_win32_to_host(ctx, (const VkGeometryNV32 *)UlongToPtr(in->pGeometries), in->geometryCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7006,7 +7006,7 @@ static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7019,7 +7019,7 @@ static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_h
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7061,7 +7061,7 @@ static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcOffset = in->srcOffset;
     out->dstOffset = in->dstOffset;
     out->size = in->size;
@@ -7092,11 +7092,11 @@ static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcBuffer = in->srcBuffer;
     out->dstBuffer = in->dstBuffer;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkBufferCopy2_array_win32_to_host(ctx, (const VkBufferCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7196,12 +7196,12 @@ static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct convers
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcBuffer = in->srcBuffer;
     out->dstImage = in->dstImage;
     out->dstImageLayout = in->dstImageLayout;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7211,7 +7211,7 @@ static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in,
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcSubresource = in->srcSubresource;
     out->srcOffset = in->srcOffset;
     out->dstSubresource = in->dstSubresource;
@@ -7244,13 +7244,13 @@ static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_cont
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcImage = in->srcImage;
     out->srcImageLayout = in->srcImageLayout;
     out->dstImage = in->dstImage;
     out->dstImageLayout = in->dstImageLayout;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkImageCopy2_array_win32_to_host(ctx, (const VkImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7260,12 +7260,12 @@ static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct convers
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcImage = in->srcImage;
     out->srcImageLayout = in->srcImageLayout;
     out->dstBuffer = in->dstBuffer;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkBufferImageCopy2_array_win32_to_host(ctx, (const VkBufferImageCopy232 *)UlongToPtr(in->pRegions), in->regionCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7275,7 +7275,7 @@ static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_h
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7288,7 +7288,7 @@ static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkC
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7301,7 +7301,7 @@ static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicro
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7314,7 +7314,7 @@ static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkC
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->src = in->src;
     out->dst = in->dst;
     out->mode = in->mode;
@@ -7327,7 +7327,7 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->function = in->function;
     out->gridDimX = in->gridDimX;
     out->gridDimY = in->gridDimY;
@@ -7337,9 +7337,9 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN
     out->blockDimZ = in->blockDimZ;
     out->sharedMemBytes = in->sharedMemBytes;
     out->paramCount = in->paramCount;
-    out->pParams = in->pParams;
+    out->pParams = (const void * const *)UlongToPtr(in->pParams);
     out->extraCount = in->extraCount;
-    out->pExtras = in->pExtras;
+    out->pExtras = (const void * const *)UlongToPtr(in->pExtras);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7349,8 +7349,8 @@ static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebu
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pMarkerName = in->pMarkerName;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pMarkerName = (const char *)UlongToPtr(in->pMarkerName);
     memcpy(out->color, in->color, 4 * sizeof(float));
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -7408,7 +7408,7 @@ static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_cont
             out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
             out_ext->pNext = NULL;
             out_ext->fragmentDensityOffsetCount = in_ext->fragmentDensityOffsetCount;
-            out_ext->pFragmentDensityOffsets = in_ext->pFragmentDensityOffsets;
+            out_ext->pFragmentDensityOffsets = (const VkOffset2D *)UlongToPtr(in_ext->pFragmentDensityOffsets);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7440,7 +7440,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count)
+static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkCommandBuffer *out;
     unsigned int i;
@@ -7450,7 +7450,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i] = wine_cmd_buffer_from_handle(in[i])->command_buffer;
+        out[i] = wine_cmd_buffer_from_handle(UlongToPtr(in[i]))->command_buffer;
     }

return out;
@@ -7491,12 +7491,12 @@ static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conver
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->pipelineBindPoint = in->pipelineBindPoint;
     out->pipeline = in->pipeline;
     out->indirectCommandsLayout = in->indirectCommandsLayout;
     out->streamCount = in->streamCount;
-    out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, in->pStreams, in->streamCount);
+    out->pStreams = convert_VkIndirectCommandsStreamNV_array_win32_to_host(ctx, (const VkIndirectCommandsStreamNV32 *)UlongToPtr(in->pStreams), in->streamCount);
     out->sequencesCount = in->sequencesCount;
     out->preprocessBuffer = in->preprocessBuffer;
     out->preprocessOffset = in->preprocessOffset;
@@ -7514,10 +7514,10 @@ static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpti
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->regionCount = in->regionCount;
-    out->pRegions = in->pRegions;
+    out->pRegions = (const VkRect2D *)UlongToPtr(in->pRegions);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7527,7 +7527,7 @@ static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcAccessMask = in->srcAccessMask;
     out->dstAccessMask = in->dstAccessMask;
 }
@@ -7557,7 +7557,7 @@ static inline void convert_VkBufferMemoryBarrier_win32_to_host(const VkBufferMem
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcAccessMask = in->srcAccessMask;
     out->dstAccessMask = in->dstAccessMask;
     out->srcQueueFamilyIndex = in->srcQueueFamilyIndex;
@@ -7618,7 +7618,7 @@ static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_
             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
-            out_ext->pSampleLocations = in_ext->pSampleLocations;
+            out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7655,7 +7655,7 @@ static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier2
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcStageMask = in->srcStageMask;
     out->srcAccessMask = in->srcAccessMask;
     out->dstStageMask = in->dstStageMask;
@@ -7687,7 +7687,7 @@ static inline void convert_VkBufferMemoryBarrier2_win32_to_host(const VkBufferMe
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcStageMask = in->srcStageMask;
     out->srcAccessMask = in->srcAccessMask;
     out->dstStageMask = in->dstStageMask;
@@ -7752,7 +7752,7 @@ static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion
             out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel;
             out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize;
             out_ext->sampleLocationsCount = in_ext->sampleLocationsCount;
-            out_ext->pSampleLocations = in_ext->pSampleLocations;
+            out_ext->pSampleLocations = (const VkSampleLocationEXT *)UlongToPtr(in_ext->pSampleLocations);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7789,14 +7789,14 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->dependencyFlags = in->dependencyFlags;
     out->memoryBarrierCount = in->memoryBarrierCount;
-    out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, in->pMemoryBarriers, in->memoryBarrierCount);
+    out->pMemoryBarriers = convert_VkMemoryBarrier2_array_win32_to_host(ctx, (const VkMemoryBarrier232 *)UlongToPtr(in->pMemoryBarriers), in->memoryBarrierCount);
     out->bufferMemoryBarrierCount = in->bufferMemoryBarrierCount;
-    out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, in->pBufferMemoryBarriers, in->bufferMemoryBarrierCount);
+    out->pBufferMemoryBarriers = convert_VkBufferMemoryBarrier2_array_win32_to_host(ctx, (const VkBufferMemoryBarrier232 *)UlongToPtr(in->pBufferMemoryBarriers), in->bufferMemoryBarrierCount);
     out->imageMemoryBarrierCount = in->imageMemoryBarrierCount;
-    out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, in->pImageMemoryBarriers, in->imageMemoryBarrierCount);
+    out->pImageMemoryBarriers = convert_VkImageMemoryBarrier2_array_win32_to_host(ctx, (const VkImageMemoryBarrier232 *)UlongToPtr(in->pImageMemoryBarriers), in->imageMemoryBarrierCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -7873,9 +7873,9 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_
     out->dstArrayElement = in->dstArrayElement;
     out->descriptorCount = in->descriptorCount;
     out->descriptorType = in->descriptorType;
-    out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, in->pImageInfo, in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || in->descriptorType == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM ? in->descriptorCount : 0);
-    out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, in->pBufferInfo, in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ? in->descriptorCount : 0);
-    out->pTexelBufferView = in->pTexelBufferView;
+    out->pImageInfo = convert_VkDescriptorImageInfo_array_win32_to_host(ctx, (const VkDescriptorImageInfo32 *)UlongToPtr(in->pImageInfo), in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE || in->descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT || in->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM || in->descriptorType == VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM ? in->descriptorCount : 0);
+    out->pBufferInfo = convert_VkDescriptorBufferInfo_array_win32_to_host(ctx, (const VkDescriptorBufferInfo32 *)UlongToPtr(in->pBufferInfo), in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || in->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || in->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC ? in->descriptorCount : 0);
+    out->pTexelBufferView = (const VkBufferView *)UlongToPtr(in->pTexelBufferView);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -7888,7 +7888,7 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
             out_ext->pNext = NULL;
             out_ext->dataSize = in_ext->dataSize;
-            out_ext->pData = in_ext->pData;
+            out_ext->pData = (const void *)UlongToPtr(in_ext->pData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7900,7 +7900,7 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
             out_ext->pNext = NULL;
             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
-            out_ext->pAccelerationStructures = in_ext->pAccelerationStructures;
+            out_ext->pAccelerationStructures = (const VkAccelerationStructureKHR *)UlongToPtr(in_ext->pAccelerationStructures);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7912,7 +7912,7 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
             out_ext->pNext = NULL;
             out_ext->accelerationStructureCount = in_ext->accelerationStructureCount;
-            out_ext->pAccelerationStructures = in_ext->pAccelerationStructures;
+            out_ext->pAccelerationStructures = (const VkAccelerationStructureNV *)UlongToPtr(in_ext->pAccelerationStructures);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -7949,7 +7949,7 @@ static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcSubresource = in->srcSubresource;
     out->srcOffset = in->srcOffset;
     out->dstSubresource = in->dstSubresource;
@@ -7982,13 +7982,13 @@ static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_c
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcImage = in->srcImage;
     out->srcImageLayout = in->srcImageLayout;
     out->dstImage = in->dstImage;
     out->dstImageLayout = in->dstImageLayout;
     out->regionCount = in->regionCount;
-    out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, in->pRegions, in->regionCount);
+    out->pRegions = convert_VkImageResolve2_array_win32_to_host(ctx, (const VkImageResolve232 *)UlongToPtr(in->pRegions), in->regionCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8000,7 +8000,7 @@ static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoa
     out->shadingRate = in->shadingRate;
     out->sampleCount = in->sampleCount;
     out->sampleLocationCount = in->sampleLocationCount;
-    out->pSampleLocations = in->pSampleLocations;
+    out->pSampleLocations = (const VkCoarseSampleLocationNV *)UlongToPtr(in->pSampleLocations);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8028,7 +8028,7 @@ static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPe
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->marker = in->marker;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -8039,7 +8039,7 @@ static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->enable = in->enable;
     out->parameter = in->parameter;
@@ -8052,7 +8052,7 @@ static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->marker = in->marker;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -8063,7 +8063,7 @@ static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->binding = in->binding;
     out->stride = in->stride;
     out->inputRate = in->inputRate;
@@ -8095,7 +8095,7 @@ static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(c
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->location = in->location;
     out->binding = in->binding;
     out->format = in->format;
@@ -8127,7 +8127,7 @@ static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingR
     if (!in) return;

out->shadingRatePaletteEntryCount = in->shadingRatePaletteEntryCount;
-    out->pShadingRatePaletteEntries = in->pShadingRatePaletteEntries;
+    out->pShadingRatePaletteEntries = (const VkShadingRatePaletteEntryNV *)UlongToPtr(in->pShadingRatePaletteEntries);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8225,7 +8225,7 @@ static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(str
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->compactedSize = in->compactedSize;
     convert_VkAccelerationStructureInfoNV_win32_to_host(ctx, &in->info, &out->info);
 }
@@ -8246,7 +8246,7 @@ static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_co
     out->usage = in->usage;
     out->sharingMode = in->sharingMode;
     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
-    out->pQueueFamilyIndices = in->pQueueFamilyIndices;
+    out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -8310,7 +8310,7 @@ static inline void convert_VkBufferViewCreateInfo_win32_to_host(const VkBufferVi
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->buffer = in->buffer;
     out->format = in->format;
@@ -8325,7 +8325,7 @@ static inline void convert_VkCommandPoolCreateInfo_win32_to_host(const VkCommand
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->queueFamilyIndex = in->queueFamilyIndex;
 }
@@ -8402,9 +8402,9 @@ static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_
     if (!in) return;

out->mapEntryCount = in->mapEntryCount;
-    out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, in->pMapEntries, in->mapEntryCount);
+    out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount);
     out->dataSize = in->dataSize;
-    out->pData = in->pData;
+    out->pData = (const void *)UlongToPtr(in->pData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8541,8 +8541,8 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct
     out->flags = in->flags;
     out->stage = in->stage;
     out->module = in->module;
-    out->pName = in->pName;
-    out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, in->pSpecializationInfo, 1);
+    out->pName = (const char *)UlongToPtr(in->pName);
+    out->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in->pSpecializationInfo), 1);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -8556,7 +8556,7 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->codeSize = in_ext->codeSize;
-            out_ext->pCode = in_ext->pCode;
+            out_ext->pCode = (const uint32_t *)UlongToPtr(in_ext->pCode);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -8580,7 +8580,7 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct
             out_ext->pNext = NULL;
             out_ext->objectType = in_ext->objectType;
             out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle);
-            out_ext->pObjectName = in_ext->pObjectName;
+            out_ext->pObjectName = (const char *)UlongToPtr(in_ext->pObjectName);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -8603,7 +8603,7 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->identifierSize = in_ext->identifierSize;
-            out_ext->pIdentifier = in_ext->pIdentifier;
+            out_ext->pIdentifier = (const uint8_t *)UlongToPtr(in_ext->pIdentifier);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -8671,9 +8671,9 @@ static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conv
             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -8741,8 +8741,8 @@ static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkCom
             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header = (void *)out_ext;
             break;
         }
@@ -8809,9 +8809,9 @@ static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFun
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->module = in->module;
-    out->pName = in->pName;
+    out->pName = (const char *)UlongToPtr(in->pName);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8821,9 +8821,9 @@ static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(const VkCuModul
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->dataSize = in->dataSize;
-    out->pData = in->pData;
+    out->pData = (const void *)UlongToPtr(in->pData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8833,10 +8833,10 @@ static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->pfnCallback = in->pfnCallback;
-    out->pUserData = in->pUserData;
+    out->pUserData = (void *)UlongToPtr(in->pUserData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8846,12 +8846,12 @@ static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->messageSeverity = in->messageSeverity;
     out->messageType = in->messageType;
     out->pfnUserCallback = in->pfnUserCallback;
-    out->pUserData = in->pUserData;
+    out->pUserData = (void *)UlongToPtr(in->pUserData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8861,7 +8861,7 @@ static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const Vk
     if (!in) return;

out->descriptorTypeCount = in->descriptorTypeCount;
-    out->pDescriptorTypes = in->pDescriptorTypes;
+    out->pDescriptorTypes = (const VkDescriptorType *)UlongToPtr(in->pDescriptorTypes);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8896,7 +8896,7 @@ static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conve
     out->flags = in->flags;
     out->maxSets = in->maxSets;
     out->poolSizeCount = in->poolSizeCount;
-    out->pPoolSizes = in->pPoolSizes;
+    out->pPoolSizes = (const VkDescriptorPoolSize *)UlongToPtr(in->pPoolSizes);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -8920,7 +8920,7 @@ static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conve
             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
-            out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, in_ext->pMutableDescriptorTypeLists, in_ext->mutableDescriptorTypeListCount);
+            out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -8942,7 +8942,7 @@ static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDe
     out->descriptorType = in->descriptorType;
     out->descriptorCount = in->descriptorCount;
     out->stageFlags = in->stageFlags;
-    out->pImmutableSamplers = in->pImmutableSamplers;
+    out->pImmutableSamplers = (const VkSampler *)UlongToPtr(in->pImmutableSamplers);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -8976,7 +8976,7 @@ static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct
     out->pNext = NULL;
     out->flags = in->flags;
     out->bindingCount = in->bindingCount;
-    out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, in->pBindings, in->bindingCount);
+    out->pBindings = convert_VkDescriptorSetLayoutBinding_array_win32_to_host(ctx, (const VkDescriptorSetLayoutBinding32 *)UlongToPtr(in->pBindings), in->bindingCount);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -8989,7 +8989,7 @@ static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct
             out_ext->sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->bindingCount = in_ext->bindingCount;
-            out_ext->pBindingFlags = in_ext->pBindingFlags;
+            out_ext->pBindingFlags = (const VkDescriptorBindingFlags *)UlongToPtr(in_ext->pBindingFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -9001,7 +9001,7 @@ static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct
             out_ext->sType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->mutableDescriptorTypeListCount = in_ext->mutableDescriptorTypeListCount;
-            out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, in_ext->pMutableDescriptorTypeLists, in_ext->mutableDescriptorTypeListCount);
+            out_ext->pMutableDescriptorTypeLists = convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(ctx, (const VkMutableDescriptorTypeListEXT32 *)UlongToPtr(in_ext->pMutableDescriptorTypeLists), in_ext->mutableDescriptorTypeListCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -9052,10 +9052,10 @@ static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(st
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->descriptorUpdateEntryCount = in->descriptorUpdateEntryCount;
-    out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, in->pDescriptorUpdateEntries, in->descriptorUpdateEntryCount);
+    out->pDescriptorUpdateEntries = convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(ctx, (const VkDescriptorUpdateTemplateEntry32 *)UlongToPtr(in->pDescriptorUpdateEntries), in->descriptorUpdateEntryCount);
     out->templateType = in->templateType;
     out->descriptorSetLayout = in->descriptorSetLayout;
     out->pipelineBindPoint = in->pipelineBindPoint;
@@ -9083,7 +9083,7 @@ static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_ho
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count)
+static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count)
 {
     VkPhysicalDevice *out;
     unsigned int i;
@@ -9093,7 +9093,7 @@ static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_ho
     out = conversion_context_alloc(ctx, count * sizeof(*out));
     for (i = 0; i < count; i++)
     {
-        out[i] = wine_phys_dev_from_handle(in[i])->phys_dev;
+        out[i] = wine_phys_dev_from_handle(UlongToPtr(in[i]))->phys_dev;
     }

return out;
@@ -9113,7 +9113,7 @@ static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversi
     out->flags = in->flags;
     out->queueFamilyIndex = in->queueFamilyIndex;
     out->queueCount = in->queueCount;
-    out->pQueuePriorities = in->pQueuePriorities;
+    out->pQueuePriorities = (const float *)UlongToPtr(in->pQueuePriorities);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -10983,12 +10983,12 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
     out->pNext = NULL;
     out->flags = in->flags;
     out->queueCreateInfoCount = in->queueCreateInfoCount;
-    out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, in->pQueueCreateInfos, in->queueCreateInfoCount);
+    out->pQueueCreateInfos = convert_VkDeviceQueueCreateInfo_array_win32_to_host(ctx, (const VkDeviceQueueCreateInfo32 *)UlongToPtr(in->pQueueCreateInfos), in->queueCreateInfoCount);
     out->enabledLayerCount = in->enabledLayerCount;
-    out->ppEnabledLayerNames = in->ppEnabledLayerNames;
+    out->ppEnabledLayerNames = UlongToPtr(in->ppEnabledLayerNames);
     out->enabledExtensionCount = in->enabledExtensionCount;
-    out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
-    out->pEnabledFeatures = in->pEnabledFeatures;
+    out->ppEnabledExtensionNames = UlongToPtr(in->ppEnabledExtensionNames);
+    out->pEnabledFeatures = (const VkPhysicalDeviceFeatures *)UlongToPtr(in->pEnabledFeatures);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -11072,7 +11072,7 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co
             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->physicalDeviceCount = in_ext->physicalDeviceCount;
-            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount);
+            out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -12792,7 +12792,7 @@ static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateIn
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -12838,14 +12838,14 @@ static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->usage = in->usage;
     out->width = in->width;
     out->height = in->height;
     out->layerCount = in->layerCount;
     out->viewFormatCount = in->viewFormatCount;
-    out->pViewFormats = in->pViewFormats;
+    out->pViewFormats = (const VkFormat *)UlongToPtr(in->pViewFormats);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -12880,7 +12880,7 @@ static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversi
     out->flags = in->flags;
     out->renderPass = in->renderPass;
     out->attachmentCount = in->attachmentCount;
-    out->pAttachments = in->pAttachments;
+    out->pAttachments = (const VkImageView *)UlongToPtr(in->pAttachments);
     out->width = in->width;
     out->height = in->height;
     out->layers = in->layers;
@@ -12896,7 +12896,7 @@ static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversi
             out_ext->sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->attachmentImageInfoCount = in_ext->attachmentImageInfoCount;
-            out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, in_ext->pAttachmentImageInfos, in_ext->attachmentImageInfoCount);
+            out_ext->pAttachmentImageInfos = convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(ctx, (const VkFramebufferAttachmentImageInfo32 *)UlongToPtr(in_ext->pAttachmentImageInfos), in_ext->attachmentImageInfoCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -12957,9 +12957,9 @@ static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(st
     out->pNext = NULL;
     out->flags = in->flags;
     out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount;
-    out->pVertexBindingDescriptions = in->pVertexBindingDescriptions;
+    out->pVertexBindingDescriptions = (const VkVertexInputBindingDescription *)UlongToPtr(in->pVertexBindingDescriptions);
     out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount;
-    out->pVertexAttributeDescriptions = in->pVertexAttributeDescriptions;
+    out->pVertexAttributeDescriptions = (const VkVertexInputAttributeDescription *)UlongToPtr(in->pVertexAttributeDescriptions);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -12972,7 +12972,7 @@ static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(st
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount;
-            out_ext->pVertexBindingDivisors = in_ext->pVertexBindingDivisors;
+            out_ext->pVertexBindingDivisors = (const VkVertexInputBindingDivisorDescriptionEXT *)UlongToPtr(in_ext->pVertexBindingDivisors);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13077,11 +13077,11 @@ static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struc
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
-    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, in->pVertexInputState, 1);
-    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, in->pTessellationState, 1);
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
+    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
+    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -13127,7 +13127,7 @@ static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->topology = in->topology;
     out->primitiveRestartEnable = in->primitiveRestartEnable;
@@ -13164,9 +13164,9 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
     out->pNext = NULL;
     out->flags = in->flags;
     out->viewportCount = in->viewportCount;
-    out->pViewports = in->pViewports;
+    out->pViewports = (const VkViewport *)UlongToPtr(in->pViewports);
     out->scissorCount = in->scissorCount;
-    out->pScissors = in->pScissors;
+    out->pScissors = (const VkRect2D *)UlongToPtr(in->pScissors);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -13180,7 +13180,7 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_ext->pNext = NULL;
             out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable;
             out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportWScalings = in_ext->pViewportWScalings;
+            out_ext->pViewportWScalings = (const VkViewportWScalingNV *)UlongToPtr(in_ext->pViewportWScalings);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13193,7 +13193,7 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pViewportSwizzles = in_ext->pViewportSwizzles;
+            out_ext->pViewportSwizzles = (const VkViewportSwizzleNV *)UlongToPtr(in_ext->pViewportSwizzles);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13205,7 +13205,7 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
             out_ext->pNext = NULL;
             out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount;
-            out_ext->pExclusiveScissors = in_ext->pExclusiveScissors;
+            out_ext->pExclusiveScissors = (const VkRect2D *)UlongToPtr(in_ext->pExclusiveScissors);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13218,7 +13218,7 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_ext->pNext = NULL;
             out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable;
             out_ext->viewportCount = in_ext->viewportCount;
-            out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, in_ext->pShadingRatePalettes, in_ext->viewportCount);
+            out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13231,7 +13231,7 @@ static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struc
             out_ext->pNext = NULL;
             out_ext->sampleOrderType = in_ext->sampleOrderType;
             out_ext->customSampleOrderCount = in_ext->customSampleOrderCount;
-            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, in_ext->pCustomSampleOrders, in_ext->customSampleOrderCount);
+            out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13412,7 +13412,7 @@ static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(st
     out->rasterizationSamples = in->rasterizationSamples;
     out->sampleShadingEnable = in->sampleShadingEnable;
     out->minSampleShading = in->minSampleShading;
-    out->pSampleMask = in->pSampleMask;
+    out->pSampleMask = (const VkSampleMask *)UlongToPtr(in->pSampleMask);
     out->alphaToCoverageEnable = in->alphaToCoverageEnable;
     out->alphaToOneEnable = in->alphaToOneEnable;

@@ -13455,7 +13455,7 @@ static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(st
             out_ext->coverageModulationMode = in_ext->coverageModulationMode;
             out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable;
             out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount;
-            out_ext->pCoverageModulationTable = in_ext->pCoverageModulationTable;
+            out_ext->pCoverageModulationTable = (const float *)UlongToPtr(in_ext->pCoverageModulationTable);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13504,7 +13504,7 @@ static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(c
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->depthTestEnable = in->depthTestEnable;
     out->depthWriteEnable = in->depthWriteEnable;
@@ -13550,7 +13550,7 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str
     out->logicOpEnable = in->logicOpEnable;
     out->logicOp = in->logicOp;
     out->attachmentCount = in->attachmentCount;
-    out->pAttachments = in->pAttachments;
+    out->pAttachments = (const VkPipelineColorBlendAttachmentState *)UlongToPtr(in->pAttachments);
     memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float));

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
@@ -13577,7 +13577,7 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
             out_ext->attachmentCount = in_ext->attachmentCount;
-            out_ext->pColorWriteEnables = in_ext->pColorWriteEnables;
+            out_ext->pColorWriteEnables = (const VkBool32 *)UlongToPtr(in_ext->pColorWriteEnables);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13614,10 +13614,10 @@ static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->dynamicStateCount = in->dynamicStateCount;
-    out->pDynamicStates = in->pDynamicStates;
+    out->pDynamicStates = (const VkDynamicState *)UlongToPtr(in->pDynamicStates);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -13856,16 +13856,16 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
     out->pNext = NULL;
     out->flags = in->flags;
     out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
-    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, in->pVertexInputState, 1);
-    out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, in->pInputAssemblyState, 1);
-    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, in->pTessellationState, 1);
-    out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, in->pViewportState, 1);
-    out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, in->pRasterizationState, 1);
-    out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, in->pMultisampleState, 1);
-    out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, in->pDepthStencilState, 1);
-    out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, in->pColorBlendState, 1);
-    out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, in->pDynamicState, 1);
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
+    out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1);
+    out->pInputAssemblyState = convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineInputAssemblyStateCreateInfo32 *)UlongToPtr(in->pInputAssemblyState), 1);
+    out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1);
+    out->pViewportState = convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineViewportStateCreateInfo32 *)UlongToPtr(in->pViewportState), 1);
+    out->pRasterizationState = convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineRasterizationStateCreateInfo32 *)UlongToPtr(in->pRasterizationState), 1);
+    out->pMultisampleState = convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineMultisampleStateCreateInfo32 *)UlongToPtr(in->pMultisampleState), 1);
+    out->pDepthStencilState = convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDepthStencilStateCreateInfo32 *)UlongToPtr(in->pDepthStencilState), 1);
+    out->pColorBlendState = convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineColorBlendStateCreateInfo32 *)UlongToPtr(in->pColorBlendState), 1);
+    out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
     out->layout = in->layout;
     out->renderPass = in->renderPass;
     out->subpass = in->subpass;
@@ -13883,9 +13883,9 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
             out_ext->pNext = NULL;
             out_ext->groupCount = in_ext->groupCount;
-            out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, in_ext->pGroups, in_ext->groupCount);
+            out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkGraphicsShaderGroupCreateInfoNV32 *)UlongToPtr(in_ext->pGroups), in_ext->groupCount);
             out_ext->pipelineCount = in_ext->pipelineCount;
-            out_ext->pPipelines = in_ext->pPipelines;
+            out_ext->pPipelines = (const VkPipeline *)UlongToPtr(in_ext->pPipelines);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13899,7 +13899,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             out_ext->flags = in_ext->flags;
             out_ext->discardRectangleMode = in_ext->discardRectangleMode;
             out_ext->discardRectangleCount = in_ext->discardRectangleCount;
-            out_ext->pDiscardRectangles = in_ext->pDiscardRectangles;
+            out_ext->pDiscardRectangles = (const VkRect2D *)UlongToPtr(in_ext->pDiscardRectangles);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13921,9 +13921,9 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13946,7 +13946,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->libraryCount = in_ext->libraryCount;
-            out_ext->pLibraries = in_ext->pLibraries;
+            out_ext->pLibraries = (const VkPipeline *)UlongToPtr(in_ext->pLibraries);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -13984,7 +13984,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             out_ext->pNext = NULL;
             out_ext->viewMask = in_ext->viewMask;
             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats;
+            out_ext->pColorAttachmentFormats = (const VkFormat *)UlongToPtr(in_ext->pColorAttachmentFormats);
             out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat;
             out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat;
             out_header->pNext = (void *)out_ext;
@@ -13998,7 +13998,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con
             out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
             out_ext->pNext = NULL;
             out_ext->colorAttachmentCount = in_ext->colorAttachmentCount;
-            out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples;
+            out_ext->pColorAttachmentSamples = (const VkSampleCountFlagBits *)UlongToPtr(in_ext->pColorAttachmentSamples);
             out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -14067,8 +14067,8 @@ static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGr
             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header = (void *)out_ext;
             break;
         }
@@ -14150,7 +14150,7 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con
     out->usage = in->usage;
     out->sharingMode = in->sharingMode;
     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
-    out->pQueueFamilyIndices = in->pQueueFamilyIndices;
+    out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
     out->initialLayout = in->initialLayout;

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
@@ -14197,7 +14197,7 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con
             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->viewFormatCount = in_ext->viewFormatCount;
-            out_ext->pViewFormats = in_ext->pViewFormats;
+            out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14221,7 +14221,7 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
+            out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14337,7 +14337,7 @@ static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const V
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->tokenType = in->tokenType;
     out->stream = in->stream;
     out->offset = in->offset;
@@ -14349,8 +14349,8 @@ static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const V
     out->pushconstantSize = in->pushconstantSize;
     out->indirectStateFlags = in->indirectStateFlags;
     out->indexTypeCount = in->indexTypeCount;
-    out->pIndexTypes = in->pIndexTypes;
-    out->pIndexTypeValues = in->pIndexTypeValues;
+    out->pIndexTypes = (const VkIndexType *)UlongToPtr(in->pIndexTypes);
+    out->pIndexTypeValues = (const uint32_t *)UlongToPtr(in->pIndexTypeValues);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14378,13 +14378,13 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->pipelineBindPoint = in->pipelineBindPoint;
     out->tokenCount = in->tokenCount;
-    out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, in->pTokens, in->tokenCount);
+    out->pTokens = convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(ctx, (const VkIndirectCommandsLayoutTokenNV32 *)UlongToPtr(in->pTokens), in->tokenCount);
     out->streamCount = in->streamCount;
-    out->pStreamStrides = in->pStreamStrides;
+    out->pStreamStrides = (const uint32_t *)UlongToPtr(in->pStreamStrides);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14394,10 +14394,10 @@ static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationIn
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pApplicationName = in->pApplicationName;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pApplicationName = (const char *)UlongToPtr(in->pApplicationName);
     out->applicationVersion = in->applicationVersion;
-    out->pEngineName = in->pEngineName;
+    out->pEngineName = (const char *)UlongToPtr(in->pEngineName);
     out->engineVersion = in->engineVersion;
     out->apiVersion = in->apiVersion;
 }
@@ -14517,11 +14517,11 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, in->pApplicationInfo, 1);
+    out->pApplicationInfo = convert_VkApplicationInfo_array_win32_to_host(ctx, (const VkApplicationInfo32 *)UlongToPtr(in->pApplicationInfo), 1);
     out->enabledLayerCount = in->enabledLayerCount;
-    out->ppEnabledLayerNames = in->ppEnabledLayerNames;
+    out->ppEnabledLayerNames = UlongToPtr(in->ppEnabledLayerNames);
     out->enabledExtensionCount = in->enabledExtensionCount;
-    out->ppEnabledExtensionNames = in->ppEnabledExtensionNames;
+    out->ppEnabledExtensionNames = UlongToPtr(in->ppEnabledExtensionNames);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -14537,7 +14537,7 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->pfnCallback = in_ext->pfnCallback;
-            out_ext->pUserData = in_ext->pUserData;
+            out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14549,7 +14549,7 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT;
             out_ext->pNext = NULL;
             out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount;
-            out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks;
+            out_ext->pDisabledValidationChecks = (const VkValidationCheckEXT *)UlongToPtr(in_ext->pDisabledValidationChecks);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14561,9 +14561,9 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
             out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
             out_ext->pNext = NULL;
             out_ext->enabledValidationFeatureCount = in_ext->enabledValidationFeatureCount;
-            out_ext->pEnabledValidationFeatures = in_ext->pEnabledValidationFeatures;
+            out_ext->pEnabledValidationFeatures = (const VkValidationFeatureEnableEXT *)UlongToPtr(in_ext->pEnabledValidationFeatures);
             out_ext->disabledValidationFeatureCount = in_ext->disabledValidationFeatureCount;
-            out_ext->pDisabledValidationFeatures = in_ext->pDisabledValidationFeatures;
+            out_ext->pDisabledValidationFeatures = (const VkValidationFeatureDisableEXT *)UlongToPtr(in_ext->pDisabledValidationFeatures);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14578,7 +14578,7 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_
             out_ext->messageSeverity = in_ext->messageSeverity;
             out_ext->messageType = in_ext->messageType;
             out_ext->pfnUserCallback = in_ext->pfnUserCallback;
-            out_ext->pUserData = in_ext->pUserData;
+            out_ext->pUserData = (void *)UlongToPtr(in_ext->pUserData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14597,7 +14597,7 @@ static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicroma
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->createFlags = in->createFlags;
     out->buffer = in->buffer;
     out->offset = in->offset;
@@ -14639,7 +14639,7 @@ static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct
             out_ext->pNext = NULL;
             out_ext->id = in_ext->id;
             out_ext->size = in_ext->size;
-            out_ext->pPrivateData = in_ext->pPrivateData;
+            out_ext->pPrivateData = (const void *)UlongToPtr(in_ext->pPrivateData);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14658,10 +14658,10 @@ static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipel
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->initialDataSize = in->initialDataSize;
-    out->pInitialData = in->pInitialData;
+    out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14671,12 +14671,12 @@ static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipe
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->setLayoutCount = in->setLayoutCount;
-    out->pSetLayouts = in->pSetLayouts;
+    out->pSetLayouts = (const VkDescriptorSetLayout *)UlongToPtr(in->pSetLayouts);
     out->pushConstantRangeCount = in->pushConstantRangeCount;
-    out->pPushConstantRanges = in->pPushConstantRanges;
+    out->pPushConstantRanges = (const VkPushConstantRange *)UlongToPtr(in->pPushConstantRanges);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14686,7 +14686,7 @@ static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPri
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -14718,7 +14718,7 @@ static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion
             out_ext->pNext = NULL;
             out_ext->queueFamilyIndex = in_ext->queueFamilyIndex;
             out_ext->counterIndexCount = in_ext->counterIndexCount;
-            out_ext->pCounterIndices = in_ext->pCounterIndices;
+            out_ext->pCounterIndices = (const uint32_t *)UlongToPtr(in_ext->pCounterIndices);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14748,13 +14748,13 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(co
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->generalShader = in->generalShader;
     out->closestHitShader = in->closestHitShader;
     out->anyHitShader = in->anyHitShader;
     out->intersectionShader = in->intersectionShader;
-    out->pShaderGroupCaptureReplayHandle = in->pShaderGroupCaptureReplayHandle;
+    out->pShaderGroupCaptureReplayHandle = (const void *)UlongToPtr(in->pShaderGroupCaptureReplayHandle);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14782,9 +14782,9 @@ static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->libraryCount = in->libraryCount;
-    out->pLibraries = in->pLibraries;
+    out->pLibraries = (const VkPipeline *)UlongToPtr(in->pLibraries);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -14812,7 +14812,7 @@ static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_h
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->maxPipelineRayPayloadSize = in->maxPipelineRayPayloadSize;
     out->maxPipelineRayHitAttributeSize = in->maxPipelineRayHitAttributeSize;
 }
@@ -14870,13 +14870,13 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struc
     out->pNext = NULL;
     out->flags = in->flags;
     out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
     out->groupCount = in->groupCount;
-    out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, in->pGroups, in->groupCount);
+    out->pGroups = convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoKHR32 *)UlongToPtr(in->pGroups), in->groupCount);
     out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth;
-    out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, in->pLibraryInfo, 1);
-    out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, in->pLibraryInterface, 1);
-    out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, in->pDynamicState, 1);
+    out->pLibraryInfo = convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(ctx, (const VkPipelineLibraryCreateInfoKHR32 *)UlongToPtr(in->pLibraryInfo), 1);
+    out->pLibraryInterface = convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(ctx, (const VkRayTracingPipelineInterfaceCreateInfoKHR32 *)UlongToPtr(in->pLibraryInterface), 1);
+    out->pDynamicState = convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineDynamicStateCreateInfo32 *)UlongToPtr(in->pDynamicState), 1);
     out->layout = in->layout;
     out->basePipelineHandle = in->basePipelineHandle;
     out->basePipelineIndex = in->basePipelineIndex;
@@ -14891,9 +14891,9 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struc
             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -14938,8 +14938,8 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const
             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header = (void *)out_ext;
             break;
         }
@@ -15006,7 +15006,7 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->generalShader = in->generalShader;
     out->closestHitShader = in->closestHitShader;
@@ -15064,9 +15064,9 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct
     out->pNext = NULL;
     out->flags = in->flags;
     out->stageCount = in->stageCount;
-    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, in->pStages, in->stageCount);
+    out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount);
     out->groupCount = in->groupCount;
-    out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, in->pGroups, in->groupCount);
+    out->pGroups = convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(ctx, (const VkRayTracingShaderGroupCreateInfoNV32 *)UlongToPtr(in->pGroups), in->groupCount);
     out->maxRecursionDepth = in->maxRecursionDepth;
     out->layout = in->layout;
     out->basePipelineHandle = in->basePipelineHandle;
@@ -15082,9 +15082,9 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct
             const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
             out_ext->pNext = NULL;
-            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineCreationFeedback, 1);
+            out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1);
             out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount;
-            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, in_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15115,8 +15115,8 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const
             VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
             const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, out_ext->pPipelineCreationFeedback, 1);
-            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, out_ext->pPipelineStageCreationFeedbacks, in_ext->pipelineStageCreationFeedbackCount);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1);
+            convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount);
             out_header = (void *)out_ext;
             break;
         }
@@ -15185,13 +15185,13 @@ static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDes
     out->flags = in->flags;
     out->pipelineBindPoint = in->pipelineBindPoint;
     out->inputAttachmentCount = in->inputAttachmentCount;
-    out->pInputAttachments = in->pInputAttachments;
+    out->pInputAttachments = (const VkAttachmentReference *)UlongToPtr(in->pInputAttachments);
     out->colorAttachmentCount = in->colorAttachmentCount;
-    out->pColorAttachments = in->pColorAttachments;
-    out->pResolveAttachments = in->pResolveAttachments;
-    out->pDepthStencilAttachment = in->pDepthStencilAttachment;
+    out->pColorAttachments = (const VkAttachmentReference *)UlongToPtr(in->pColorAttachments);
+    out->pResolveAttachments = (const VkAttachmentReference *)UlongToPtr(in->pResolveAttachments);
+    out->pDepthStencilAttachment = (const VkAttachmentReference *)UlongToPtr(in->pDepthStencilAttachment);
     out->preserveAttachmentCount = in->preserveAttachmentCount;
-    out->pPreserveAttachments = in->pPreserveAttachments;
+    out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -15225,11 +15225,11 @@ static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversio
     out->pNext = NULL;
     out->flags = in->flags;
     out->attachmentCount = in->attachmentCount;
-    out->pAttachments = in->pAttachments;
+    out->pAttachments = (const VkAttachmentDescription *)UlongToPtr(in->pAttachments);
     out->subpassCount = in->subpassCount;
-    out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, in->pSubpasses, in->subpassCount);
+    out->pSubpasses = convert_VkSubpassDescription_array_win32_to_host(ctx, (const VkSubpassDescription32 *)UlongToPtr(in->pSubpasses), in->subpassCount);
     out->dependencyCount = in->dependencyCount;
-    out->pDependencies = in->pDependencies;
+    out->pDependencies = (const VkSubpassDependency *)UlongToPtr(in->pDependencies);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15242,11 +15242,11 @@ static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversio
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->subpassCount = in_ext->subpassCount;
-            out_ext->pViewMasks = in_ext->pViewMasks;
+            out_ext->pViewMasks = (const uint32_t *)UlongToPtr(in_ext->pViewMasks);
             out_ext->dependencyCount = in_ext->dependencyCount;
-            out_ext->pViewOffsets = in_ext->pViewOffsets;
+            out_ext->pViewOffsets = (const int32_t *)UlongToPtr(in_ext->pViewOffsets);
             out_ext->correlationMaskCount = in_ext->correlationMaskCount;
-            out_ext->pCorrelationMasks = in_ext->pCorrelationMasks;
+            out_ext->pCorrelationMasks = (const uint32_t *)UlongToPtr(in_ext->pCorrelationMasks);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15258,7 +15258,7 @@ static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversio
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->aspectReferenceCount = in_ext->aspectReferenceCount;
-            out_ext->pAspectReferences = in_ext->pAspectReferences;
+            out_ext->pAspectReferences = (const VkInputAttachmentAspectReference *)UlongToPtr(in_ext->pAspectReferences);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15413,13 +15413,13 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion
     out->pipelineBindPoint = in->pipelineBindPoint;
     out->viewMask = in->viewMask;
     out->inputAttachmentCount = in->inputAttachmentCount;
-    out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pInputAttachments, in->inputAttachmentCount);
+    out->pInputAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pInputAttachments), in->inputAttachmentCount);
     out->colorAttachmentCount = in->colorAttachmentCount;
-    out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pColorAttachments, in->colorAttachmentCount);
-    out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pResolveAttachments, in->colorAttachmentCount);
-    out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in->pDepthStencilAttachment, 1);
+    out->pColorAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pColorAttachments), in->colorAttachmentCount);
+    out->pResolveAttachments = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pResolveAttachments), in->colorAttachmentCount);
+    out->pDepthStencilAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in->pDepthStencilAttachment), 1);
     out->preserveAttachmentCount = in->preserveAttachmentCount;
-    out->pPreserveAttachments = in->pPreserveAttachments;
+    out->pPreserveAttachments = (const uint32_t *)UlongToPtr(in->pPreserveAttachments);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15433,7 +15433,7 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion
             out_ext->pNext = NULL;
             out_ext->depthResolveMode = in_ext->depthResolveMode;
             out_ext->stencilResolveMode = in_ext->stencilResolveMode;
-            out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in_ext->pDepthStencilResolveAttachment, 1);
+            out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15444,7 +15444,7 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion
             const VkFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkFragmentShadingRateAttachmentInfoKHR32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
             out_ext->pNext = NULL;
-            out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, in_ext->pFragmentShadingRateAttachment, 1);
+            out_ext->pFragmentShadingRateAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pFragmentShadingRateAttachment), 1);
             out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -15479,7 +15479,7 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion
             const VkRenderPassSubpassFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassSubpassFeedbackCreateInfoEXT32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->pSubpassFeedback = in_ext->pSubpassFeedback;
+            out_ext->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT *)UlongToPtr(in_ext->pSubpassFeedback);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15585,13 +15585,13 @@ static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversi
     out->pNext = NULL;
     out->flags = in->flags;
     out->attachmentCount = in->attachmentCount;
-    out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, in->pAttachments, in->attachmentCount);
+    out->pAttachments = convert_VkAttachmentDescription2_array_win32_to_host(ctx, (const VkAttachmentDescription232 *)UlongToPtr(in->pAttachments), in->attachmentCount);
     out->subpassCount = in->subpassCount;
-    out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, in->pSubpasses, in->subpassCount);
+    out->pSubpasses = convert_VkSubpassDescription2_array_win32_to_host(ctx, (const VkSubpassDescription232 *)UlongToPtr(in->pSubpasses), in->subpassCount);
     out->dependencyCount = in->dependencyCount;
-    out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, in->pDependencies, in->dependencyCount);
+    out->pDependencies = convert_VkSubpassDependency2_array_win32_to_host(ctx, (const VkSubpassDependency232 *)UlongToPtr(in->pDependencies), in->dependencyCount);
     out->correlatedViewMaskCount = in->correlatedViewMaskCount;
-    out->pCorrelatedViewMasks = in->pCorrelatedViewMasks;
+    out->pCorrelatedViewMasks = (const uint32_t *)UlongToPtr(in->pCorrelatedViewMasks);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15625,7 +15625,7 @@ static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversi
             const VkRenderPassCreationFeedbackCreateInfoEXT32 *in_ext = (const VkRenderPassCreationFeedbackCreateInfoEXT32 *)in_header;
             out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
             out_ext->pNext = NULL;
-            out_ext->pRenderPassFeedback = in_ext->pRenderPassFeedback;
+            out_ext->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT *)UlongToPtr(in_ext->pRenderPassFeedback);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15729,7 +15729,7 @@ static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->format = in->format;
     out->ycbcrModel = in->ycbcrModel;
     out->ycbcrRange = in->ycbcrRange;
@@ -15800,7 +15800,7 @@ static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct convers
     out->pNext = NULL;
     out->flags = in->flags;
     out->codeSize = in->codeSize;
-    out->pCode = in->pCode;
+    out->pCode = (const uint32_t *)UlongToPtr(in->pCode);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -15871,7 +15871,7 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct convers
     out->imageUsage = in->imageUsage;
     out->imageSharingMode = in->imageSharingMode;
     out->queueFamilyIndexCount = in->queueFamilyIndexCount;
-    out->pQueueFamilyIndices = in->pQueueFamilyIndices;
+    out->pQueueFamilyIndices = (const uint32_t *)UlongToPtr(in->pQueueFamilyIndices);
     out->preTransform = in->preTransform;
     out->compositeAlpha = in->compositeAlpha;
     out->presentMode = in->presentMode;
@@ -15900,7 +15900,7 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct convers
             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->viewFormatCount = in_ext->viewFormatCount;
-            out_ext->pViewFormats = in_ext->pViewFormats;
+            out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15924,7 +15924,7 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_host(struct convers
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
+            out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -15943,10 +15943,10 @@ static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->initialDataSize = in->initialDataSize;
-    out->pInitialData = in->pInitialData;
+    out->pInitialData = (const void *)UlongToPtr(in->pInitialData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -15956,10 +15956,10 @@ static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
-    out->hinstance = in->hinstance;
-    out->hwnd = in->hwnd;
+    out->hinstance = (HINSTANCE)UlongToPtr(in->hinstance);
+    out->hwnd = (HWND)UlongToPtr(in->hwnd);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -15982,10 +15982,10 @@ static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->objectType = in->objectType;
     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
-    out->pObjectName = in->pObjectName;
+    out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16010,17 +16010,17 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkD
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->objectType = in->objectType;
     out->object = wine_vk_unwrap_handle(in->objectType, in->object);
     out->tagName = in->tagName;
     out->tagSize = in->tagSize;
-    out->pTag = in->pTag;
+    out->pTag = (const void *)UlongToPtr(in->pTag);
 }
 #endif /* USE_STRUCT_CONVERSION */

#if defined(USE_STRUCT_CONVERSION)
-static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, VkPhysicalDevice *out, uint32_t count)
+static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count)
 {
     unsigned int i;

@@ -16028,7 +16028,7 @@ static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const

for (i = 0; i < count; i++)
     {
-        out[i] = in[i];
+        out[i] = PtrToUlong(in[i]);
     }
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16039,7 +16039,7 @@ static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_ho
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16092,7 +16092,7 @@ static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerform
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16146,7 +16146,7 @@ static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16200,7 +16200,7 @@ static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemor
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->memory = in->memory;
     out->offset = in->offset;
     out->size = in->size;
@@ -16231,7 +16231,7 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_hos
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->accelerationStructureSize = in->accelerationStructureSize;
     out->updateScratchSize = in->updateScratchSize;
     out->buildScratchSize = in->buildScratchSize;
@@ -16255,7 +16255,7 @@ static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->accelerationStructure = in->accelerationStructure;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16266,7 +16266,7 @@ static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->type = in->type;
     out->accelerationStructure = in->accelerationStructure;
 }
@@ -16289,7 +16289,7 @@ static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemory
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16308,7 +16308,7 @@ static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBuffe
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->buffer = in->buffer;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16319,7 +16319,7 @@ static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const V
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->buffer = in->buffer;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16393,7 +16393,7 @@ static inline void convert_VkCalibratedTimestampInfoEXT_win32_to_host(const VkCa
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->timeDomain = in->timeDomain;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16422,7 +16422,7 @@ static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(co
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->descriptorSetLayout = in->descriptorSetLayout;
     out->binding = in->binding;
 }
@@ -16434,7 +16434,7 @@ static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_ho
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->descriptorOffset = in->descriptorOffset;
     out->descriptorSize = in->descriptorSize;
 }
@@ -16518,8 +16518,8 @@ static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(c
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pVersionData = in->pVersionData;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16547,8 +16547,8 @@ static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pCreateInfo = convert_VkBufferCreateInfo_array_win32_to_host(ctx, (const VkBufferCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16558,7 +16558,7 @@ static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFa
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->addressInfoCount = in->addressInfoCount;
     out->vendorInfoCount = in->vendorInfoCount;
     out->vendorBinarySize = in->vendorBinarySize;
@@ -16690,11 +16690,11 @@ static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, in->pAddressInfos, 1);
-    out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, in->pVendorInfos, 1);
-    out->pVendorBinaryData = in->pVendorBinaryData;
+    out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1);
+    out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1);
+    out->pVendorBinaryData = (void *)UlongToPtr(in->pVendorBinaryData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16704,9 +16704,9 @@ static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaul
     if (!in) return;

memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, out->pAddressInfos, 1);
-    convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, out->pVendorInfos, 1);
-    out->pVendorBinaryData = in->pVendorBinaryData;
+    convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(in->pAddressInfos, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(out->pAddressInfos), 1);
+    convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(in->pVendorInfos, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(out->pVendorInfos), 1);
+    out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16716,7 +16716,7 @@ static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16754,8 +16754,8 @@ static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, in->pCreateInfo, 1);
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1);
     out->planeAspect = in->planeAspect;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16779,7 +16779,7 @@ static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16830,7 +16830,7 @@ static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->memory = in->memory;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -16841,8 +16841,8 @@ static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicrom
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pVersionData = in->pVersionData;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pVersionData = (const uint8_t *)UlongToPtr(in->pVersionData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -16852,7 +16852,7 @@ static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueI
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->queueFamilyIndex = in->queueFamilyIndex;
     out->queueIndex = in->queueIndex;
@@ -16865,7 +16865,7 @@ static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTileProper
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->tileSize = in->tileSize;
     out->apronSize = in->apronSize;
     out->origin = in->origin;
@@ -16921,7 +16921,7 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->pipelineBindPoint = in->pipelineBindPoint;
     out->pipeline = in->pipeline;
     out->indirectCommandsLayout = in->indirectCommandsLayout;
@@ -16984,7 +16984,7 @@ static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(co
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->image = in->image;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -17008,7 +17008,7 @@ static inline void convert_VkImageSubresource2EXT_win32_to_host(const VkImageSub
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
     out->imageSubresource = in->imageSubresource;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -17082,7 +17082,7 @@ static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const V
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -17102,7 +17102,7 @@ static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageV
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->imageView = in->imageView;
     out->descriptorType = in->descriptorType;
     out->sampler = in->sampler;
@@ -17115,7 +17115,7 @@ static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -17134,7 +17134,7 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMic
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->micromapSize = in->micromapSize;
     out->buildScratchSize = in->buildScratchSize;
     out->discardable = in->discardable;
@@ -17178,7 +17178,7 @@ static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const V
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -17236,7 +17236,7 @@ static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(cons
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->usage = in->usage;
     out->handleType = in->handleType;
@@ -17249,7 +17249,7 @@ static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExte
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -17268,7 +17268,7 @@ static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->handleType = in->handleType;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -17279,7 +17279,7 @@ static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExter
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -17336,7 +17336,7 @@ static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkE
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -20662,7 +20662,7 @@ static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -20759,7 +20759,7 @@ static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct
             out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
             out_ext->pNext = NULL;
             out_ext->viewFormatCount = in_ext->viewFormatCount;
-            out_ext->pViewFormats = in_ext->pViewFormats;
+            out_ext->pViewFormats = (const VkFormat *)UlongToPtr(in_ext->pViewFormats);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -20794,7 +20794,7 @@ static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct
             out_ext->pNext = NULL;
             out_ext->flags = in_ext->flags;
             out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount;
-            out_ext->pFixedRateFlags = in_ext->pFixedRateFlags;
+            out_ext->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT *)UlongToPtr(in_ext->pFixedRateFlags);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -21059,7 +21059,7 @@ static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMult
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -21078,7 +21078,7 @@ static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->usage = in->usage;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -21089,7 +21089,7 @@ static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(co
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -22834,10 +22834,10 @@ static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->queueFamilyIndex = in->queueFamilyIndex;
     out->counterIndexCount = in->counterIndexCount;
-    out->pCounterIndices = in->pCounterIndices;
+    out->pCounterIndices = (const uint32_t *)UlongToPtr(in->pCounterIndices);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -22981,7 +22981,7 @@ static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->format = in->format;
     out->type = in->type;
     out->samples = in->samples;
@@ -22996,7 +22996,7 @@ static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23047,7 +23047,7 @@ static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23101,7 +23101,7 @@ static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_ho
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->surface = in->surface;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -23185,7 +23185,7 @@ static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(const V
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->surface = wine_surface_from_handle(in->surface)->driver_surface;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -23291,7 +23291,7 @@ static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const Vk
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23346,7 +23346,7 @@ static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPip
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->pipeline = in->pipeline;
     out->executableIndex = in->executableIndex;
 }
@@ -23358,7 +23358,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_t
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23371,7 +23371,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to
     memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
     out->isText = in->isText;
     out->dataSize = in->dataSize;
-    out->pData = in->pData;
+    out->pData = PtrToUlong(in->pData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23413,7 +23413,7 @@ static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoK
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->pipeline = in->pipeline;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -23424,7 +23424,7 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23478,7 +23478,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23532,7 +23532,7 @@ static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoE
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->pipeline = in->pipeline;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -23543,7 +23543,7 @@ static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointD
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23553,7 +23553,7 @@ static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointD
     if (!in) return;

out->stage = in->stage;
-    out->pCheckpointMarker = in->pCheckpointMarker;
+    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23595,7 +23595,7 @@ static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDa
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23605,7 +23605,7 @@ static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDa
     if (!in) return;

out->stage = in->stage;
-    out->pCheckpointMarker = in->pCheckpointMarker;
+    out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23647,7 +23647,7 @@ static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkSha
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (void *)UlongToPtr(in->pNext);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23667,8 +23667,8 @@ static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(con
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->pUserData = in->pUserData;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->pUserData = (void *)UlongToPtr(in->pUserData);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23710,7 +23710,7 @@ static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct con

out->buffer = in->buffer;
     out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23739,7 +23739,7 @@ static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struc

out->image = in->image;
     out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+    out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23800,7 +23800,7 @@ static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conv

out->image = in->image;
     out->bindCount = in->bindCount;
-    out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, in->pBinds, in->bindCount);
+    out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23833,15 +23833,15 @@ static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_cont
     out->sType = in->sType;
     out->pNext = NULL;
     out->waitSemaphoreCount = in->waitSemaphoreCount;
-    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
     out->bufferBindCount = in->bufferBindCount;
-    out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, in->pBufferBinds, in->bufferBindCount);
+    out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseBufferMemoryBindInfo32 *)UlongToPtr(in->pBufferBinds), in->bufferBindCount);
     out->imageOpaqueBindCount = in->imageOpaqueBindCount;
-    out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount);
+    out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageOpaqueMemoryBindInfo32 *)UlongToPtr(in->pImageOpaqueBinds), in->imageOpaqueBindCount);
     out->imageBindCount = in->imageBindCount;
-    out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, in->pImageBinds, in->imageBindCount);
+    out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win32_to_host(ctx, (const VkSparseImageMemoryBindInfo32 *)UlongToPtr(in->pImageBinds), in->imageBindCount);
     out->signalSemaphoreCount = in->signalSemaphoreCount;
-    out->pSignalSemaphores = in->pSignalSemaphores;
+    out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -23866,9 +23866,9 @@ static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_cont
             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
             out_ext->pNext = NULL;
             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
-            out_ext->pWaitSemaphoreValues = in_ext->pWaitSemaphoreValues;
+            out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
-            out_ext->pSignalSemaphoreValues = in_ext->pSignalSemaphoreValues;
+            out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23905,7 +23905,7 @@ static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegio
     if (!in) return;

out->rectangleCount = in->rectangleCount;
-    out->pRectangles = in->pRectangles;
+    out->pRectangles = (const VkRectLayerKHR *)UlongToPtr(in->pRectangles);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -23938,11 +23938,11 @@ static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_cont
     out->sType = in->sType;
     out->pNext = NULL;
     out->waitSemaphoreCount = in->waitSemaphoreCount;
-    out->pWaitSemaphores = in->pWaitSemaphores;
+    out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
     out->swapchainCount = in->swapchainCount;
-    out->pSwapchains = in->pSwapchains;
-    out->pImageIndices = in->pImageIndices;
-    out->pResults = in->pResults;
+    out->pSwapchains = (const VkSwapchainKHR *)UlongToPtr(in->pSwapchains);
+    out->pImageIndices = (const uint32_t *)UlongToPtr(in->pImageIndices);
+    out->pResults = (VkResult *)UlongToPtr(in->pResults);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -23955,7 +23955,7 @@ static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_cont
             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
             out_ext->pNext = NULL;
             out_ext->swapchainCount = in_ext->swapchainCount;
-            out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, in_ext->pRegions, in_ext->swapchainCount);
+            out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -23967,7 +23967,7 @@ static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_cont
             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
             out_ext->pNext = NULL;
             out_ext->swapchainCount = in_ext->swapchainCount;
-            out_ext->pDeviceMasks = in_ext->pDeviceMasks;
+            out_ext->pDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pDeviceMasks);
             out_ext->mode = in_ext->mode;
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
@@ -23980,7 +23980,7 @@ static inline void convert_VkPresentInfoKHR_win32_to_host(struct conversion_cont
             out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR;
             out_ext->pNext = NULL;
             out_ext->swapchainCount = in_ext->swapchainCount;
-            out_ext->pPresentIds = in_ext->pPresentIds;
+            out_ext->pPresentIds = (const uint64_t *)UlongToPtr(in_ext->pPresentIds);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24021,12 +24021,12 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context
     out->sType = in->sType;
     out->pNext = NULL;
     out->waitSemaphoreCount = in->waitSemaphoreCount;
-    out->pWaitSemaphores = in->pWaitSemaphores;
-    out->pWaitDstStageMask = in->pWaitDstStageMask;
+    out->pWaitSemaphores = (const VkSemaphore *)UlongToPtr(in->pWaitSemaphores);
+    out->pWaitDstStageMask = (const VkPipelineStageFlags *)UlongToPtr(in->pWaitDstStageMask);
     out->commandBufferCount = in->commandBufferCount;
-    out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, in->pCommandBuffers, in->commandBufferCount);
+    out->pCommandBuffers = convert_VkCommandBuffer_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in->pCommandBuffers), in->commandBufferCount);
     out->signalSemaphoreCount = in->signalSemaphoreCount;
-    out->pSignalSemaphores = in->pSignalSemaphores;
+    out->pSignalSemaphores = (const VkSemaphore *)UlongToPtr(in->pSignalSemaphores);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -24039,11 +24039,11 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context
             out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
             out_ext->pNext = NULL;
             out_ext->waitSemaphoreCount = in_ext->waitSemaphoreCount;
-            out_ext->pWaitSemaphoreDeviceIndices = in_ext->pWaitSemaphoreDeviceIndices;
+            out_ext->pWaitSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pWaitSemaphoreDeviceIndices);
             out_ext->commandBufferCount = in_ext->commandBufferCount;
-            out_ext->pCommandBufferDeviceMasks = in_ext->pCommandBufferDeviceMasks;
+            out_ext->pCommandBufferDeviceMasks = (const uint32_t *)UlongToPtr(in_ext->pCommandBufferDeviceMasks);
             out_ext->signalSemaphoreCount = in_ext->signalSemaphoreCount;
-            out_ext->pSignalSemaphoreDeviceIndices = in_ext->pSignalSemaphoreDeviceIndices;
+            out_ext->pSignalSemaphoreDeviceIndices = (const uint32_t *)UlongToPtr(in_ext->pSignalSemaphoreDeviceIndices);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24066,9 +24066,9 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context
             out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
             out_ext->pNext = NULL;
             out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount;
-            out_ext->pWaitSemaphoreValues = in_ext->pWaitSemaphoreValues;
+            out_ext->pWaitSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pWaitSemaphoreValues);
             out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount;
-            out_ext->pSignalSemaphoreValues = in_ext->pSignalSemaphoreValues;
+            out_ext->pSignalSemaphoreValues = (const uint64_t *)UlongToPtr(in_ext->pSignalSemaphoreValues);
             out_header->pNext = (void *)out_ext;
             out_header = (void *)out_ext;
             break;
@@ -24134,7 +24134,7 @@ static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphore
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->semaphore = in->semaphore;
     out->value = in->value;
     out->stageMask = in->stageMask;
@@ -24178,8 +24178,8 @@ static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(const VkComma
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
-    out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->command_buffer;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
+    out->commandBuffer = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(in->commandBuffer))->command_buffer;
     out->deviceMask = in->deviceMask;
 }
 #endif /* USE_STRUCT_CONVERSION */
@@ -24249,11 +24249,11 @@ static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context
     out->pNext = NULL;
     out->flags = in->flags;
     out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount;
-    out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pWaitSemaphoreInfos, in->waitSemaphoreInfoCount);
+    out->pWaitSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pWaitSemaphoreInfos), in->waitSemaphoreInfoCount);
     out->commandBufferInfoCount = in->commandBufferInfoCount;
-    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount);
+    out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win32_to_host(ctx, (const VkCommandBufferSubmitInfo32 *)UlongToPtr(in->pCommandBufferInfos), in->commandBufferInfoCount);
     out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount;
-    out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, in->pSignalSemaphoreInfos, in->signalSemaphoreInfoCount);
+    out->pSignalSemaphoreInfos = convert_VkSemaphoreSubmitInfo_array_win32_to_host(ctx, (const VkSemaphoreSubmitInfo32 *)UlongToPtr(in->pSignalSemaphoreInfos), in->signalSemaphoreInfoCount);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -24333,10 +24333,10 @@ static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkD
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->objectType = in->objectType;
     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
-    out->pObjectName = in->pObjectName;
+    out->pObjectName = (const char *)UlongToPtr(in->pObjectName);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -24361,12 +24361,12 @@ static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDe
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->objectType = in->objectType;
     out->objectHandle = wine_vk_unwrap_handle(in->objectType, in->objectHandle);
     out->tagName = in->tagName;
     out->tagSize = in->tagSize;
-    out->pTag = in->pTag;
+    out->pTag = (const void *)UlongToPtr(in->pTag);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -24376,7 +24376,7 @@ static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphore
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->semaphore = in->semaphore;
     out->value = in->value;
 }
@@ -24467,15 +24467,15 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st
     out->sType = in->sType;
     out->pNext = NULL;
     out->flags = in->flags;
-    out->pMessageIdName = in->pMessageIdName;
+    out->pMessageIdName = (const char *)UlongToPtr(in->pMessageIdName);
     out->messageIdNumber = in->messageIdNumber;
-    out->pMessage = in->pMessage;
+    out->pMessage = (const char *)UlongToPtr(in->pMessage);
     out->queueLabelCount = in->queueLabelCount;
-    out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, in->pQueueLabels, in->queueLabelCount);
+    out->pQueueLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pQueueLabels), in->queueLabelCount);
     out->cmdBufLabelCount = in->cmdBufLabelCount;
-    out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, in->pCmdBufLabels, in->cmdBufLabelCount);
+    out->pCmdBufLabels = convert_VkDebugUtilsLabelEXT_array_win32_to_host(ctx, (const VkDebugUtilsLabelEXT32 *)UlongToPtr(in->pCmdBufLabels), in->cmdBufLabelCount);
     out->objectCount = in->objectCount;
-    out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, in->pObjects, in->objectCount);
+    out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(ctx, (const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(in->pObjects), in->objectCount);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext))
     {
@@ -24509,7 +24509,7 @@ static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescrip
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->srcSet = in->srcSet;
     out->srcBinding = in->srcBinding;
     out->srcArrayElement = in->srcArrayElement;
@@ -24544,11 +24544,11 @@ static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWa
     if (!in) return;

out->sType = in->sType;
-    out->pNext = in->pNext;
+    out->pNext = (const void *)UlongToPtr(in->pNext);
     out->flags = in->flags;
     out->semaphoreCount = in->semaphoreCount;
-    out->pSemaphores = in->pSemaphores;
-    out->pValues = in->pValues;
+    out->pSemaphores = (const VkSemaphore *)UlongToPtr(in->pSemaphores);
+    out->pValues = (const uint64_t *)UlongToPtr(in->pValues);
 }
 #endif /* USE_STRUCT_CONVERSION */

@@ -24570,17 +24570,17 @@ static NTSTATUS thunk32_vkAcquireNextImage2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAcquireNextImageInfoKHR32 *pAcquireInfo;
-        uint32_t *pImageIndex;
+        PTR32 device;
+        PTR32 pAcquireInfo;
+        PTR32 pImageIndex;
         VkResult result;
     } *params = args;
     VkAcquireNextImageInfoKHR pAcquireInfo_host;

-    TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pImageIndex);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pImageIndex);

-    convert_VkAcquireNextImageInfoKHR_win32_to_host(params->pAcquireInfo, &pAcquireInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pImageIndex);
+    convert_VkAcquireNextImageInfoKHR_win32_to_host((const VkAcquireNextImageInfoKHR32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireNextImage2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAcquireInfo_host, (uint32_t *)UlongToPtr(params->pImageIndex));
     return STATUS_SUCCESS;
 }

@@ -24604,18 +24604,18 @@ static NTSTATUS thunk32_vkAcquireNextImageKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
         uint64_t DECLSPEC_ALIGN(8) timeout;
         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
         VkFence DECLSPEC_ALIGN(8) fence;
-        uint32_t *pImageIndex;
+        PTR32 pImageIndex;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->timeout), wine_dbgstr_longlong(params->semaphore), wine_dbgstr_longlong(params->fence), params->pImageIndex);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->timeout, params->semaphore, params->fence, params->pImageIndex);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireNextImageKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, params->timeout, params->semaphore, params->fence, (uint32_t *)UlongToPtr(params->pImageIndex));
     return STATUS_SUCCESS;
 }

@@ -24639,17 +24639,17 @@ static NTSTATUS thunk32_vkAcquirePerformanceConfigurationINTEL(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPerformanceConfigurationAcquireInfoINTEL32 *pAcquireInfo;
-        VkPerformanceConfigurationINTEL *pConfiguration;
+        PTR32 device;
+        PTR32 pAcquireInfo;
+        PTR32 pConfiguration;
         VkResult result;
     } *params = args;
     VkPerformanceConfigurationAcquireInfoINTEL pAcquireInfo_host;

-    TRACE("%p, %p, %p\n", params->device, params->pAcquireInfo, params->pConfiguration);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pAcquireInfo, params->pConfiguration);

-    convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(params->pAcquireInfo, &pAcquireInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, &pAcquireInfo_host, params->pConfiguration);
+    convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host((const VkPerformanceConfigurationAcquireInfoINTEL32 *)UlongToPtr(params->pAcquireInfo), &pAcquireInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquirePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAcquireInfo_host, (VkPerformanceConfigurationINTEL *)UlongToPtr(params->pConfiguration));
     return STATUS_SUCCESS;
 }

@@ -24673,16 +24673,16 @@ static NTSTATUS thunk32_vkAcquireProfilingLockKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAcquireProfilingLockInfoKHR32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkAcquireProfilingLockInfoKHR pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkAcquireProfilingLockInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkAcquireProfilingLockInfoKHR_win32_to_host((const VkAcquireProfilingLockInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAcquireProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -24706,21 +24706,21 @@ static NTSTATUS thunk32_vkAllocateCommandBuffers(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkCommandBufferAllocateInfo32 *pAllocateInfo;
-        VkCommandBuffer *pCommandBuffers;
+        PTR32 device;
+        PTR32 pAllocateInfo;
+        PTR32 pCommandBuffers;
         VkResult result;
     } *params = args;
     VkCommandBufferAllocateInfo pAllocateInfo_host;
     VkCommandBuffer *pCommandBuffers_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pCommandBuffers);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pCommandBuffers);

init_conversion_context(&ctx);
-    convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(params->pAllocateInfo, &pAllocateInfo_host);
-    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, params->pCommandBuffers, params->pAllocateInfo->commandBufferCount);
-    params->result = wine_vkAllocateCommandBuffers(params->device, &pAllocateInfo_host, pCommandBuffers_host);
+    convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
+    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (PTR32 *)UlongToPtr(params->pCommandBuffers), ((const VkCommandBufferAllocateInfo32 *)UlongToPtr(params->pAllocateInfo))->commandBufferCount);
+    params->result = wine_vkAllocateCommandBuffers((VkDevice)UlongToPtr(params->device), &pAllocateInfo_host, pCommandBuffers_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24745,19 +24745,19 @@ static NTSTATUS thunk32_vkAllocateDescriptorSets(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorSetAllocateInfo32 *pAllocateInfo;
-        VkDescriptorSet *pDescriptorSets;
+        PTR32 device;
+        PTR32 pAllocateInfo;
+        PTR32 pDescriptorSets;
         VkResult result;
     } *params = args;
     VkDescriptorSetAllocateInfo pAllocateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pAllocateInfo, params->pDescriptorSets);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pDescriptorSets);

init_conversion_context(&ctx);
-    convert_VkDescriptorSetAllocateInfo_win32_to_host(&ctx, params->pAllocateInfo, &pAllocateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, params->pDescriptorSets);
+    convert_VkDescriptorSetAllocateInfo_win32_to_host(&ctx, (const VkDescriptorSetAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAllocateDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAllocateInfo_host, (VkDescriptorSet *)UlongToPtr(params->pDescriptorSets));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24782,20 +24782,20 @@ static NTSTATUS thunk32_vkAllocateMemory(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkMemoryAllocateInfo32 *pAllocateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDeviceMemory *pMemory;
+        PTR32 device;
+        PTR32 pAllocateInfo;
+        PTR32 pAllocator;
+        PTR32 pMemory;
         VkResult result;
     } *params = args;
     VkMemoryAllocateInfo pAllocateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pAllocateInfo, params->pAllocator, params->pMemory);

init_conversion_context(&ctx);
-    convert_VkMemoryAllocateInfo_win32_to_host(&ctx, params->pAllocateInfo, &pAllocateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkAllocateMemory(wine_device_from_handle(params->device)->device, &pAllocateInfo_host, NULL, params->pMemory);
+    convert_VkMemoryAllocateInfo_win32_to_host(&ctx, (const VkMemoryAllocateInfo32 *)UlongToPtr(params->pAllocateInfo), &pAllocateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkAllocateMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pAllocateInfo_host, NULL, (VkDeviceMemory *)UlongToPtr(params->pMemory));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24820,18 +24820,18 @@ static NTSTATUS thunk32_vkBeginCommandBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCommandBufferBeginInfo32 *pBeginInfo;
+        PTR32 commandBuffer;
+        PTR32 pBeginInfo;
         VkResult result;
     } *params = args;
     VkCommandBufferBeginInfo pBeginInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pBeginInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pBeginInfo);

init_conversion_context(&ctx);
-    convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, params->pBeginInfo, &pBeginInfo_host);
-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBeginInfo_host);
+    convert_VkCommandBufferBeginInfo_win32_to_host(&ctx, (const VkCommandBufferBeginInfo32 *)UlongToPtr(params->pBeginInfo), &pBeginInfo_host);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkBeginCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBeginInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24856,19 +24856,19 @@ static NTSTATUS thunk32_vkBindAccelerationStructureMemoryNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t bindInfoCount;
-        const VkBindAccelerationStructureMemoryInfoNV32 *pBindInfos;
+        PTR32 pBindInfos;
         VkResult result;
     } *params = args;
     const VkBindAccelerationStructureMemoryInfoNV *pBindInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
+    TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);

init_conversion_context(&ctx);
-    pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    pBindInfos_host = convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(&ctx, (const VkBindAccelerationStructureMemoryInfoNV32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindAccelerationStructureMemoryNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24893,16 +24893,16 @@ static NTSTATUS thunk32_vkBindBufferMemory(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
+    TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory(wine_device_from_handle(params->device)->device, params->buffer, params->memory, params->memoryOffset);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, params->memory, params->memoryOffset);
     return STATUS_SUCCESS;
 }

@@ -24926,19 +24926,19 @@ static NTSTATUS thunk32_vkBindBufferMemory2(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t bindInfoCount;
-        const VkBindBufferMemoryInfo32 *pBindInfos;
+        PTR32 pBindInfos;
         VkResult result;
     } *params = args;
     const VkBindBufferMemoryInfo *pBindInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
+    TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);

init_conversion_context(&ctx);
-    pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -24963,19 +24963,19 @@ static NTSTATUS thunk32_vkBindBufferMemory2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t bindInfoCount;
-        const VkBindBufferMemoryInfo32 *pBindInfos;
+        PTR32 pBindInfos;
         VkResult result;
     } *params = args;
     const VkBindBufferMemoryInfo *pBindInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
+    TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);

init_conversion_context(&ctx);
-    pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    pBindInfos_host = convert_VkBindBufferMemoryInfo_array_win32_to_host(&ctx, (const VkBindBufferMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindBufferMemory2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25000,16 +25000,16 @@ static NTSTATUS thunk32_vkBindImageMemory(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
         VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));
+    TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->image), wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->memoryOffset));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory(wine_device_from_handle(params->device)->device, params->image, params->memory, params->memoryOffset);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, params->memory, params->memoryOffset);
     return STATUS_SUCCESS;
 }

@@ -25033,19 +25033,19 @@ static NTSTATUS thunk32_vkBindImageMemory2(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t bindInfoCount;
-        const VkBindImageMemoryInfo32 *pBindInfos;
+        PTR32 pBindInfos;
         VkResult result;
     } *params = args;
     const VkBindImageMemoryInfo *pBindInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
+    TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);

init_conversion_context(&ctx);
-    pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25070,19 +25070,19 @@ static NTSTATUS thunk32_vkBindImageMemory2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t bindInfoCount;
-        const VkBindImageMemoryInfo32 *pBindInfos;
+        PTR32 pBindInfos;
         VkResult result;
     } *params = args;
     const VkBindImageMemoryInfo *pBindInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->bindInfoCount, params->pBindInfos);
+    TRACE("%#x, %u, %#x\n", params->device, params->bindInfoCount, params->pBindInfos);

init_conversion_context(&ctx);
-    pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, params->pBindInfos, params->bindInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle(params->device)->device, params->bindInfoCount, pBindInfos_host);
+    pBindInfos_host = convert_VkBindImageMemoryInfo_array_win32_to_host(&ctx, (const VkBindImageMemoryInfo32 *)UlongToPtr(params->pBindInfos), params->bindInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindImageMemory2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bindInfoCount, pBindInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25107,7 +25107,7 @@ static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
         VkOpticalFlowSessionBindingPointNV bindingPoint;
         VkImageView DECLSPEC_ALIGN(8) view;
@@ -25115,9 +25115,9 @@ static NTSTATUS thunk32_vkBindOpticalFlowSessionImageNV(void *args)
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);
+    TRACE("%#x, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->bindingPoint, wine_dbgstr_longlong(params->view), params->layout);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle(params->device)->device, params->session, params->bindingPoint, params->view, params->layout);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBindOpticalFlowSessionImageNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, params->bindingPoint, params->view, params->layout);
     return STATUS_SUCCESS;
 }

@@ -25141,21 +25141,21 @@ static NTSTATUS thunk32_vkBuildAccelerationStructuresKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
         uint32_t infoCount;
-        const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
-        const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
+        PTR32 pInfos;
+        PTR32 ppBuildRangeInfos;
         VkResult result;
     } *params = args;
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);
+    TRACE("%#x, 0x%s, %u, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos, params->ppBuildRangeInfos);

init_conversion_context(&ctx);
-    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
+    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildAccelerationStructuresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25180,20 +25180,20 @@ static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
         uint32_t infoCount;
-        const VkMicromapBuildInfoEXT32 *pInfos;
+        PTR32 pInfos;
         VkResult result;
     } *params = args;
     const VkMicromapBuildInfoEXT *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->infoCount, params->pInfos);

init_conversion_context(&ctx);
-    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, params->infoCount, pInfos_host);
+    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkBuildMicromapsEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->infoCount, pInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25218,15 +25218,15 @@ static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkConditionalRenderingBeginInfoEXT32 *pConditionalRenderingBegin;
+        PTR32 commandBuffer;
+        PTR32 pConditionalRenderingBegin;
     } *params = args;
     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pConditionalRenderingBegin);

-    convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(params->pConditionalRenderingBegin, &pConditionalRenderingBegin_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pConditionalRenderingBegin_host);
+    convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pConditionalRenderingBegin_host);
     return STATUS_SUCCESS;
 }

@@ -25250,15 +25250,15 @@ static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDebugUtilsLabelEXT32 *pLabelInfo;
+        PTR32 commandBuffer;
+        PTR32 pLabelInfo;
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);

-    convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLabelInfo_host);
+    convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
     return STATUS_SUCCESS;
 }

@@ -25282,15 +25282,15 @@ static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
         VkQueryControlFlags flags;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags);
     return STATUS_SUCCESS;
 }

@@ -25314,16 +25314,16 @@ static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
         VkQueryControlFlags flags;
         uint32_t index;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
+    TRACE("%#x, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags, params->index);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags, params->index);
     return STATUS_SUCCESS;
 }

@@ -25347,18 +25347,18 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkRenderPassBeginInfo32 *pRenderPassBegin;
+        PTR32 commandBuffer;
+        PTR32 pRenderPassBegin;
         VkSubpassContents contents;
     } *params = args;
     VkRenderPassBeginInfo pRenderPassBegin_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);

init_conversion_context(&ctx);
-    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, params->contents);
+    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, params->contents);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25383,20 +25383,20 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkRenderPassBeginInfo32 *pRenderPassBegin;
-        const VkSubpassBeginInfo32 *pSubpassBeginInfo;
+        PTR32 commandBuffer;
+        PTR32 pRenderPassBegin;
+        PTR32 pSubpassBeginInfo;
     } *params = args;
     VkRenderPassBeginInfo pRenderPassBegin_host;
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);

init_conversion_context(&ctx);
-    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
-    convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
+    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
+    convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25421,20 +25421,20 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkRenderPassBeginInfo32 *pRenderPassBegin;
-        const VkSubpassBeginInfo32 *pSubpassBeginInfo;
+        PTR32 commandBuffer;
+        PTR32 pRenderPassBegin;
+        PTR32 pSubpassBeginInfo;
     } *params = args;
     VkRenderPassBeginInfo pRenderPassBegin_host;
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);

init_conversion_context(&ctx);
-    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, params->pRenderPassBegin, &pRenderPassBegin_host);
-    convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
+    convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
+    convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25459,17 +25459,17 @@ static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkRenderingInfo32 *pRenderingInfo;
+        PTR32 commandBuffer;
+        PTR32 pRenderingInfo;
     } *params = args;
     VkRenderingInfo pRenderingInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);

init_conversion_context(&ctx);
-    convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
+    convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25494,17 +25494,17 @@ static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkRenderingInfo32 *pRenderingInfo;
+        PTR32 commandBuffer;
+        PTR32 pRenderingInfo;
     } *params = args;
     VkRenderingInfo pRenderingInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);

init_conversion_context(&ctx);
-    convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRenderingInfo_host);
+    convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25529,16 +25529,16 @@ static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstCounterBuffer;
         uint32_t counterBufferCount;
-        const VkBuffer *pCounterBuffers;
-        const VkDeviceSize *pCounterBufferOffsets;
+        PTR32 pCounterBuffers;
+        PTR32 pCounterBufferOffsets;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
+    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
     return STATUS_SUCCESS;
 }

@@ -25562,19 +25562,19 @@ static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineBindPoint pipelineBindPoint;
         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
         uint32_t firstSet;
         uint32_t descriptorSetCount;
-        const VkDescriptorSet *pDescriptorSets;
+        PTR32 pDescriptorSets;
         uint32_t dynamicOffsetCount;
-        const uint32_t *pDynamicOffsets;
+        PTR32 pDynamicOffsets;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
+    TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets), params->dynamicOffsetCount, (const uint32_t *)UlongToPtr(params->pDynamicOffsets));
     return STATUS_SUCCESS;
 }

@@ -25598,15 +25598,15 @@ static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkIndexType indexType;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
+    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->indexType);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->indexType);
     return STATUS_SUCCESS;
 }

@@ -25630,14 +25630,14 @@ static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImageView DECLSPEC_ALIGN(8) imageView;
         VkImageLayout imageLayout;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }

@@ -25661,14 +25661,14 @@ static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineBindPoint pipelineBindPoint;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
     } *params = args;

-    TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
+    TRACE("%#x, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline);
     return STATUS_SUCCESS;
 }

@@ -25692,15 +25692,15 @@ static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineBindPoint pipelineBindPoint;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t groupIndex;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
+    TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
     return STATUS_SUCCESS;
 }

@@ -25724,14 +25724,14 @@ static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImageView DECLSPEC_ALIGN(8) imageView;
         VkImageLayout imageLayout;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }

@@ -25755,17 +25755,17 @@ static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstBinding;
         uint32_t bindingCount;
-        const VkBuffer *pBuffers;
-        const VkDeviceSize *pOffsets;
-        const VkDeviceSize *pSizes;
+        PTR32 pBuffers;
+        PTR32 pOffsets;
+        PTR32 pSizes;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
+    TRACE("%#x, %u, %u, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes));
     return STATUS_SUCCESS;
 }

@@ -25789,16 +25789,16 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstBinding;
         uint32_t bindingCount;
-        const VkBuffer *pBuffers;
-        const VkDeviceSize *pOffsets;
+        PTR32 pBuffers;
+        PTR32 pOffsets;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
+    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
     return STATUS_SUCCESS;
 }

@@ -25822,18 +25822,18 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstBinding;
         uint32_t bindingCount;
-        const VkBuffer *pBuffers;
-        const VkDeviceSize *pOffsets;
-        const VkDeviceSize *pSizes;
-        const VkDeviceSize *pStrides;
+        PTR32 pBuffers;
+        PTR32 pOffsets;
+        PTR32 pSizes;
+        PTR32 pStrides;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
+    TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
     return STATUS_SUCCESS;
 }

@@ -25857,18 +25857,18 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstBinding;
         uint32_t bindingCount;
-        const VkBuffer *pBuffers;
-        const VkDeviceSize *pOffsets;
-        const VkDeviceSize *pSizes;
-        const VkDeviceSize *pStrides;
+        PTR32 pBuffers;
+        PTR32 pOffsets;
+        PTR32 pSizes;
+        PTR32 pStrides;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
+    TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
     return STATUS_SUCCESS;
 }

@@ -25892,19 +25892,19 @@ static NTSTATUS thunk32_vkCmdBlitImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) srcImage;
         VkImageLayout srcImageLayout;
         VkImage DECLSPEC_ALIGN(8) dstImage;
         VkImageLayout dstImageLayout;
         uint32_t regionCount;
-        const VkImageBlit *pRegions;
+        PTR32 pRegions;
         VkFilter filter;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
+    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageBlit *)UlongToPtr(params->pRegions), params->filter);
     return STATUS_SUCCESS;
 }

@@ -25928,17 +25928,17 @@ static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkBlitImageInfo232 *pBlitImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pBlitImageInfo;
     } *params = args;
     VkBlitImageInfo2 pBlitImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);

init_conversion_context(&ctx);
-    convert_VkBlitImageInfo2_win32_to_host(&ctx, params->pBlitImageInfo, &pBlitImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
+    convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25963,17 +25963,17 @@ static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkBlitImageInfo232 *pBlitImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pBlitImageInfo;
     } *params = args;
     VkBlitImageInfo2 pBlitImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);

init_conversion_context(&ctx);
-    convert_VkBlitImageInfo2_win32_to_host(&ctx, params->pBlitImageInfo, &pBlitImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pBlitImageInfo_host);
+    convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -25998,8 +25998,8 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkAccelerationStructureInfoNV32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
         VkBuffer DECLSPEC_ALIGN(8) instanceData;
         VkDeviceSize DECLSPEC_ALIGN(8) instanceOffset;
         VkBool32 update;
@@ -26011,11 +26011,11 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
     VkAccelerationStructureInfoNV pInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
+    TRACE("%#x, %#x, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));

init_conversion_context(&ctx);
-    convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
+    convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26040,21 +26040,21 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t infoCount;
-        const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
-        const VkDeviceAddress *pIndirectDeviceAddresses;
-        const uint32_t *pIndirectStrides;
-        const uint32_t * const*ppMaxPrimitiveCounts;
+        PTR32 pInfos;
+        PTR32 pIndirectDeviceAddresses;
+        PTR32 pIndirectStrides;
+        PTR32 ppMaxPrimitiveCounts;
     } *params = args;
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
+    TRACE("%#x, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);

init_conversion_context(&ctx);
-    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
+    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkDeviceAddress *)UlongToPtr(params->pIndirectDeviceAddresses), (const uint32_t *)UlongToPtr(params->pIndirectStrides), (const uint32_t * const*)UlongToPtr(params->ppMaxPrimitiveCounts));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26079,19 +26079,19 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t infoCount;
-        const VkAccelerationStructureBuildGeometryInfoKHR32 *pInfos;
-        const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos;
+        PTR32 pInfos;
+        PTR32 ppBuildRangeInfos;
     } *params = args;
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
+    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);

init_conversion_context(&ctx);
-    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host, params->ppBuildRangeInfos);
+    pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26116,18 +26116,18 @@ static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t infoCount;
-        const VkMicromapBuildInfoEXT32 *pInfos;
+        PTR32 pInfos;
     } *params = args;
     const VkMicromapBuildInfoEXT *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->infoCount, params->pInfos);

init_conversion_context(&ctx);
-    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, params->pInfos, params->infoCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, pInfos_host);
+    pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26152,16 +26152,16 @@ static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t attachmentCount;
-        const VkClearAttachment *pAttachments;
+        PTR32 pAttachments;
         uint32_t rectCount;
-        const VkClearRect *pRects;
+        PTR32 pRects;
     } *params = args;

-    TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
+    TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkClearAttachment *)UlongToPtr(params->pAttachments), params->rectCount, (const VkClearRect *)UlongToPtr(params->pRects));
     return STATUS_SUCCESS;
 }

@@ -26185,17 +26185,17 @@ static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) image;
         VkImageLayout imageLayout;
-        const VkClearColorValue *pColor;
+        PTR32 pColor;
         uint32_t rangeCount;
-        const VkImageSubresourceRange *pRanges;
+        PTR32 pRanges;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
+    TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearColorValue *)UlongToPtr(params->pColor), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
     return STATUS_SUCCESS;
 }

@@ -26219,17 +26219,17 @@ static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) image;
         VkImageLayout imageLayout;
-        const VkClearDepthStencilValue *pDepthStencil;
+        PTR32 pDepthStencil;
         uint32_t rangeCount;
-        const VkImageSubresourceRange *pRanges;
+        PTR32 pRanges;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
+    TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearDepthStencilValue *)UlongToPtr(params->pDepthStencil), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
     return STATUS_SUCCESS;
 }

@@ -26253,15 +26253,15 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyAccelerationStructureInfoKHR32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26285,15 +26285,15 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkAccelerationStructureNV DECLSPEC_ALIGN(8) dst;
         VkAccelerationStructureNV DECLSPEC_ALIGN(8) src;
         VkCopyAccelerationStructureModeKHR mode;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
+    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dst, params->src, params->mode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dst, params->src, params->mode);
     return STATUS_SUCCESS;
 }

@@ -26317,15 +26317,15 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26349,20 +26349,20 @@ static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         uint32_t regionCount;
-        const VkBufferCopy32 *pRegions;
+        PTR32 pRegions;
     } *params = args;
     const VkBufferCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
+    TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);

init_conversion_context(&ctx);
-    pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
+    pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26387,17 +26387,17 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyBufferInfo232 *pCopyBufferInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyBufferInfo;
     } *params = args;
     VkCopyBufferInfo2 pCopyBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);

init_conversion_context(&ctx);
-    convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
+    convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26422,17 +26422,17 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyBufferInfo232 *pCopyBufferInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyBufferInfo;
     } *params = args;
     VkCopyBufferInfo2 pCopyBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);

init_conversion_context(&ctx);
-    convert_VkCopyBufferInfo2_win32_to_host(&ctx, params->pCopyBufferInfo, &pCopyBufferInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferInfo_host);
+    convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26457,21 +26457,21 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) srcBuffer;
         VkImage DECLSPEC_ALIGN(8) dstImage;
         VkImageLayout dstImageLayout;
         uint32_t regionCount;
-        const VkBufferImageCopy32 *pRegions;
+        PTR32 pRegions;
     } *params = args;
     const VkBufferImageCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
+    TRACE("%#x, 0x%s, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);

init_conversion_context(&ctx);
-    pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
+    pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26496,17 +26496,17 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyBufferToImageInfo;
     } *params = args;
     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);

init_conversion_context(&ctx);
-    convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
+    convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26531,17 +26531,17 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyBufferToImageInfo232 *pCopyBufferToImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyBufferToImageInfo;
     } *params = args;
     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);

init_conversion_context(&ctx);
-    convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, params->pCopyBufferToImageInfo, &pCopyBufferToImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyBufferToImageInfo_host);
+    convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26566,18 +26566,18 @@ static NTSTATUS thunk32_vkCmdCopyImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) srcImage;
         VkImageLayout srcImageLayout;
         VkImage DECLSPEC_ALIGN(8) dstImage;
         VkImageLayout dstImageLayout;
         uint32_t regionCount;
-        const VkImageCopy *pRegions;
+        PTR32 pRegions;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
+    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageCopy *)UlongToPtr(params->pRegions));
     return STATUS_SUCCESS;
 }

@@ -26601,17 +26601,17 @@ static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyImageInfo232 *pCopyImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyImageInfo;
     } *params = args;
     VkCopyImageInfo2 pCopyImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);

init_conversion_context(&ctx);
-    convert_VkCopyImageInfo2_win32_to_host(&ctx, params->pCopyImageInfo, &pCopyImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
+    convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26636,17 +26636,17 @@ static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyImageInfo232 *pCopyImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyImageInfo;
     } *params = args;
     VkCopyImageInfo2 pCopyImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);

init_conversion_context(&ctx);
-    convert_VkCopyImageInfo2_win32_to_host(&ctx, params->pCopyImageInfo, &pCopyImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageInfo_host);
+    convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26671,21 +26671,21 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) srcImage;
         VkImageLayout srcImageLayout;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         uint32_t regionCount;
-        const VkBufferImageCopy32 *pRegions;
+        PTR32 pRegions;
     } *params = args;
     const VkBufferImageCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
+    TRACE("%#x, 0x%s, %#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);

init_conversion_context(&ctx);
-    pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, params->pRegions, params->regionCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
+    pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26710,17 +26710,17 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyImageToBufferInfo;
     } *params = args;
     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);

init_conversion_context(&ctx);
-    convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
+    convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26745,17 +26745,17 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyImageToBufferInfo232 *pCopyImageToBufferInfo;
+        PTR32 commandBuffer;
+        PTR32 pCopyImageToBufferInfo;
     } *params = args;
     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);

init_conversion_context(&ctx);
-    convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, params->pCopyImageToBufferInfo, &pCopyImageToBufferInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pCopyImageToBufferInfo_host);
+    convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -26780,15 +26780,15 @@ static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
         uint32_t copyCount;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
+    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -26812,15 +26812,15 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26844,18 +26844,18 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkDeviceAddress DECLSPEC_ALIGN(8) copyBufferAddress;
         uint32_t copyCount;
         uint32_t stride;
         VkImage DECLSPEC_ALIGN(8) dstImage;
         VkImageLayout dstImageLayout;
-        const VkImageSubresourceLayers *pImageSubresources;
+        PTR32 pImageSubresources;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %#x, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, params->pImageSubresources);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, (const VkImageSubresourceLayers *)UlongToPtr(params->pImageSubresources));
     return STATUS_SUCCESS;
 }

@@ -26879,15 +26879,15 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyMemoryToMicromapInfoEXT pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26911,15 +26911,15 @@ static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyMicromapInfoEXT32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyMicromapInfoEXT pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26943,15 +26943,15 @@ static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
+        PTR32 commandBuffer;
+        PTR32 pInfo;
     } *params = args;
     VkCopyMicromapToMemoryInfoEXT pInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);

-    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pInfo_host);
+    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -26975,7 +26975,7 @@ static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
         uint32_t queryCount;
@@ -26985,9 +26985,9 @@ static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
         VkQueryResultFlags flags;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
     return STATUS_SUCCESS;
 }

@@ -27011,15 +27011,15 @@ static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkCuLaunchInfoNVX32 *pLaunchInfo;
+        PTR32 commandBuffer;
+        PTR32 pLaunchInfo;
     } *params = args;
     VkCuLaunchInfoNVX pLaunchInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pLaunchInfo);

-    convert_VkCuLaunchInfoNVX_win32_to_host(params->pLaunchInfo, &pLaunchInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLaunchInfo_host);
+    convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLaunchInfo_host);
     return STATUS_SUCCESS;
 }

@@ -27043,15 +27043,15 @@ static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDebugMarkerMarkerInfoEXT32 *pMarkerInfo;
+        PTR32 commandBuffer;
+        PTR32 pMarkerInfo;
     } *params = args;
     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);

-    convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
+    convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
 }

@@ -27075,12 +27075,12 @@ static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -27104,15 +27104,15 @@ static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDebugMarkerMarkerInfoEXT32 *pMarkerInfo;
+        PTR32 commandBuffer;
+        PTR32 pMarkerInfo;
     } *params = args;
     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);

-    convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
+    convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
 }

@@ -27136,15 +27136,15 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsAddress;
         VkDeviceAddress DECLSPEC_ALIGN(8) indirectCommandsCountAddress;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
+    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27168,18 +27168,18 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t decompressRegionCount;
-        const VkDecompressMemoryRegionNV32 *pDecompressMemoryRegions;
+        PTR32 pDecompressMemoryRegions;
     } *params = args;
     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);

init_conversion_context(&ctx);
-    pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, params->pDecompressMemoryRegions, params->decompressRegionCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
+    pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -27204,15 +27204,15 @@ static NTSTATUS thunk32_vkCmdDispatch(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t groupCountX;
         uint32_t groupCountY;
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
+    TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }

@@ -27236,7 +27236,7 @@ static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t baseGroupX;
         uint32_t baseGroupY;
         uint32_t baseGroupZ;
@@ -27245,9 +27245,9 @@ static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
+    TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }

@@ -27271,7 +27271,7 @@ static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t baseGroupX;
         uint32_t baseGroupY;
         uint32_t baseGroupZ;
@@ -27280,9 +27280,9 @@ static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
+    TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }

@@ -27306,14 +27306,14 @@ static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
+    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset);
     return STATUS_SUCCESS;
 }

@@ -27337,16 +27337,16 @@ static NTSTATUS thunk32_vkCmdDraw(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t vertexCount;
         uint32_t instanceCount;
         uint32_t firstVertex;
         uint32_t firstInstance;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
+    TRACE("%#x, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
     return STATUS_SUCCESS;
 }

@@ -27370,7 +27370,7 @@ static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t indexCount;
         uint32_t instanceCount;
         uint32_t firstIndex;
@@ -27378,9 +27378,9 @@ static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
         uint32_t firstInstance;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
+    TRACE("%#x, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
     return STATUS_SUCCESS;
 }

@@ -27404,16 +27404,16 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         uint32_t drawCount;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27437,7 +27437,7 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27446,9 +27446,9 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27472,7 +27472,7 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27481,9 +27481,9 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27507,7 +27507,7 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27516,9 +27516,9 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27542,16 +27542,16 @@ static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         uint32_t drawCount;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27575,7 +27575,7 @@ static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t instanceCount;
         uint32_t firstInstance;
         VkBuffer DECLSPEC_ALIGN(8) counterBuffer;
@@ -27584,9 +27584,9 @@ static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
         uint32_t vertexStride;
     } *params = args;

-    TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
+    TRACE("%#x, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
     return STATUS_SUCCESS;
 }

@@ -27610,7 +27610,7 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27619,9 +27619,9 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27645,7 +27645,7 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27654,9 +27654,9 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27680,7 +27680,7 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27689,9 +27689,9 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27715,15 +27715,15 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t groupCountX;
         uint32_t groupCountY;
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
+    TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }

@@ -27747,7 +27747,7 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27756,9 +27756,9 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27782,7 +27782,7 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkBuffer DECLSPEC_ALIGN(8) countBuffer;
@@ -27791,9 +27791,9 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27817,16 +27817,16 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         uint32_t drawCount;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27850,16 +27850,16 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         uint32_t drawCount;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
+    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27883,14 +27883,14 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t taskCount;
         uint32_t firstTask;
     } *params = args;

-    TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
+    TRACE("%#x, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->taskCount, params->firstTask);
     return STATUS_SUCCESS;
 }

@@ -27914,17 +27914,17 @@ static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t drawCount;
-        const VkMultiDrawInfoEXT *pVertexInfo;
+        PTR32 pVertexInfo;
         uint32_t instanceCount;
         uint32_t firstInstance;
         uint32_t stride;
     } *params = args;

-    TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
+    TRACE("%#x, %u, %#x, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawInfoEXT *)UlongToPtr(params->pVertexInfo), params->instanceCount, params->firstInstance, params->stride);
     return STATUS_SUCCESS;
 }

@@ -27948,18 +27948,18 @@ static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t drawCount;
-        const VkMultiDrawIndexedInfoEXT *pIndexInfo;
+        PTR32 pIndexInfo;
         uint32_t instanceCount;
         uint32_t firstInstance;
         uint32_t stride;
-        const int32_t *pVertexOffset;
+        PTR32 pVertexOffset;
     } *params = args;

-    TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
+    TRACE("%#x, %u, %#x, %u, %u, %u, %#x\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawIndexedInfoEXT *)UlongToPtr(params->pIndexInfo), params->instanceCount, params->firstInstance, params->stride, (const int32_t *)UlongToPtr(params->pVertexOffset));
     return STATUS_SUCCESS;
 }

@@ -27983,12 +27983,12 @@ static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -28012,12 +28012,12 @@ static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -28041,14 +28041,14 @@ static NTSTATUS thunk32_vkCmdEndQuery(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
     } *params = args;

-    TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
+    TRACE("%#x, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }

@@ -28072,15 +28072,15 @@ static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
         uint32_t index;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
+    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->index);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->index);
     return STATUS_SUCCESS;
 }

@@ -28104,12 +28104,12 @@ static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -28133,17 +28133,17 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkSubpassEndInfo32 *pSubpassEndInfo;
+        PTR32 commandBuffer;
+        PTR32 pSubpassEndInfo;
     } *params = args;
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);

init_conversion_context(&ctx);
-    convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassEndInfo_host);
+    convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28168,17 +28168,17 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkSubpassEndInfo32 *pSubpassEndInfo;
+        PTR32 commandBuffer;
+        PTR32 pSubpassEndInfo;
     } *params = args;
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);

init_conversion_context(&ctx);
-    convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassEndInfo_host);
+    convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28203,12 +28203,12 @@ static NTSTATUS thunk32_vkCmdEndRendering(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -28232,12 +28232,12 @@ static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -28261,16 +28261,16 @@ static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstCounterBuffer;
         uint32_t counterBufferCount;
-        const VkBuffer *pCounterBuffers;
-        const VkDeviceSize *pCounterBufferOffsets;
+        PTR32 pCounterBuffers;
+        PTR32 pCounterBufferOffsets;
     } *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
+    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
     return STATUS_SUCCESS;
 }

@@ -28299,18 +28299,18 @@ static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t commandBufferCount;
-        const VkCommandBuffer *pCommandBuffers;
+        PTR32 pCommandBuffers;
     } *params = args;
     const VkCommandBuffer *pCommandBuffers_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);

init_conversion_context(&ctx);
-    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
+    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->commandBufferCount, pCommandBuffers_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28335,18 +28335,18 @@ static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 isPreprocessed;
-        const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
+        PTR32 pGeneratedCommandsInfo;
     } *params = args;
     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);

init_conversion_context(&ctx);
-    convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
+    convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28371,16 +28371,16 @@ static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
         VkDeviceSize DECLSPEC_ALIGN(8) size;
         uint32_t data;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
     return STATUS_SUCCESS;
 }

@@ -28404,15 +28404,15 @@ static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDebugUtilsLabelEXT32 *pLabelInfo;
+        PTR32 commandBuffer;
+        PTR32 pLabelInfo;
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);

-    convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pLabelInfo_host);
+    convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
     return STATUS_SUCCESS;
 }

@@ -28436,13 +28436,13 @@ static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkSubpassContents contents;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->contents);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->contents);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->contents);
     return STATUS_SUCCESS;
 }

@@ -28466,20 +28466,20 @@ static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkSubpassBeginInfo32 *pSubpassBeginInfo;
-        const VkSubpassEndInfo32 *pSubpassEndInfo;
+        PTR32 commandBuffer;
+        PTR32 pSubpassBeginInfo;
+        PTR32 pSubpassEndInfo;
     } *params = args;
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);

init_conversion_context(&ctx);
-    convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
-    convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
+    convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
+    convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28504,20 +28504,20 @@ static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkSubpassBeginInfo32 *pSubpassBeginInfo;
-        const VkSubpassEndInfo32 *pSubpassEndInfo;
+        PTR32 commandBuffer;
+        PTR32 pSubpassBeginInfo;
+        PTR32 pSubpassEndInfo;
     } *params = args;
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);

init_conversion_context(&ctx);
-    convert_VkSubpassBeginInfo_win32_to_host(params->pSubpassBeginInfo, &pSubpassBeginInfo_host);
-    convert_VkSubpassEndInfo_win32_to_host(&ctx, params->pSubpassEndInfo, &pSubpassEndInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
+    convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
+    convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28542,16 +28542,16 @@ static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
-        const VkOpticalFlowExecuteInfoNV32 *pExecuteInfo;
+        PTR32 pExecuteInfo;
     } *params = args;
     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);

-    convert_VkOpticalFlowExecuteInfoNV_win32_to_host(params->pExecuteInfo, &pExecuteInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, &pExecuteInfo_host);
+    convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->session, &pExecuteInfo_host);
     return STATUS_SUCCESS;
 }

@@ -28575,29 +28575,29 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlags srcStageMask;
         VkPipelineStageFlags dstStageMask;
         VkDependencyFlags dependencyFlags;
         uint32_t memoryBarrierCount;
-        const VkMemoryBarrier32 *pMemoryBarriers;
+        PTR32 pMemoryBarriers;
         uint32_t bufferMemoryBarrierCount;
-        const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
+        PTR32 pBufferMemoryBarriers;
         uint32_t imageMemoryBarrierCount;
-        const VkImageMemoryBarrier32 *pImageMemoryBarriers;
+        PTR32 pImageMemoryBarriers;
     } *params = args;
     const VkMemoryBarrier *pMemoryBarriers_host;
     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
+    TRACE("%#x, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);

init_conversion_context(&ctx);
-    pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, params->pMemoryBarriers, params->memoryBarrierCount);
-    pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
-    pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
+    pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
+    pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
+    pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28622,17 +28622,17 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDependencyInfo32 *pDependencyInfo;
+        PTR32 commandBuffer;
+        PTR32 pDependencyInfo;
     } *params = args;
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);

init_conversion_context(&ctx);
-    convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
+    convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28657,17 +28657,17 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkDependencyInfo32 *pDependencyInfo;
+        PTR32 commandBuffer;
+        PTR32 pDependencyInfo;
     } *params = args;
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);

init_conversion_context(&ctx);
-    convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pDependencyInfo_host);
+    convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28692,17 +28692,17 @@ static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkGeneratedCommandsInfoNV32 *pGeneratedCommandsInfo;
+        PTR32 commandBuffer;
+        PTR32 pGeneratedCommandsInfo;
     } *params = args;
     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pGeneratedCommandsInfo);

init_conversion_context(&ctx);
-    convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, params->pGeneratedCommandsInfo, &pGeneratedCommandsInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pGeneratedCommandsInfo_host);
+    convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pGeneratedCommandsInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28727,17 +28727,17 @@ static NTSTATUS thunk32_vkCmdPushConstants(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
         VkShaderStageFlags stageFlags;
         uint32_t offset;
         uint32_t size;
-        const void *pValues;
+        PTR32 pValues;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
+    TRACE("%#x, 0x%s, %#x, %u, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->layout, params->stageFlags, params->offset, params->size, params->pValues);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->layout, params->stageFlags, params->offset, params->size, (const void *)UlongToPtr(params->pValues));
     return STATUS_SUCCESS;
 }

@@ -28761,21 +28761,21 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineBindPoint pipelineBindPoint;
         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
         uint32_t set;
         uint32_t descriptorWriteCount;
-        const VkWriteDescriptorSet32 *pDescriptorWrites;
+        PTR32 pDescriptorWrites;
     } *params = args;
     const VkWriteDescriptorSet *pDescriptorWrites_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
+    TRACE("%#x, %#x, 0x%s, %u, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);

init_conversion_context(&ctx);
-    pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
+    pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -28800,16 +28800,16 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
         VkPipelineLayout DECLSPEC_ALIGN(8) layout;
         uint32_t set;
-        const void *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
+    TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, params->pData);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -28833,14 +28833,14 @@ static NTSTATUS thunk32_vkCmdResetEvent(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkPipelineStageFlags stageMask;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }

@@ -28864,14 +28864,14 @@ static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
+    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }

@@ -28895,14 +28895,14 @@ static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
+    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }

@@ -28926,15 +28926,15 @@ static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
         uint32_t queryCount;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
+    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
     return STATUS_SUCCESS;
 }

@@ -28958,18 +28958,18 @@ static NTSTATUS thunk32_vkCmdResolveImage(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkImage DECLSPEC_ALIGN(8) srcImage;
         VkImageLayout srcImageLayout;
         VkImage DECLSPEC_ALIGN(8) dstImage;
         VkImageLayout dstImageLayout;
         uint32_t regionCount;
-        const VkImageResolve *pRegions;
+        PTR32 pRegions;
     } *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
+    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageResolve *)UlongToPtr(params->pRegions));
     return STATUS_SUCCESS;
 }

@@ -28993,17 +28993,17 @@ static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkResolveImageInfo232 *pResolveImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pResolveImageInfo;
     } *params = args;
     VkResolveImageInfo2 pResolveImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);

init_conversion_context(&ctx);
-    convert_VkResolveImageInfo2_win32_to_host(&ctx, params->pResolveImageInfo, &pResolveImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
+    convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -29028,17 +29028,17 @@ static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkResolveImageInfo232 *pResolveImageInfo;
+        PTR32 commandBuffer;
+        PTR32 pResolveImageInfo;
     } *params = args;
     VkResolveImageInfo2 pResolveImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);

init_conversion_context(&ctx);
-    convert_VkResolveImageInfo2_win32_to_host(&ctx, params->pResolveImageInfo, &pResolveImageInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pResolveImageInfo_host);
+    convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -29063,13 +29063,13 @@ static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 alphaToCoverageEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->alphaToCoverageEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToCoverageEnable);
     return STATUS_SUCCESS;
 }

@@ -29093,13 +29093,13 @@ static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 alphaToOneEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->alphaToOneEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToOneEnable);
     return STATUS_SUCCESS;
 }

@@ -29123,13 +29123,13 @@ static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const float *blendConstants;
+        PTR32 commandBuffer;
+        PTR32 blendConstants;
     } *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->blendConstants);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const float *)UlongToPtr(params->blendConstants));
     return STATUS_SUCCESS;
 }

@@ -29153,13 +29153,13 @@ static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const void *pCheckpointMarker;
+        PTR32 commandBuffer;
+        PTR32 pCheckpointMarker;
     } *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pCheckpointMarker);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const void *)UlongToPtr(params->pCheckpointMarker));
     return STATUS_SUCCESS;
 }

@@ -29183,19 +29183,19 @@ static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCoarseSampleOrderTypeNV sampleOrderType;
         uint32_t customSampleOrderCount;
-        const VkCoarseSampleOrderCustomNV32 *pCustomSampleOrders;
+        PTR32 pCustomSampleOrders;
     } *params = args;
     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
+    TRACE("%#x, %#x, %u, %#x\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);

init_conversion_context(&ctx);
-    pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, params->pCustomSampleOrders, params->customSampleOrderCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleOrderType, params->customSampleOrderCount, pCustomSampleOrders_host);
+    pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleOrderType, params->customSampleOrderCount, pCustomSampleOrders_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -29220,15 +29220,15 @@ static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstAttachment;
         uint32_t attachmentCount;
-        const VkColorBlendAdvancedEXT *pColorBlendAdvanced;
+        PTR32 pColorBlendAdvanced;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendAdvancedEXT *)UlongToPtr(params->pColorBlendAdvanced));
     return STATUS_SUCCESS;
 }

@@ -29252,15 +29252,15 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstAttachment;
         uint32_t attachmentCount;
-        const VkBool32 *pColorBlendEnables;
+        PTR32 pColorBlendEnables;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorBlendEnables));
     return STATUS_SUCCESS;
 }

@@ -29284,15 +29284,15 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstAttachment;
         uint32_t attachmentCount;
-        const VkColorBlendEquationEXT *pColorBlendEquations;
+        PTR32 pColorBlendEquations;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendEquationEXT *)UlongToPtr(params->pColorBlendEquations));
     return STATUS_SUCCESS;
 }

@@ -29316,14 +29316,14 @@ static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t attachmentCount;
-        const VkBool32 *pColorWriteEnables;
+        PTR32 pColorWriteEnables;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorWriteEnables));
     return STATUS_SUCCESS;
 }

@@ -29347,15 +29347,15 @@ static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstAttachment;
         uint32_t attachmentCount;
-        const VkColorComponentFlags *pColorWriteMasks;
+        PTR32 pColorWriteMasks;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorComponentFlags *)UlongToPtr(params->pColorWriteMasks));
     return STATUS_SUCCESS;
 }

@@ -29379,13 +29379,13 @@ static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->conservativeRasterizationMode);
     return STATUS_SUCCESS;
 }

@@ -29409,13 +29409,13 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCoverageModulationModeNV coverageModulationMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->coverageModulationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationMode);
     return STATUS_SUCCESS;
 }

@@ -29439,13 +29439,13 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 coverageModulationTableEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->coverageModulationTableEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableEnable);
     return STATUS_SUCCESS;
 }

@@ -29469,14 +29469,14 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t coverageModulationTableCount;
-        const float *pCoverageModulationTable;
+        PTR32 pCoverageModulationTable;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableCount, (const float *)UlongToPtr(params->pCoverageModulationTable));
     return STATUS_SUCCESS;
 }

@@ -29500,13 +29500,13 @@ static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCoverageReductionModeNV coverageReductionMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->coverageReductionMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageReductionMode);
     return STATUS_SUCCESS;
 }

@@ -29530,13 +29530,13 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 coverageToColorEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorEnable);
     return STATUS_SUCCESS;
 }

@@ -29560,13 +29560,13 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t coverageToColorLocation;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
+    TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorLocation);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorLocation);
     return STATUS_SUCCESS;
 }

@@ -29590,13 +29590,13 @@ static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCullModeFlags cullMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }

@@ -29620,13 +29620,13 @@ static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCullModeFlags cullMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }

@@ -29650,15 +29650,15 @@ static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         float depthBiasConstantFactor;
         float depthBiasClamp;
         float depthBiasSlopeFactor;
     } *params = args;

-    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    TRACE("%#x, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
     return STATUS_SUCCESS;
 }

@@ -29682,13 +29682,13 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthBiasEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }

@@ -29712,13 +29712,13 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthBiasEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }

@@ -29742,14 +29742,14 @@ static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         float minDepthBounds;
         float maxDepthBounds;
     } *params = args;

-    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
+    TRACE("%#x, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->minDepthBounds, params->maxDepthBounds);
     return STATUS_SUCCESS;
 }

@@ -29773,13 +29773,13 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthBoundsTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }

@@ -29803,13 +29803,13 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthBoundsTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }

@@ -29833,13 +29833,13 @@ static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthClampEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthClampEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClampEnable);
     return STATUS_SUCCESS;
 }

@@ -29863,13 +29863,13 @@ static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthClipEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthClipEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClipEnable);
     return STATUS_SUCCESS;
 }

@@ -29893,13 +29893,13 @@ static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 negativeOneToOne;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
+    TRACE("%#x, %u\n", params->commandBuffer, params->negativeOneToOne);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->negativeOneToOne);
     return STATUS_SUCCESS;
 }

@@ -29923,13 +29923,13 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCompareOp depthCompareOp;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }

@@ -29953,13 +29953,13 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCompareOp depthCompareOp;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }

@@ -29983,13 +29983,13 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }

@@ -30013,13 +30013,13 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }

@@ -30043,13 +30043,13 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthWriteEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }

@@ -30073,13 +30073,13 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 depthWriteEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }

@@ -30103,13 +30103,13 @@ static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t deviceMask;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
+    TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }

@@ -30133,13 +30133,13 @@ static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t deviceMask;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
+    TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }

@@ -30163,15 +30163,15 @@ static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstDiscardRectangle;
         uint32_t discardRectangleCount;
-        const VkRect2D *pDiscardRectangles;
+        PTR32 pDiscardRectangles;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, (const VkRect2D *)UlongToPtr(params->pDiscardRectangles));
     return STATUS_SUCCESS;
 }

@@ -30195,14 +30195,14 @@ static NTSTATUS thunk32_vkCmdSetEvent(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkPipelineStageFlags stageMask;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }

@@ -30226,18 +30226,18 @@ static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
-        const VkDependencyInfo32 *pDependencyInfo;
+        PTR32 pDependencyInfo;
     } *params = args;
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);

init_conversion_context(&ctx);
-    convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
+    convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -30262,18 +30262,18 @@ static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkEvent DECLSPEC_ALIGN(8) event;
-        const VkDependencyInfo32 *pDependencyInfo;
+        PTR32 pDependencyInfo;
     } *params = args;
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);

init_conversion_context(&ctx);
-    convert_VkDependencyInfo_win32_to_host(&ctx, params->pDependencyInfo, &pDependencyInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, &pDependencyInfo_host);
+    convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -30298,15 +30298,15 @@ static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstExclusiveScissor;
         uint32_t exclusiveScissorCount;
-        const VkRect2D *pExclusiveScissors;
+        PTR32 pExclusiveScissors;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, (const VkRect2D *)UlongToPtr(params->pExclusiveScissors));
     return STATUS_SUCCESS;
 }

@@ -30330,13 +30330,13 @@ static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         float extraPrimitiveOverestimationSize;
     } *params = args;

-    TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
+    TRACE("%#x, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->extraPrimitiveOverestimationSize);
     return STATUS_SUCCESS;
 }

@@ -30360,14 +30360,14 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkFragmentShadingRateNV shadingRate;
-        const VkFragmentShadingRateCombinerOpKHR *combinerOps;
+        PTR32 combinerOps;
     } *params = args;

-    TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->shadingRate, params->combinerOps);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRate, (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
     return STATUS_SUCCESS;
 }

@@ -30391,14 +30391,14 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkExtent2D *pFragmentSize;
-        const VkFragmentShadingRateCombinerOpKHR *combinerOps;
+        PTR32 commandBuffer;
+        PTR32 pFragmentSize;
+        PTR32 combinerOps;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const VkExtent2D *)UlongToPtr(params->pFragmentSize), (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
     return STATUS_SUCCESS;
 }

@@ -30422,13 +30422,13 @@ static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkFrontFace frontFace;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }

@@ -30452,13 +30452,13 @@ static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkFrontFace frontFace;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }

@@ -30482,13 +30482,13 @@ static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkLineRasterizationModeEXT lineRasterizationMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->lineRasterizationMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineRasterizationMode);
     return STATUS_SUCCESS;
 }

@@ -30512,14 +30512,14 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t lineStippleFactor;
         uint16_t lineStipplePattern;
     } *params = args;

-    TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
+    TRACE("%#x, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
     return STATUS_SUCCESS;
 }

@@ -30543,13 +30543,13 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 stippledLineEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->stippledLineEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stippledLineEnable);
     return STATUS_SUCCESS;
 }

@@ -30573,13 +30573,13 @@ static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         float lineWidth;
     } *params = args;

-    TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
+    TRACE("%#x, %f\n", params->commandBuffer, params->lineWidth);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineWidth);
     return STATUS_SUCCESS;
 }

@@ -30603,13 +30603,13 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkLogicOp logicOp;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->logicOp);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOp);
     return STATUS_SUCCESS;
 }

@@ -30633,13 +30633,13 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 logicOpEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->logicOpEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOpEnable);
     return STATUS_SUCCESS;
 }

@@ -30663,13 +30663,13 @@ static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t patchControlPoints;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
+    TRACE("%#x, %u\n", params->commandBuffer, params->patchControlPoints);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->patchControlPoints);
     return STATUS_SUCCESS;
 }

@@ -30693,16 +30693,16 @@ static NTSTATUS thunk32_vkCmdSetPerformanceMarkerINTEL(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkPerformanceMarkerInfoINTEL32 *pMarkerInfo;
+        PTR32 commandBuffer;
+        PTR32 pMarkerInfo;
         VkResult result;
     } *params = args;
     VkPerformanceMarkerInfoINTEL pMarkerInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);

-    convert_VkPerformanceMarkerInfoINTEL_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
+    convert_VkPerformanceMarkerInfoINTEL_win32_to_host((const VkPerformanceMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceMarkerINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
 }

@@ -30726,16 +30726,16 @@ static NTSTATUS thunk32_vkCmdSetPerformanceOverrideINTEL(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkPerformanceOverrideInfoINTEL32 *pOverrideInfo;
+        PTR32 commandBuffer;
+        PTR32 pOverrideInfo;
         VkResult result;
     } *params = args;
     VkPerformanceOverrideInfoINTEL pOverrideInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pOverrideInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pOverrideInfo);

-    convert_VkPerformanceOverrideInfoINTEL_win32_to_host(params->pOverrideInfo, &pOverrideInfo_host);
-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pOverrideInfo_host);
+    convert_VkPerformanceOverrideInfoINTEL_win32_to_host((const VkPerformanceOverrideInfoINTEL32 *)UlongToPtr(params->pOverrideInfo), &pOverrideInfo_host);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceOverrideINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pOverrideInfo_host);
     return STATUS_SUCCESS;
 }

@@ -30759,16 +30759,16 @@ static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkPerformanceStreamMarkerInfoINTEL32 *pMarkerInfo;
+        PTR32 commandBuffer;
+        PTR32 pMarkerInfo;
         VkResult result;
     } *params = args;
     VkPerformanceStreamMarkerInfoINTEL pMarkerInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);

-    convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(params->pMarkerInfo, &pMarkerInfo_host);
-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pMarkerInfo_host);
+    convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host((const VkPerformanceStreamMarkerInfoINTEL32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
 }

@@ -30792,13 +30792,13 @@ static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPolygonMode polygonMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->polygonMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->polygonMode);
     return STATUS_SUCCESS;
 }

@@ -30822,13 +30822,13 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 primitiveRestartEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }

@@ -30852,13 +30852,13 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 primitiveRestartEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }

@@ -30882,13 +30882,13 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPrimitiveTopology primitiveTopology;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }

@@ -30912,13 +30912,13 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPrimitiveTopology primitiveTopology;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }

@@ -30942,13 +30942,13 @@ static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkProvokingVertexModeEXT provokingVertexMode;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->provokingVertexMode);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->provokingVertexMode);
     return STATUS_SUCCESS;
 }

@@ -30972,13 +30972,13 @@ static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkSampleCountFlagBits rasterizationSamples;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->rasterizationSamples);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationSamples);
     return STATUS_SUCCESS;
 }

@@ -31002,13 +31002,13 @@ static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t rasterizationStream;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
+    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizationStream);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationStream);
     return STATUS_SUCCESS;
 }

@@ -31032,13 +31032,13 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 rasterizerDiscardEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }

@@ -31062,13 +31062,13 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 rasterizerDiscardEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }

@@ -31092,13 +31092,13 @@ static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t pipelineStackSize;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
+    TRACE("%#x, %u\n", params->commandBuffer, params->pipelineStackSize);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStackSize);
     return STATUS_SUCCESS;
 }

@@ -31122,13 +31122,13 @@ static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 representativeFragmentTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->representativeFragmentTestEnable);
     return STATUS_SUCCESS;
 }

@@ -31152,15 +31152,15 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkSampleLocationsInfoEXT32 *pSampleLocationsInfo;
+        PTR32 commandBuffer;
+        PTR32 pSampleLocationsInfo;
     } *params = args;
     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->pSampleLocationsInfo);

-    convert_VkSampleLocationsInfoEXT_win32_to_host(params->pSampleLocationsInfo, &pSampleLocationsInfo_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pSampleLocationsInfo_host);
+    convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSampleLocationsInfo_host);
     return STATUS_SUCCESS;
 }

@@ -31184,13 +31184,13 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 sampleLocationsEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->sampleLocationsEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleLocationsEnable);
     return STATUS_SUCCESS;
 }

@@ -31214,14 +31214,14 @@ static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkSampleCountFlagBits samples;
-        const VkSampleMask *pSampleMask;
+        PTR32 pSampleMask;
     } *params = args;

-    TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
+    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->samples, params->pSampleMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->samples, (const VkSampleMask *)UlongToPtr(params->pSampleMask));
     return STATUS_SUCCESS;
 }

@@ -31245,15 +31245,15 @@ static NTSTATUS thunk32_vkCmdSetScissor(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstScissor;
         uint32_t scissorCount;
-        const VkRect2D *pScissors;
+        PTR32 pScissors;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstScissor, params->scissorCount, params->pScissors);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstScissor, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }

@@ -31277,14 +31277,14 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t scissorCount;
-        const VkRect2D *pScissors;
+        PTR32 pScissors;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }

@@ -31308,14 +31308,14 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t scissorCount;
-        const VkRect2D *pScissors;
+        PTR32 pScissors;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }

@@ -31339,13 +31339,13 @@ static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 shadingRateImageEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->shadingRateImageEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRateImageEnable);
     return STATUS_SUCCESS;
 }

@@ -31369,14 +31369,14 @@ static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkStencilFaceFlags faceMask;
         uint32_t compareMask;
     } *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
+    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->compareMask);
     return STATUS_SUCCESS;
 }

@@ -31400,7 +31400,7 @@ static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkStencilFaceFlags faceMask;
         VkStencilOp failOp;
         VkStencilOp passOp;
@@ -31408,9 +31408,9 @@ static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
         VkCompareOp compareOp;
     } *params = args;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
+    TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }

@@ -31434,7 +31434,7 @@ static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkStencilFaceFlags faceMask;
         VkStencilOp failOp;
         VkStencilOp passOp;
@@ -31442,9 +31442,9 @@ static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
         VkCompareOp compareOp;
     } *params = args;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
+    TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }

@@ -31468,14 +31468,14 @@ static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkStencilFaceFlags faceMask;
         uint32_t reference;
     } *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
+    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->reference);
     return STATUS_SUCCESS;
 }

@@ -31499,13 +31499,13 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 stencilTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }

@@ -31529,13 +31529,13 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 stencilTestEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }

@@ -31559,14 +31559,14 @@ static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkStencilFaceFlags faceMask;
         uint32_t writeMask;
     } *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
+    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->writeMask);
     return STATUS_SUCCESS;
 }

@@ -31590,13 +31590,13 @@ static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkTessellationDomainOrigin domainOrigin;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->domainOrigin);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->domainOrigin);
     return STATUS_SUCCESS;
 }

@@ -31620,22 +31620,22 @@ static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t vertexBindingDescriptionCount;
-        const VkVertexInputBindingDescription2EXT32 *pVertexBindingDescriptions;
+        PTR32 pVertexBindingDescriptions;
         uint32_t vertexAttributeDescriptionCount;
-        const VkVertexInputAttributeDescription2EXT32 *pVertexAttributeDescriptions;
+        PTR32 pVertexAttributeDescriptions;
     } *params = args;
     const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions_host;
     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
+    TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);

init_conversion_context(&ctx);
-    pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, params->pVertexBindingDescriptions, params->vertexBindingDescriptionCount);
-    pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, params->pVertexAttributeDescriptions, params->vertexAttributeDescriptionCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexBindingDescriptionCount, pVertexBindingDescriptions_host, params->vertexAttributeDescriptionCount, pVertexAttributeDescriptions_host);
+    pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
+    pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexBindingDescriptionCount, pVertexBindingDescriptions_host, params->vertexAttributeDescriptionCount, pVertexAttributeDescriptions_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -31660,15 +31660,15 @@ static NTSTATUS thunk32_vkCmdSetViewport(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstViewport;
         uint32_t viewportCount;
-        const VkViewport *pViewports;
+        PTR32 pViewports;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewports);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }

@@ -31692,19 +31692,19 @@ static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstViewport;
         uint32_t viewportCount;
-        const VkShadingRatePaletteNV32 *pShadingRatePalettes;
+        PTR32 pShadingRatePalettes;
     } *params = args;
     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);

init_conversion_context(&ctx);
-    pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, params->pShadingRatePalettes, params->viewportCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, pShadingRatePalettes_host);
+    pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, pShadingRatePalettes_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -31729,15 +31729,15 @@ static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstViewport;
         uint32_t viewportCount;
-        const VkViewportSwizzleNV *pViewportSwizzles;
+        PTR32 pViewportSwizzles;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportSwizzleNV *)UlongToPtr(params->pViewportSwizzles));
     return STATUS_SUCCESS;
 }

@@ -31761,13 +31761,13 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBool32 viewportWScalingEnable;
     } *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
+    TRACE("%#x, %u\n", params->commandBuffer, params->viewportWScalingEnable);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportWScalingEnable);
     return STATUS_SUCCESS;
 }

@@ -31791,15 +31791,15 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t firstViewport;
         uint32_t viewportCount;
-        const VkViewportWScalingNV *pViewportWScalings;
+        PTR32 pViewportWScalings;
     } *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
+    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportWScalingNV *)UlongToPtr(params->pViewportWScalings));
     return STATUS_SUCCESS;
 }

@@ -31823,14 +31823,14 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t viewportCount;
-        const VkViewport *pViewports;
+        PTR32 pViewports;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }

@@ -31854,14 +31854,14 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t viewportCount;
-        const VkViewport *pViewports;
+        PTR32 pViewports;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
+    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }

@@ -31885,12 +31885,12 @@ static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -31914,13 +31914,13 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
+    TRACE("%#x, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectDeviceAddress);
     return STATUS_SUCCESS;
 }

@@ -31944,11 +31944,11 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
+        PTR32 commandBuffer;
+        PTR32 pRaygenShaderBindingTable;
+        PTR32 pMissShaderBindingTable;
+        PTR32 pHitShaderBindingTable;
+        PTR32 pCallableShaderBindingTable;
         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
     } *params = args;
     VkStridedDeviceAddressRegionKHR pRaygenShaderBindingTable_host;
@@ -31956,13 +31956,13 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;

-    TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
+    TRACE("%#x, %#x, %#x, %#x, %#x, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));

-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
     return STATUS_SUCCESS;
 }

@@ -31986,11 +31986,11 @@ static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
-        const VkStridedDeviceAddressRegionKHR32 *pRaygenShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pMissShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pHitShaderBindingTable;
-        const VkStridedDeviceAddressRegionKHR32 *pCallableShaderBindingTable;
+        PTR32 commandBuffer;
+        PTR32 pRaygenShaderBindingTable;
+        PTR32 pMissShaderBindingTable;
+        PTR32 pHitShaderBindingTable;
+        PTR32 pCallableShaderBindingTable;
         uint32_t width;
         uint32_t height;
         uint32_t depth;
@@ -32000,13 +32000,13 @@ static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;

-    TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
+    TRACE("%#x, %#x, %#x, %#x, %#x, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);

-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pRaygenShaderBindingTable, &pRaygenShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pMissShaderBindingTable, &pMissShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pHitShaderBindingTable, &pHitShaderBindingTable_host);
-    convert_VkStridedDeviceAddressRegionKHR_win32_to_host(params->pCallableShaderBindingTable, &pCallableShaderBindingTable_host);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
+    convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
     return STATUS_SUCCESS;
 }

@@ -32030,7 +32030,7 @@ static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) raygenShaderBindingTableBuffer;
         VkDeviceSize DECLSPEC_ALIGN(8) raygenShaderBindingOffset;
         VkBuffer DECLSPEC_ALIGN(8) missShaderBindingTableBuffer;
@@ -32047,9 +32047,9 @@ static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
         uint32_t depth;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
     return STATUS_SUCCESS;
 }

@@ -32073,16 +32073,16 @@ static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
         VkDeviceSize DECLSPEC_ALIGN(8) dataSize;
-        const void *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, params->pData);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -32106,30 +32106,30 @@ static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t eventCount;
-        const VkEvent *pEvents;
+        PTR32 pEvents;
         VkPipelineStageFlags srcStageMask;
         VkPipelineStageFlags dstStageMask;
         uint32_t memoryBarrierCount;
-        const VkMemoryBarrier32 *pMemoryBarriers;
+        PTR32 pMemoryBarriers;
         uint32_t bufferMemoryBarrierCount;
-        const VkBufferMemoryBarrier32 *pBufferMemoryBarriers;
+        PTR32 pBufferMemoryBarriers;
         uint32_t imageMemoryBarrierCount;
-        const VkImageMemoryBarrier32 *pImageMemoryBarriers;
+        PTR32 pImageMemoryBarriers;
     } *params = args;
     const VkMemoryBarrier *pMemoryBarriers_host;
     const VkBufferMemoryBarrier *pBufferMemoryBarriers_host;
     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
+    TRACE("%#x, %u, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);

init_conversion_context(&ctx);
-    pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, params->pMemoryBarriers, params->memoryBarrierCount);
-    pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, params->pBufferMemoryBarriers, params->bufferMemoryBarrierCount);
-    pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, params->pImageMemoryBarriers, params->imageMemoryBarrierCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
+    pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
+    pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
+    pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32154,19 +32154,19 @@ static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t eventCount;
-        const VkEvent *pEvents;
-        const VkDependencyInfo32 *pDependencyInfos;
+        PTR32 pEvents;
+        PTR32 pDependencyInfos;
     } *params = args;
     const VkDependencyInfo *pDependencyInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
+    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);

init_conversion_context(&ctx);
-    pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
+    pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32191,19 +32191,19 @@ static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t eventCount;
-        const VkEvent *pEvents;
-        const VkDependencyInfo32 *pDependencyInfos;
+        PTR32 pEvents;
+        PTR32 pDependencyInfos;
     } *params = args;
     const VkDependencyInfo *pDependencyInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
+    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);

init_conversion_context(&ctx);
-    pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, params->pDependencyInfos, params->eventCount);
-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, pDependencyInfos_host);
+    pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32228,17 +32228,17 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t accelerationStructureCount;
-        const VkAccelerationStructureKHR *pAccelerationStructures;
+        PTR32 pAccelerationStructures;
         VkQueryType queryType;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
+    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }

@@ -32262,17 +32262,17 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t accelerationStructureCount;
-        const VkAccelerationStructureNV *pAccelerationStructures;
+        PTR32 pAccelerationStructures;
         VkQueryType queryType;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
+    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }

@@ -32296,16 +32296,16 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
         uint32_t marker;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }

@@ -32329,16 +32329,16 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlagBits pipelineStage;
         VkBuffer DECLSPEC_ALIGN(8) dstBuffer;
         VkDeviceSize DECLSPEC_ALIGN(8) dstOffset;
         uint32_t marker;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
+    TRACE("%#x, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }

@@ -32362,17 +32362,17 @@ static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         uint32_t micromapCount;
-        const VkMicromapEXT *pMicromaps;
+        PTR32 pMicromaps;
         VkQueryType queryType;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
+    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }

@@ -32396,15 +32396,15 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlagBits pipelineStage;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
+    TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->queryPool, params->query);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }

@@ -32428,15 +32428,15 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
+    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }

@@ -32460,15 +32460,15 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t query;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
+    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);

-    wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
+    wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }

@@ -32492,15 +32492,15 @@ static NTSTATUS thunk32_vkCompileDeferredNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t shader;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);
+    TRACE("%#x, 0x%s, %u\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shader);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCompileDeferredNV(wine_device_from_handle(params->device)->device, params->pipeline, params->shader);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCompileDeferredNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->shader);
     return STATUS_SUCCESS;
 }

@@ -32524,17 +32524,17 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyAccelerationStructureInfoKHR32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32558,17 +32558,17 @@ static NTSTATUS thunk32_vkCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyAccelerationStructureToMemoryInfoKHR32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyAccelerationStructureToMemoryKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32592,17 +32592,17 @@ static NTSTATUS thunk32_vkCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyMemoryToAccelerationStructureInfoKHR32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32626,17 +32626,17 @@ static NTSTATUS thunk32_vkCopyMemoryToMicromapEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyMemoryToMicromapInfoEXT32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyMemoryToMicromapInfoEXT pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMemoryToMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32660,17 +32660,17 @@ static NTSTATUS thunk32_vkCopyMicromapEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyMicromapInfoEXT32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyMicromapInfoEXT pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyMicromapInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32694,17 +32694,17 @@ static NTSTATUS thunk32_vkCopyMicromapToMemoryEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
-        const VkCopyMicromapToMemoryInfoEXT32 *pInfo;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     VkCopyMicromapToMemoryInfoEXT pInfo_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), params->pInfo);

-    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle(params->device)->device, params->deferredOperation, &pInfo_host);
+    convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCopyMicromapToMemoryEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -32728,20 +32728,20 @@ static NTSTATUS thunk32_vkCreateAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAccelerationStructureCreateInfoKHR32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkAccelerationStructureKHR *pAccelerationStructure;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pAccelerationStructure;
         VkResult result;
     } *params = args;
     VkAccelerationStructureCreateInfoKHR pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

init_conversion_context(&ctx);
-    convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
+    convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructure));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32766,20 +32766,20 @@ static NTSTATUS thunk32_vkCreateAccelerationStructureNV(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAccelerationStructureCreateInfoNV32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkAccelerationStructureNV *pAccelerationStructure;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pAccelerationStructure;
         VkResult result;
     } *params = args;
     VkAccelerationStructureCreateInfoNV pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pAccelerationStructure);

init_conversion_context(&ctx);
-    convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pAccelerationStructure);
+    convert_VkAccelerationStructureCreateInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructure));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32804,20 +32804,20 @@ static NTSTATUS thunk32_vkCreateBuffer(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkBuffer *pBuffer;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pBuffer;
         VkResult result;
     } *params = args;
     VkBufferCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pBuffer);

init_conversion_context(&ctx);
-    convert_VkBufferCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pBuffer);
+    convert_VkBufferCreateInfo_win32_to_host(&ctx, (const VkBufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkBuffer *)UlongToPtr(params->pBuffer));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32842,18 +32842,18 @@ static NTSTATUS thunk32_vkCreateBufferView(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferViewCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkBufferView *pView;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pView;
         VkResult result;
     } *params = args;
     VkBufferViewCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

-    convert_VkBufferViewCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateBufferView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
+    convert_VkBufferViewCreateInfo_win32_to_host((const VkBufferViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkBufferView *)UlongToPtr(params->pView));
     return STATUS_SUCCESS;
 }

@@ -32877,19 +32877,19 @@ static NTSTATUS thunk32_vkCreateCommandPool(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkCommandPoolCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkCommandPool *pCommandPool;
-        void *client_ptr;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pCommandPool;
+        PTR32 client_ptr;
         VkResult result;
     } *params = args;
     VkCommandPoolCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pCommandPool);

-    convert_VkCommandPoolCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_vkCreateCommandPool(params->device, &pCreateInfo_host, params->pAllocator, params->pCommandPool, params->client_ptr);
+    convert_VkCommandPoolCreateInfo_win32_to_host((const VkCommandPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_vkCreateCommandPool((VkDevice)UlongToPtr(params->device), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkCommandPool *)UlongToPtr(params->pCommandPool), UlongToPtr(params->client_ptr));
     return STATUS_SUCCESS;
 }

@@ -32918,23 +32918,23 @@ static NTSTATUS thunk32_vkCreateComputePipelines(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
         uint32_t createInfoCount;
-        const VkComputePipelineCreateInfo32 *pCreateInfos;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipeline *pPipelines;
+        PTR32 pCreateInfos;
+        PTR32 pAllocator;
+        PTR32 pPipelines;
         VkResult result;
     } *params = args;
     const VkComputePipelineCreateInfo *pCreateInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

init_conversion_context(&ctx);
-    pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateComputePipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
-    convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
+    pCreateInfos_host = convert_VkComputePipelineCreateInfo_array_win32_to_host(&ctx, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateComputePipelines(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
+    convert_VkComputePipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkComputePipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -32959,18 +32959,18 @@ static NTSTATUS thunk32_vkCreateCuFunctionNVX(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkCuFunctionCreateInfoNVX32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkCuFunctionNVX *pFunction;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pFunction;
         VkResult result;
     } *params = args;
     VkCuFunctionCreateInfoNVX pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFunction);

-    convert_VkCuFunctionCreateInfoNVX_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFunction);
+    convert_VkCuFunctionCreateInfoNVX_win32_to_host((const VkCuFunctionCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkCuFunctionNVX *)UlongToPtr(params->pFunction));
     return STATUS_SUCCESS;
 }

@@ -32994,18 +32994,18 @@ static NTSTATUS thunk32_vkCreateCuModuleNVX(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkCuModuleCreateInfoNVX32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkCuModuleNVX *pModule;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pModule;
         VkResult result;
     } *params = args;
     VkCuModuleCreateInfoNVX pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pModule);

-    convert_VkCuModuleCreateInfoNVX_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pModule);
+    convert_VkCuModuleCreateInfoNVX_win32_to_host((const VkCuModuleCreateInfoNVX32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkCuModuleNVX *)UlongToPtr(params->pModule));
     return STATUS_SUCCESS;
 }

@@ -33029,18 +33029,18 @@ static NTSTATUS thunk32_vkCreateDebugReportCallbackEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
-        const VkDebugReportCallbackCreateInfoEXT32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDebugReportCallbackEXT *pCallback;
+        PTR32 instance;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pCallback;
         VkResult result;
     } *params = args;
     VkDebugReportCallbackCreateInfoEXT pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);
+    TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pCallback);

-    convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_vkCreateDebugReportCallbackEXT(params->instance, &pCreateInfo_host, params->pAllocator, params->pCallback);
+    convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host((const VkDebugReportCallbackCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_vkCreateDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugReportCallbackEXT *)UlongToPtr(params->pCallback));
     return STATUS_SUCCESS;
 }

@@ -33064,18 +33064,18 @@ static NTSTATUS thunk32_vkCreateDebugUtilsMessengerEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
-        const VkDebugUtilsMessengerCreateInfoEXT32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDebugUtilsMessengerEXT *pMessenger;
+        PTR32 instance;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pMessenger;
         VkResult result;
     } *params = args;
     VkDebugUtilsMessengerCreateInfoEXT pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);
+    TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pMessenger);

-    convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_vkCreateDebugUtilsMessengerEXT(params->instance, &pCreateInfo_host, params->pAllocator, params->pMessenger);
+    convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host((const VkDebugUtilsMessengerCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_vkCreateDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkDebugUtilsMessengerEXT *)UlongToPtr(params->pMessenger));
     return STATUS_SUCCESS;
 }

@@ -33099,15 +33099,15 @@ static NTSTATUS thunk32_vkCreateDeferredOperationKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAllocationCallbacks *pAllocator;
-        VkDeferredOperationKHR *pDeferredOperation;
+        PTR32 device;
+        PTR32 pAllocator;
+        PTR32 pDeferredOperation;
         VkResult result;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->device, params->pAllocator, params->pDeferredOperation);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pAllocator, params->pDeferredOperation);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle(params->device)->device, NULL, params->pDeferredOperation);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, NULL, (VkDeferredOperationKHR *)UlongToPtr(params->pDeferredOperation));
     return STATUS_SUCCESS;
 }

@@ -33131,20 +33131,20 @@ static NTSTATUS thunk32_vkCreateDescriptorPool(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorPoolCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDescriptorPool *pDescriptorPool;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pDescriptorPool;
         VkResult result;
     } *params = args;
     VkDescriptorPoolCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorPool);

init_conversion_context(&ctx);
-    convert_VkDescriptorPoolCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorPool(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorPool);
+    convert_VkDescriptorPoolCreateInfo_win32_to_host(&ctx, (const VkDescriptorPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorPool *)UlongToPtr(params->pDescriptorPool));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33169,20 +33169,20 @@ static NTSTATUS thunk32_vkCreateDescriptorSetLayout(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDescriptorSetLayout *pSetLayout;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSetLayout;
         VkResult result;
     } *params = args;
     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSetLayout);

init_conversion_context(&ctx);
-    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSetLayout);
+    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorSetLayout *)UlongToPtr(params->pSetLayout));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33207,20 +33207,20 @@ static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplate(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pDescriptorUpdateTemplate;
         VkResult result;
     } *params = args;
     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

init_conversion_context(&ctx);
-    convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
+    convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorUpdateTemplate *)UlongToPtr(params->pDescriptorUpdateTemplate));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33245,20 +33245,20 @@ static NTSTATUS thunk32_vkCreateDescriptorUpdateTemplateKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorUpdateTemplateCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pDescriptorUpdateTemplate;
         VkResult result;
     } *params = args;
     VkDescriptorUpdateTemplateCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pDescriptorUpdateTemplate);

init_conversion_context(&ctx);
-    convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pDescriptorUpdateTemplate);
+    convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(&ctx, (const VkDescriptorUpdateTemplateCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkDescriptorUpdateTemplate *)UlongToPtr(params->pDescriptorUpdateTemplate));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33288,24 +33288,24 @@ static NTSTATUS thunk32_vkCreateDevice(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkDeviceCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkDevice *pDevice;
-        void *client_ptr;
+        PTR32 physicalDevice;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pDevice;
+        PTR32 client_ptr;
         VkResult result;
     } *params = args;
     VkDeviceCreateInfo pCreateInfo_host;
     VkDevice pDevice_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pCreateInfo, params->pAllocator, params->pDevice);

init_conversion_context(&ctx);
-    convert_VkDeviceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    pDevice_host = *params->pDevice;
-    params->result = wine_vkCreateDevice(params->physicalDevice, &pCreateInfo_host, params->pAllocator, &pDevice_host, params->client_ptr);
-    *params->pDevice = pDevice_host;
+    convert_VkDeviceCreateInfo_win32_to_host(&ctx, (const VkDeviceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    pDevice_host = *(VkDevice *)UlongToPtr(params->pDevice);
+    params->result = wine_vkCreateDevice((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pDevice_host, UlongToPtr(params->client_ptr));
+    *(VkDevice *)UlongToPtr(params->pDevice) = pDevice_host;
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33330,18 +33330,18 @@ static NTSTATUS thunk32_vkCreateEvent(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkEventCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkEvent *pEvent;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pEvent;
         VkResult result;
     } *params = args;
     VkEventCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pEvent);

-    convert_VkEventCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateEvent(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pEvent);
+    convert_VkEventCreateInfo_win32_to_host((const VkEventCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkEvent *)UlongToPtr(params->pEvent));
     return STATUS_SUCCESS;
 }

@@ -33365,20 +33365,20 @@ static NTSTATUS thunk32_vkCreateFence(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkFenceCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkFence *pFence;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pFence;
         VkResult result;
     } *params = args;
     VkFenceCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFence);

init_conversion_context(&ctx);
-    convert_VkFenceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFence(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFence);
+    convert_VkFenceCreateInfo_win32_to_host(&ctx, (const VkFenceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkFence *)UlongToPtr(params->pFence));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33403,20 +33403,20 @@ static NTSTATUS thunk32_vkCreateFramebuffer(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkFramebufferCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkFramebuffer *pFramebuffer;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pFramebuffer;
         VkResult result;
     } *params = args;
     VkFramebufferCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pFramebuffer);

init_conversion_context(&ctx);
-    convert_VkFramebufferCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateFramebuffer(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pFramebuffer);
+    convert_VkFramebufferCreateInfo_win32_to_host(&ctx, (const VkFramebufferCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkFramebuffer *)UlongToPtr(params->pFramebuffer));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33446,23 +33446,23 @@ static NTSTATUS thunk32_vkCreateGraphicsPipelines(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
         uint32_t createInfoCount;
-        const VkGraphicsPipelineCreateInfo32 *pCreateInfos;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipeline *pPipelines;
+        PTR32 pCreateInfos;
+        PTR32 pAllocator;
+        PTR32 pPipelines;
         VkResult result;
     } *params = args;
     const VkGraphicsPipelineCreateInfo *pCreateInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

init_conversion_context(&ctx);
-    pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateGraphicsPipelines(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
-    convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
+    pCreateInfos_host = convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(&ctx, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateGraphicsPipelines(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
+    convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(pCreateInfos_host, (const VkGraphicsPipelineCreateInfo32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33487,20 +33487,20 @@ static NTSTATUS thunk32_vkCreateImage(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkImage *pImage;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pImage;
         VkResult result;
     } *params = args;
     VkImageCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pImage);

init_conversion_context(&ctx);
-    convert_VkImageCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImage(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pImage);
+    convert_VkImageCreateInfo_win32_to_host(&ctx, (const VkImageCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkImage *)UlongToPtr(params->pImage));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33525,20 +33525,20 @@ static NTSTATUS thunk32_vkCreateImageView(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageViewCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkImageView *pView;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pView;
         VkResult result;
     } *params = args;
     VkImageViewCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pView);

init_conversion_context(&ctx);
-    convert_VkImageViewCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateImageView(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pView);
+    convert_VkImageViewCreateInfo_win32_to_host(&ctx, (const VkImageViewCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkImageView *)UlongToPtr(params->pView));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33563,20 +33563,20 @@ static NTSTATUS thunk32_vkCreateIndirectCommandsLayoutNV(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkIndirectCommandsLayoutCreateInfoNV32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkIndirectCommandsLayoutNV *pIndirectCommandsLayout;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pIndirectCommandsLayout;
         VkResult result;
     } *params = args;
     VkIndirectCommandsLayoutCreateInfoNV pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pIndirectCommandsLayout);

init_conversion_context(&ctx);
-    convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pIndirectCommandsLayout);
+    convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(&ctx, (const VkIndirectCommandsLayoutCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkIndirectCommandsLayoutNV *)UlongToPtr(params->pIndirectCommandsLayout));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33606,23 +33606,23 @@ static NTSTATUS thunk32_vkCreateInstance(void *args)
 {
     struct
     {
-        const VkInstanceCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkInstance *pInstance;
-        void *client_ptr;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pInstance;
+        PTR32 client_ptr;
         VkResult result;
     } *params = args;
     VkInstanceCreateInfo pCreateInfo_host;
     VkInstance pInstance_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->pCreateInfo, params->pAllocator, params->pInstance);
+    TRACE("%#x, %#x, %#x\n", params->pCreateInfo, params->pAllocator, params->pInstance);

init_conversion_context(&ctx);
-    convert_VkInstanceCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    pInstance_host = *params->pInstance;
-    params->result = wine_vkCreateInstance(&pCreateInfo_host, params->pAllocator, &pInstance_host, params->client_ptr);
-    *params->pInstance = pInstance_host;
+    convert_VkInstanceCreateInfo_win32_to_host(&ctx, (const VkInstanceCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    pInstance_host = *(VkInstance *)UlongToPtr(params->pInstance);
+    params->result = wine_vkCreateInstance(&pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), &pInstance_host, UlongToPtr(params->client_ptr));
+    *(VkInstance *)UlongToPtr(params->pInstance) = pInstance_host;
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33647,18 +33647,18 @@ static NTSTATUS thunk32_vkCreateMicromapEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkMicromapCreateInfoEXT32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkMicromapEXT *pMicromap;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pMicromap;
         VkResult result;
     } *params = args;
     VkMicromapCreateInfoEXT pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pMicromap);

-    convert_VkMicromapCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateMicromapEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pMicromap);
+    convert_VkMicromapCreateInfoEXT_win32_to_host((const VkMicromapCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkMicromapEXT *)UlongToPtr(params->pMicromap));
     return STATUS_SUCCESS;
 }

@@ -33682,20 +33682,20 @@ static NTSTATUS thunk32_vkCreateOpticalFlowSessionNV(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkOpticalFlowSessionCreateInfoNV32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkOpticalFlowSessionNV *pSession;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSession;
         VkResult result;
     } *params = args;
     VkOpticalFlowSessionCreateInfoNV pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSession);

init_conversion_context(&ctx);
-    convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSession);
+    convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(&ctx, (const VkOpticalFlowSessionCreateInfoNV32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkOpticalFlowSessionNV *)UlongToPtr(params->pSession));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33720,18 +33720,18 @@ static NTSTATUS thunk32_vkCreatePipelineCache(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineCacheCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipelineCache *pPipelineCache;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pPipelineCache;
         VkResult result;
     } *params = args;
     VkPipelineCacheCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineCache);

-    convert_VkPipelineCacheCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineCache(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPipelineCache);
+    convert_VkPipelineCacheCreateInfo_win32_to_host((const VkPipelineCacheCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPipelineCache *)UlongToPtr(params->pPipelineCache));
     return STATUS_SUCCESS;
 }

@@ -33755,18 +33755,18 @@ static NTSTATUS thunk32_vkCreatePipelineLayout(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineLayoutCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipelineLayout *pPipelineLayout;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pPipelineLayout;
         VkResult result;
     } *params = args;
     VkPipelineLayoutCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPipelineLayout);

-    convert_VkPipelineLayoutCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePipelineLayout(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPipelineLayout);
+    convert_VkPipelineLayoutCreateInfo_win32_to_host((const VkPipelineLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPipelineLayout *)UlongToPtr(params->pPipelineLayout));
     return STATUS_SUCCESS;
 }

@@ -33790,18 +33790,18 @@ static NTSTATUS thunk32_vkCreatePrivateDataSlot(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPrivateDataSlotCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkPrivateDataSlot *pPrivateDataSlot;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pPrivateDataSlot;
         VkResult result;
     } *params = args;
     VkPrivateDataSlotCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    convert_VkPrivateDataSlotCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPrivateDataSlot);
+    convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPrivateDataSlot *)UlongToPtr(params->pPrivateDataSlot));
     return STATUS_SUCCESS;
 }

@@ -33825,18 +33825,18 @@ static NTSTATUS thunk32_vkCreatePrivateDataSlotEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPrivateDataSlotCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkPrivateDataSlot *pPrivateDataSlot;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pPrivateDataSlot;
         VkResult result;
     } *params = args;
     VkPrivateDataSlotCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pPrivateDataSlot);

-    convert_VkPrivateDataSlotCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pPrivateDataSlot);
+    convert_VkPrivateDataSlotCreateInfo_win32_to_host((const VkPrivateDataSlotCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreatePrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkPrivateDataSlot *)UlongToPtr(params->pPrivateDataSlot));
     return STATUS_SUCCESS;
 }

@@ -33860,20 +33860,20 @@ static NTSTATUS thunk32_vkCreateQueryPool(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkQueryPoolCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkQueryPool *pQueryPool;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pQueryPool;
         VkResult result;
     } *params = args;
     VkQueryPoolCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pQueryPool);

init_conversion_context(&ctx);
-    convert_VkQueryPoolCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateQueryPool(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pQueryPool);
+    convert_VkQueryPoolCreateInfo_win32_to_host(&ctx, (const VkQueryPoolCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkQueryPool *)UlongToPtr(params->pQueryPool));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33903,24 +33903,24 @@ static NTSTATUS thunk32_vkCreateRayTracingPipelinesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) deferredOperation;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
         uint32_t createInfoCount;
-        const VkRayTracingPipelineCreateInfoKHR32 *pCreateInfos;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipeline *pPipelines;
+        PTR32 pCreateInfos;
+        PTR32 pAllocator;
+        PTR32 pPipelines;
         VkResult result;
     } *params = args;
     const VkRayTracingPipelineCreateInfoKHR *pCreateInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    TRACE("%#x, 0x%s, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

init_conversion_context(&ctx);
-    pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle(params->device)->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
-    convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
+    pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->deferredOperation, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
+    convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoKHR32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33950,23 +33950,23 @@ static NTSTATUS thunk32_vkCreateRayTracingPipelinesNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
         uint32_t createInfoCount;
-        const VkRayTracingPipelineCreateInfoNV32 *pCreateInfos;
-        const VkAllocationCallbacks *pAllocator;
-        VkPipeline *pPipelines;
+        PTR32 pCreateInfos;
+        PTR32 pAllocator;
+        PTR32 pPipelines;
         VkResult result;
     } *params = args;
     const VkRayTracingPipelineCreateInfoNV *pCreateInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
+    TRACE("%#x, 0x%s, %u, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);

init_conversion_context(&ctx);
-    pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, params->pCreateInfos, params->createInfoCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRayTracingPipelinesNV(wine_device_from_handle(params->device)->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, params->pPipelines);
-    convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, params->pCreateInfos, params->createInfoCount);
+    pCreateInfos_host = convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(&ctx, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRayTracingPipelinesNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, params->createInfoCount, pCreateInfos_host, NULL, (VkPipeline *)UlongToPtr(params->pPipelines));
+    convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(pCreateInfos_host, (const VkRayTracingPipelineCreateInfoNV32 *)UlongToPtr(params->pCreateInfos), params->createInfoCount);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -33991,20 +33991,20 @@ static NTSTATUS thunk32_vkCreateRenderPass(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkRenderPassCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkRenderPass *pRenderPass;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pRenderPass;
         VkResult result;
     } *params = args;
     VkRenderPassCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

init_conversion_context(&ctx);
-    convert_VkRenderPassCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
+    convert_VkRenderPassCreateInfo_win32_to_host(&ctx, (const VkRenderPassCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34029,20 +34029,20 @@ static NTSTATUS thunk32_vkCreateRenderPass2(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkRenderPassCreateInfo232 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkRenderPass *pRenderPass;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pRenderPass;
         VkResult result;
     } *params = args;
     VkRenderPassCreateInfo2 pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

init_conversion_context(&ctx);
-    convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
+    convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34067,20 +34067,20 @@ static NTSTATUS thunk32_vkCreateRenderPass2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkRenderPassCreateInfo232 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkRenderPass *pRenderPass;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pRenderPass;
         VkResult result;
     } *params = args;
     VkRenderPassCreateInfo2 pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pRenderPass);

init_conversion_context(&ctx);
-    convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pRenderPass);
+    convert_VkRenderPassCreateInfo2_win32_to_host(&ctx, (const VkRenderPassCreateInfo232 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateRenderPass2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkRenderPass *)UlongToPtr(params->pRenderPass));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34105,20 +34105,20 @@ static NTSTATUS thunk32_vkCreateSampler(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSamplerCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSampler *pSampler;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSampler;
         VkResult result;
     } *params = args;
     VkSamplerCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSampler);

init_conversion_context(&ctx);
-    convert_VkSamplerCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSampler(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSampler);
+    convert_VkSamplerCreateInfo_win32_to_host(&ctx, (const VkSamplerCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSampler *)UlongToPtr(params->pSampler));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34143,18 +34143,18 @@ static NTSTATUS thunk32_vkCreateSamplerYcbcrConversion(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSamplerYcbcrConversionCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSamplerYcbcrConversion *pYcbcrConversion;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pYcbcrConversion;
         VkResult result;
     } *params = args;
     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pYcbcrConversion);
+    convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSamplerYcbcrConversion *)UlongToPtr(params->pYcbcrConversion));
     return STATUS_SUCCESS;
 }

@@ -34178,18 +34178,18 @@ static NTSTATUS thunk32_vkCreateSamplerYcbcrConversionKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSamplerYcbcrConversionCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSamplerYcbcrConversion *pYcbcrConversion;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pYcbcrConversion;
         VkResult result;
     } *params = args;
     VkSamplerYcbcrConversionCreateInfo pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pYcbcrConversion);

-    convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pYcbcrConversion);
+    convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host((const VkSamplerYcbcrConversionCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSamplerYcbcrConversion *)UlongToPtr(params->pYcbcrConversion));
     return STATUS_SUCCESS;
 }

@@ -34213,20 +34213,20 @@ static NTSTATUS thunk32_vkCreateSemaphore(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSemaphoreCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSemaphore *pSemaphore;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSemaphore;
         VkResult result;
     } *params = args;
     VkSemaphoreCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSemaphore);

init_conversion_context(&ctx);
-    convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSemaphore(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSemaphore);
+    convert_VkSemaphoreCreateInfo_win32_to_host(&ctx, (const VkSemaphoreCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSemaphore *)UlongToPtr(params->pSemaphore));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34251,20 +34251,20 @@ static NTSTATUS thunk32_vkCreateShaderModule(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkShaderModuleCreateInfo32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkShaderModule *pShaderModule;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pShaderModule;
         VkResult result;
     } *params = args;
     VkShaderModuleCreateInfo pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pShaderModule);

init_conversion_context(&ctx);
-    convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateShaderModule(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pShaderModule);
+    convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkShaderModule *)UlongToPtr(params->pShaderModule));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34291,20 +34291,20 @@ static NTSTATUS thunk32_vkCreateSwapchainKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSwapchainCreateInfoKHR32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSwapchainKHR *pSwapchain;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSwapchain;
         VkResult result;
     } *params = args;
     VkSwapchainCreateInfoKHR pCreateInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pSwapchain);

init_conversion_context(&ctx);
-    convert_VkSwapchainCreateInfoKHR_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pSwapchain);
+    convert_VkSwapchainCreateInfoKHR_win32_to_host(&ctx, (const VkSwapchainCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateSwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkSwapchainKHR *)UlongToPtr(params->pSwapchain));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -34329,18 +34329,18 @@ static NTSTATUS thunk32_vkCreateValidationCacheEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkValidationCacheCreateInfoEXT32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkValidationCacheEXT *pValidationCache;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pValidationCache;
         VkResult result;
     } *params = args;
     VkValidationCacheCreateInfoEXT pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pAllocator, params->pValidationCache);

-    convert_VkValidationCacheCreateInfoEXT_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, NULL, params->pValidationCache);
+    convert_VkValidationCacheCreateInfoEXT_win32_to_host((const VkValidationCacheCreateInfoEXT32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkCreateValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, NULL, (VkValidationCacheEXT *)UlongToPtr(params->pValidationCache));
     return STATUS_SUCCESS;
 }

@@ -34364,18 +34364,18 @@ static NTSTATUS thunk32_vkCreateWin32SurfaceKHR(void *args)
 {
     struct
     {
-        VkInstance instance;
-        const VkWin32SurfaceCreateInfoKHR32 *pCreateInfo;
-        const VkAllocationCallbacks *pAllocator;
-        VkSurfaceKHR *pSurface;
+        PTR32 instance;
+        PTR32 pCreateInfo;
+        PTR32 pAllocator;
+        PTR32 pSurface;
         VkResult result;
     } *params = args;
     VkWin32SurfaceCreateInfoKHR pCreateInfo_host;

-    TRACE("%p, %p, %p, %p\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);
+    TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->pCreateInfo, params->pAllocator, params->pSurface);

-    convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(params->pCreateInfo, &pCreateInfo_host);
-    params->result = wine_vkCreateWin32SurfaceKHR(params->instance, &pCreateInfo_host, params->pAllocator, params->pSurface);
+    convert_VkWin32SurfaceCreateInfoKHR_win32_to_host((const VkWin32SurfaceCreateInfoKHR32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    params->result = wine_vkCreateWin32SurfaceKHR((VkInstance)UlongToPtr(params->instance), &pCreateInfo_host, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator), (VkSurfaceKHR *)UlongToPtr(params->pSurface));
     return STATUS_SUCCESS;
 }

@@ -34401,16 +34401,16 @@ static NTSTATUS thunk32_vkDebugMarkerSetObjectNameEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDebugMarkerObjectNameInfoEXT32 *pNameInfo;
+        PTR32 device;
+        PTR32 pNameInfo;
         VkResult result;
     } *params = args;
     VkDebugMarkerObjectNameInfoEXT pNameInfo_host;

-    TRACE("%p, %p\n", params->device, params->pNameInfo);
+    TRACE("%#x, %#x\n", params->device, params->pNameInfo);

-    convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host((const VkDebugMarkerObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
     return STATUS_SUCCESS;
 }

@@ -34436,16 +34436,16 @@ static NTSTATUS thunk32_vkDebugMarkerSetObjectTagEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDebugMarkerObjectTagInfoEXT32 *pTagInfo;
+        PTR32 device;
+        PTR32 pTagInfo;
         VkResult result;
     } *params = args;
     VkDebugMarkerObjectTagInfoEXT pTagInfo_host;

-    TRACE("%p, %p\n", params->device, params->pTagInfo);
+    TRACE("%#x, %#x\n", params->device, params->pTagInfo);

-    convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host((const VkDebugMarkerObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDebugMarkerSetObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
     return STATUS_SUCCESS;
 }

@@ -34469,19 +34469,19 @@ static NTSTATUS thunk32_vkDebugReportMessageEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
+        PTR32 instance;
         VkDebugReportFlagsEXT flags;
         VkDebugReportObjectTypeEXT objectType;
         uint64_t DECLSPEC_ALIGN(8) object;
-        size_t location;
+        PTR32 location;
         int32_t messageCode;
-        const char *pLayerPrefix;
-        const char *pMessage;
+        PTR32 pLayerPrefix;
+        PTR32 pMessage;
     } *params = args;

-    TRACE("%p, %#x, %#x, 0x%s, 0x%s, %d, %p, %p\n", params->instance, params->flags, params->objectType, wine_dbgstr_longlong(params->object), wine_dbgstr_longlong(params->location), params->messageCode, params->pLayerPrefix, params->pMessage);
+    TRACE("%#x, %#x, %#x, 0x%s, 0x%s, %d, %#x, %#x\n", params->instance, params->flags, params->objectType, wine_dbgstr_longlong(params->object), wine_dbgstr_longlong(params->location), params->messageCode, params->pLayerPrefix, params->pMessage);

-    wine_instance_from_handle(params->instance)->funcs.p_vkDebugReportMessageEXT(wine_instance_from_handle(params->instance)->instance, params->flags, params->objectType, wine_vk_unwrap_handle(params->objectType, params->object), params->location, params->messageCode, params->pLayerPrefix, params->pMessage);
+    wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->funcs.p_vkDebugReportMessageEXT(wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->instance, params->flags, params->objectType, wine_vk_unwrap_handle(params->objectType, params->object), params->location, params->messageCode, (const char *)UlongToPtr(params->pLayerPrefix), (const char *)UlongToPtr(params->pMessage));
     return STATUS_SUCCESS;
 }

@@ -34505,14 +34505,14 @@ static NTSTATUS thunk32_vkDeferredOperationJoinKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle(params->device)->device, params->operation);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeferredOperationJoinKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
     return STATUS_SUCCESS;
 }

@@ -34536,14 +34536,14 @@ static NTSTATUS thunk32_vkDestroyAccelerationStructureKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
     return STATUS_SUCCESS;
 }

@@ -34567,14 +34567,14 @@ static NTSTATUS thunk32_vkDestroyAccelerationStructureNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyAccelerationStructureNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, NULL);
     return STATUS_SUCCESS;
 }

@@ -34598,14 +34598,14 @@ static NTSTATUS thunk32_vkDestroyBuffer(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyBuffer(wine_device_from_handle(params->device)->device, params->buffer, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, NULL);
     return STATUS_SUCCESS;
 }

@@ -34629,14 +34629,14 @@ static NTSTATUS thunk32_vkDestroyBufferView(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkBufferView DECLSPEC_ALIGN(8) bufferView;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->bufferView), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyBufferView(wine_device_from_handle(params->device)->device, params->bufferView, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyBufferView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->bufferView, NULL);
     return STATUS_SUCCESS;
 }

@@ -34660,14 +34660,14 @@ static NTSTATUS thunk32_vkDestroyCommandPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->pAllocator);

-    wine_vkDestroyCommandPool(params->device, params->commandPool, params->pAllocator);
+    wine_vkDestroyCommandPool((VkDevice)UlongToPtr(params->device), params->commandPool, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -34691,14 +34691,14 @@ static NTSTATUS thunk32_vkDestroyCuFunctionNVX(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCuFunctionNVX DECLSPEC_ALIGN(8) function;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->function), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle(params->device)->device, params->function, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuFunctionNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->function, NULL);
     return STATUS_SUCCESS;
 }

@@ -34722,14 +34722,14 @@ static NTSTATUS thunk32_vkDestroyCuModuleNVX(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCuModuleNVX DECLSPEC_ALIGN(8) module;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->module), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle(params->device)->device, params->module, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyCuModuleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->module, NULL);
     return STATUS_SUCCESS;
 }

@@ -34753,14 +34753,14 @@ static NTSTATUS thunk32_vkDestroyDebugReportCallbackEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
+        PTR32 instance;
         VkDebugReportCallbackEXT DECLSPEC_ALIGN(8) callback;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->callback), params->pAllocator);

-    wine_vkDestroyDebugReportCallbackEXT(params->instance, params->callback, params->pAllocator);
+    wine_vkDestroyDebugReportCallbackEXT((VkInstance)UlongToPtr(params->instance), params->callback, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -34784,14 +34784,14 @@ static NTSTATUS thunk32_vkDestroyDebugUtilsMessengerEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
+        PTR32 instance;
         VkDebugUtilsMessengerEXT DECLSPEC_ALIGN(8) messenger;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->messenger), params->pAllocator);

-    wine_vkDestroyDebugUtilsMessengerEXT(params->instance, params->messenger, params->pAllocator);
+    wine_vkDestroyDebugUtilsMessengerEXT((VkInstance)UlongToPtr(params->instance), params->messenger, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -34815,14 +34815,14 @@ static NTSTATUS thunk32_vkDestroyDeferredOperationKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->operation), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle(params->device)->device, params->operation, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDeferredOperationKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation, NULL);
     return STATUS_SUCCESS;
 }

@@ -34846,14 +34846,14 @@ static NTSTATUS thunk32_vkDestroyDescriptorPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, NULL);
     return STATUS_SUCCESS;
 }

@@ -34877,14 +34877,14 @@ static NTSTATUS thunk32_vkDestroyDescriptorSetLayout(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSetLayout), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle(params->device)->device, params->descriptorSetLayout, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorSetLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSetLayout, NULL);
     return STATUS_SUCCESS;
 }

@@ -34908,14 +34908,14 @@ static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplate(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
     return STATUS_SUCCESS;
 }

@@ -34939,14 +34939,14 @@ static NTSTATUS thunk32_vkDestroyDescriptorUpdateTemplateKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorUpdateTemplate, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorUpdateTemplate, NULL);
     return STATUS_SUCCESS;
 }

@@ -34973,16 +34973,16 @@ static NTSTATUS thunk32_vkDestroyDevice(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 device;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, %p\n", params->device, params->pAllocator);
+    TRACE("%#x, %#x\n", params->device, params->pAllocator);

if (!params->device)
         return STATUS_SUCCESS;

-    wine_vkDestroyDevice(params->device, params->pAllocator);
+    wine_vkDestroyDevice((VkDevice)UlongToPtr(params->device), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -35006,14 +35006,14 @@ static NTSTATUS thunk32_vkDestroyEvent(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkEvent DECLSPEC_ALIGN(8) event;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->event), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyEvent(wine_device_from_handle(params->device)->device, params->event, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event, NULL);
     return STATUS_SUCCESS;
 }

@@ -35037,14 +35037,14 @@ static NTSTATUS thunk32_vkDestroyFence(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkFence DECLSPEC_ALIGN(8) fence;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->fence), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyFence(wine_device_from_handle(params->device)->device, params->fence, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFence(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence, NULL);
     return STATUS_SUCCESS;
 }

@@ -35068,14 +35068,14 @@ static NTSTATUS thunk32_vkDestroyFramebuffer(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyFramebuffer(wine_device_from_handle(params->device)->device, params->framebuffer, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyFramebuffer(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, NULL);
     return STATUS_SUCCESS;
 }

@@ -35099,14 +35099,14 @@ static NTSTATUS thunk32_vkDestroyImage(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyImage(wine_device_from_handle(params->device)->device, params->image, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImage(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, NULL);
     return STATUS_SUCCESS;
 }

@@ -35130,14 +35130,14 @@ static NTSTATUS thunk32_vkDestroyImageView(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImageView DECLSPEC_ALIGN(8) imageView;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyImageView(wine_device_from_handle(params->device)->device, params->imageView, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyImageView(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, NULL);
     return STATUS_SUCCESS;
 }

@@ -35161,14 +35161,14 @@ static NTSTATUS thunk32_vkDestroyIndirectCommandsLayoutNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->indirectCommandsLayout), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle(params->device)->device, params->indirectCommandsLayout, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyIndirectCommandsLayoutNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->indirectCommandsLayout, NULL);
     return STATUS_SUCCESS;
 }

@@ -35195,16 +35195,16 @@ static NTSTATUS thunk32_vkDestroyInstance(void *args)
 {
     struct
     {
-        VkInstance instance;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 instance;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, %p\n", params->instance, params->pAllocator);
+    TRACE("%#x, %#x\n", params->instance, params->pAllocator);

if (!params->instance)
         return STATUS_SUCCESS;

-    wine_vkDestroyInstance(params->instance, params->pAllocator);
+    wine_vkDestroyInstance((VkInstance)UlongToPtr(params->instance), (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -35228,14 +35228,14 @@ static NTSTATUS thunk32_vkDestroyMicromapEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkMicromapEXT DECLSPEC_ALIGN(8) micromap;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->micromap), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle(params->device)->device, params->micromap, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyMicromapEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromap, NULL);
     return STATUS_SUCCESS;
 }

@@ -35259,14 +35259,14 @@ static NTSTATUS thunk32_vkDestroyOpticalFlowSessionNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkOpticalFlowSessionNV DECLSPEC_ALIGN(8) session;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->session), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle(params->device)->device, params->session, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyOpticalFlowSessionNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->session, NULL);
     return STATUS_SUCCESS;
 }

@@ -35290,14 +35290,14 @@ static NTSTATUS thunk32_vkDestroyPipeline(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyPipeline(wine_device_from_handle(params->device)->device, params->pipeline, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipeline(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, NULL);
     return STATUS_SUCCESS;
 }

@@ -35321,14 +35321,14 @@ static NTSTATUS thunk32_vkDestroyPipelineCache(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineCache(wine_device_from_handle(params->device)->device, params->pipelineCache, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineCache(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, NULL);
     return STATUS_SUCCESS;
 }

@@ -35352,14 +35352,14 @@ static NTSTATUS thunk32_vkDestroyPipelineLayout(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineLayout), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle(params->device)->device, params->pipelineLayout, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPipelineLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineLayout, NULL);
     return STATUS_SUCCESS;
 }

@@ -35383,14 +35383,14 @@ static NTSTATUS thunk32_vkDestroyPrivateDataSlot(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlot(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
     return STATUS_SUCCESS;
 }

@@ -35414,14 +35414,14 @@ static NTSTATUS thunk32_vkDestroyPrivateDataSlotEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->privateDataSlot), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle(params->device)->device, params->privateDataSlot, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyPrivateDataSlotEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->privateDataSlot, NULL);
     return STATUS_SUCCESS;
 }

@@ -35445,14 +35445,14 @@ static NTSTATUS thunk32_vkDestroyQueryPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, NULL);
     return STATUS_SUCCESS;
 }

@@ -35476,14 +35476,14 @@ static NTSTATUS thunk32_vkDestroyRenderPass(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyRenderPass(wine_device_from_handle(params->device)->device, params->renderPass, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyRenderPass(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, NULL);
     return STATUS_SUCCESS;
 }

@@ -35507,14 +35507,14 @@ static NTSTATUS thunk32_vkDestroySampler(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSampler DECLSPEC_ALIGN(8) sampler;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->sampler), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroySampler(wine_device_from_handle(params->device)->device, params->sampler, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySampler(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->sampler, NULL);
     return STATUS_SUCCESS;
 }

@@ -35538,14 +35538,14 @@ static NTSTATUS thunk32_vkDestroySamplerYcbcrConversion(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversion(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
     return STATUS_SUCCESS;
 }

@@ -35569,14 +35569,14 @@ static NTSTATUS thunk32_vkDestroySamplerYcbcrConversionKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) ycbcrConversion;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->ycbcrConversion), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle(params->device)->device, params->ycbcrConversion, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySamplerYcbcrConversionKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->ycbcrConversion, NULL);
     return STATUS_SUCCESS;
 }

@@ -35600,14 +35600,14 @@ static NTSTATUS thunk32_vkDestroySemaphore(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroySemaphore(wine_device_from_handle(params->device)->device, params->semaphore, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, NULL);
     return STATUS_SUCCESS;
 }

@@ -35631,14 +35631,14 @@ static NTSTATUS thunk32_vkDestroyShaderModule(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyShaderModule(wine_device_from_handle(params->device)->device, params->shaderModule, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyShaderModule(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, NULL);
     return STATUS_SUCCESS;
 }

@@ -35662,14 +35662,14 @@ static NTSTATUS thunk32_vkDestroySurfaceKHR(void *args)
 {
     struct
     {
-        VkInstance instance;
+        PTR32 instance;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->instance, wine_dbgstr_longlong(params->surface), params->pAllocator);

-    wine_vkDestroySurfaceKHR(params->instance, params->surface, params->pAllocator);
+    wine_vkDestroySurfaceKHR((VkInstance)UlongToPtr(params->instance), params->surface, (const VkAllocationCallbacks *)UlongToPtr(params->pAllocator));
     return STATUS_SUCCESS;
 }

@@ -35693,14 +35693,14 @@ static NTSTATUS thunk32_vkDestroySwapchainKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle(params->device)->device, params->swapchain, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroySwapchainKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, NULL);
     return STATUS_SUCCESS;
 }

@@ -35724,14 +35724,14 @@ static NTSTATUS thunk32_vkDestroyValidationCacheEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle(params->device)->device, params->validationCache, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDestroyValidationCacheEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, NULL);
     return STATUS_SUCCESS;
 }

@@ -35755,13 +35755,13 @@ static NTSTATUS thunk32_vkDeviceWaitIdle(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkResult result;
     } *params = args;

-    TRACE("%p\n", params->device);
+    TRACE("%#x\n", params->device);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkDeviceWaitIdle(wine_device_from_handle(params->device)->device);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkDeviceWaitIdle(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
     return STATUS_SUCCESS;
 }

@@ -35785,13 +35785,13 @@ static NTSTATUS thunk32_vkEndCommandBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkResult result;
     } *params = args;

-    TRACE("%p\n", params->commandBuffer);
+    TRACE("%#x\n", params->commandBuffer);

-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkEndCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }

@@ -35815,16 +35815,16 @@ static NTSTATUS thunk32_vkEnumerateDeviceExtensionProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const char *pLayerName;
-        uint32_t *pPropertyCount;
-        VkExtensionProperties *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pLayerName;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);

-    params->result = wine_vkEnumerateDeviceExtensionProperties(params->physicalDevice, params->pLayerName, params->pPropertyCount, params->pProperties);
+    params->result = wine_vkEnumerateDeviceExtensionProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -35848,15 +35848,15 @@ static NTSTATUS thunk32_vkEnumerateDeviceLayerProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pPropertyCount;
-        VkLayerProperties *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

-    params->result = wine_vkEnumerateDeviceLayerProperties(params->physicalDevice, params->pPropertyCount, params->pProperties);
+    params->result = wine_vkEnumerateDeviceLayerProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkLayerProperties *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -35880,15 +35880,15 @@ static NTSTATUS thunk32_vkEnumerateInstanceExtensionProperties(void *args)
 {
     struct
     {
-        const char *pLayerName;
-        uint32_t *pPropertyCount;
-        VkExtensionProperties *pProperties;
+        PTR32 pLayerName;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->pLayerName, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x\n", params->pLayerName, params->pPropertyCount, params->pProperties);

-    params->result = wine_vkEnumerateInstanceExtensionProperties(params->pLayerName, params->pPropertyCount, params->pProperties);
+    params->result = wine_vkEnumerateInstanceExtensionProperties((const char *)UlongToPtr(params->pLayerName), (uint32_t *)UlongToPtr(params->pPropertyCount), (VkExtensionProperties *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -35912,13 +35912,13 @@ static NTSTATUS thunk32_vkEnumerateInstanceVersion(void *args)
 {
     struct
     {
-        uint32_t *pApiVersion;
+        PTR32 pApiVersion;
         VkResult result;
     } *params = args;

-    TRACE("%p\n", params->pApiVersion);
+    TRACE("%#x\n", params->pApiVersion);

-    params->result = wine_vkEnumerateInstanceVersion(params->pApiVersion);
+    params->result = wine_vkEnumerateInstanceVersion((uint32_t *)UlongToPtr(params->pApiVersion));
     return STATUS_SUCCESS;
 }

@@ -35942,20 +35942,20 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroups(void *args)
 {
     struct
     {
-        VkInstance instance;
-        uint32_t *pPhysicalDeviceGroupCount;
-        VkPhysicalDeviceGroupProperties32 *pPhysicalDeviceGroupProperties;
+        PTR32 instance;
+        PTR32 pPhysicalDeviceGroupCount;
+        PTR32 pPhysicalDeviceGroupProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

init_conversion_context(&ctx);
-    pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
-    params->result = wine_vkEnumeratePhysicalDeviceGroups(params->instance, params->pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties_host);
-    convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
+    pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
+    params->result = wine_vkEnumeratePhysicalDeviceGroups((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
+    convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -35980,20 +35980,20 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
 {
     struct
     {
-        VkInstance instance;
-        uint32_t *pPhysicalDeviceGroupCount;
-        VkPhysicalDeviceGroupProperties32 *pPhysicalDeviceGroupProperties;
+        PTR32 instance;
+        PTR32 pPhysicalDeviceGroupCount;
+        PTR32 pPhysicalDeviceGroupProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);
+    TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceGroupCount, params->pPhysicalDeviceGroupProperties);

init_conversion_context(&ctx);
-    pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
-    params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR(params->instance, params->pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties_host);
-    convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, params->pPhysicalDeviceGroupProperties, *params->pPhysicalDeviceGroupCount);
+    pPhysicalDeviceGroupProperties_host = convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(&ctx, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
+    params->result = wine_vkEnumeratePhysicalDeviceGroupsKHR((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount), pPhysicalDeviceGroupProperties_host);
+    convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(pPhysicalDeviceGroupProperties_host, (VkPhysicalDeviceGroupProperties32 *)UlongToPtr(params->pPhysicalDeviceGroupProperties), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceGroupCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36018,25 +36018,25 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCoun
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         uint32_t queueFamilyIndex;
-        uint32_t *pCounterCount;
-        VkPerformanceCounterKHR32 *pCounters;
-        VkPerformanceCounterDescriptionKHR32 *pCounterDescriptions;
+        PTR32 pCounterCount;
+        PTR32 pCounters;
+        PTR32 pCounterDescriptions;
         VkResult result;
     } *params = args;
     VkPerformanceCounterKHR *pCounters_host;
     VkPerformanceCounterDescriptionKHR *pCounterDescriptions_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p, %p\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);
+    TRACE("%#x, %u, %#x, %#x, %#x\n", params->physicalDevice, params->queueFamilyIndex, params->pCounterCount, params->pCounters, params->pCounterDescriptions);

init_conversion_context(&ctx);
-    pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(&ctx, params->pCounters, *params->pCounterCount);
-    pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(&ctx, params->pCounterDescriptions, *params->pCounterCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, params->pCounterCount, pCounters_host, pCounterDescriptions_host);
-    convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, params->pCounters, *params->pCounterCount);
-    convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, params->pCounterDescriptions, *params->pCounterCount);
+    pCounters_host = convert_VkPerformanceCounterKHR_array_win32_to_host(&ctx, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
+    pCounterDescriptions_host = convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(&ctx, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex, (uint32_t *)UlongToPtr(params->pCounterCount), pCounters_host, pCounterDescriptions_host);
+    convert_VkPerformanceCounterKHR_array_host_to_win32(pCounters_host, (VkPerformanceCounterKHR32 *)UlongToPtr(params->pCounters), *(uint32_t *)UlongToPtr(params->pCounterCount));
+    convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(pCounterDescriptions_host, (VkPerformanceCounterDescriptionKHR32 *)UlongToPtr(params->pCounterDescriptions), *(uint32_t *)UlongToPtr(params->pCounterCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36061,20 +36061,20 @@ static NTSTATUS thunk32_vkEnumeratePhysicalDevices(void *args)
 {
     struct
     {
-        VkInstance instance;
-        uint32_t *pPhysicalDeviceCount;
-        VkPhysicalDevice *pPhysicalDevices;
+        PTR32 instance;
+        PTR32 pPhysicalDeviceCount;
+        PTR32 pPhysicalDevices;
         VkResult result;
     } *params = args;
     VkPhysicalDevice *pPhysicalDevices_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);
+    TRACE("%#x, %#x, %#x\n", params->instance, params->pPhysicalDeviceCount, params->pPhysicalDevices);

init_conversion_context(&ctx);
-    pPhysicalDevices_host = (params->pPhysicalDevices && *params->pPhysicalDeviceCount) ? conversion_context_alloc(&ctx, sizeof(*pPhysicalDevices_host) * *params->pPhysicalDeviceCount) : NULL;
-    params->result = wine_vkEnumeratePhysicalDevices(params->instance, params->pPhysicalDeviceCount, pPhysicalDevices_host);
-    convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, params->pPhysicalDevices, *params->pPhysicalDeviceCount);
+    pPhysicalDevices_host = (params->pPhysicalDevices && *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) ? conversion_context_alloc(&ctx, sizeof(*pPhysicalDevices_host) * *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount)) : NULL;
+    params->result = wine_vkEnumeratePhysicalDevices((VkInstance)UlongToPtr(params->instance), (uint32_t *)UlongToPtr(params->pPhysicalDeviceCount), pPhysicalDevices_host);
+    convert_VkPhysicalDevice_array_unwrapped_host_to_win32(pPhysicalDevices_host, (PTR32 *)UlongToPtr(params->pPhysicalDevices), *(uint32_t *)UlongToPtr(params->pPhysicalDeviceCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36099,19 +36099,19 @@ static NTSTATUS thunk32_vkFlushMappedMemoryRanges(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t memoryRangeCount;
-        const VkMappedMemoryRange32 *pMemoryRanges;
+        PTR32 pMemoryRanges;
         VkResult result;
     } *params = args;
     const VkMappedMemoryRange *pMemoryRanges_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
+    TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

init_conversion_context(&ctx);
-    pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
+    pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFlushMappedMemoryRanges(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memoryRangeCount, pMemoryRanges_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36136,19 +36136,19 @@ static NTSTATUS thunk32_vkFreeCommandBuffers(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
         uint32_t commandBufferCount;
-        const VkCommandBuffer *pCommandBuffers;
+        PTR32 pCommandBuffers;
     } *params = args;
     const VkCommandBuffer *pCommandBuffers_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->commandBufferCount, params->pCommandBuffers);

init_conversion_context(&ctx);
-    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
-    wine_vkFreeCommandBuffers(params->device, params->commandPool, params->commandBufferCount, pCommandBuffers_host);
+    pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_unwrapped_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
+    wine_vkFreeCommandBuffers((VkDevice)UlongToPtr(params->device), params->commandPool, params->commandBufferCount, pCommandBuffers_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36173,16 +36173,16 @@ static NTSTATUS thunk32_vkFreeDescriptorSets(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
         uint32_t descriptorSetCount;
-        const VkDescriptorSet *pDescriptorSets;
+        PTR32 pDescriptorSets;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->descriptorSetCount, params->pDescriptorSets);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkFreeDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorPool, params->descriptorSetCount, params->pDescriptorSets);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFreeDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets));
     return STATUS_SUCCESS;
 }

@@ -36206,14 +36206,14 @@ static NTSTATUS thunk32_vkFreeMemory(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-        const VkAllocationCallbacks *pAllocator;
+        PTR32 pAllocator;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pAllocator);

-    wine_device_from_handle(params->device)->funcs.p_vkFreeMemory(wine_device_from_handle(params->device)->device, params->memory, NULL);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkFreeMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, NULL);
     return STATUS_SUCCESS;
 }

@@ -36237,23 +36237,23 @@ static NTSTATUS thunk32_vkGetAccelerationStructureBuildSizesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkAccelerationStructureBuildTypeKHR buildType;
-        const VkAccelerationStructureBuildGeometryInfoKHR32 *pBuildInfo;
-        const uint32_t *pMaxPrimitiveCounts;
-        VkAccelerationStructureBuildSizesInfoKHR32 *pSizeInfo;
+        PTR32 pBuildInfo;
+        PTR32 pMaxPrimitiveCounts;
+        PTR32 pSizeInfo;
     } *params = args;
     VkAccelerationStructureBuildGeometryInfoKHR pBuildInfo_host;
     VkAccelerationStructureBuildSizesInfoKHR pSizeInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %p, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);
+    TRACE("%#x, %#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pMaxPrimitiveCounts, params->pSizeInfo);

init_conversion_context(&ctx);
-    convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, params->pBuildInfo, &pBuildInfo_host);
-    convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, params->pMaxPrimitiveCounts, &pSizeInfo_host);
-    convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
+    convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
+    convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host((VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureBuildSizesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buildType, &pBuildInfo_host, (const uint32_t *)UlongToPtr(params->pMaxPrimitiveCounts), &pSizeInfo_host);
+    convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(&pSizeInfo_host, (VkAccelerationStructureBuildSizesInfoKHR32 *)UlongToPtr(params->pSizeInfo));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36278,16 +36278,16 @@ static NTSTATUS thunk32_vkGetAccelerationStructureDeviceAddressKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkAccelerationStructureDeviceAddressInfoKHR32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         VkDeviceAddress result;
     } *params = args;
     VkAccelerationStructureDeviceAddressInfoKHR pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host((const VkAccelerationStructureDeviceAddressInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36311,16 +36311,16 @@ static NTSTATUS thunk32_vkGetAccelerationStructureHandleNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure;
-        size_t dataSize;
-        void *pData;
+        PTR32 dataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);
+    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->accelerationStructure), wine_dbgstr_longlong(params->dataSize), params->pData);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle(params->device)->device, params->accelerationStructure, params->dataSize, params->pData);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureHandleNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructure, params->dataSize, (void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -36344,19 +36344,19 @@ static NTSTATUS thunk32_vkGetAccelerationStructureMemoryRequirementsNV(void *arg
 {
     struct
     {
-        VkDevice device;
-        const VkAccelerationStructureMemoryRequirementsInfoNV32 *pInfo;
-        VkMemoryRequirements2KHR32 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkAccelerationStructureMemoryRequirementsInfoNV pInfo_host;
     VkMemoryRequirements2KHR pMemoryRequirements_host;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

-    convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2KHR_win32_to_host(params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host((const VkAccelerationStructureMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2KHR_win32_to_host((VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetAccelerationStructureMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2KHR_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements2KHR32 *)UlongToPtr(params->pMemoryRequirements));
     return STATUS_SUCCESS;
 }

@@ -36380,16 +36380,16 @@ static NTSTATUS thunk32_vkGetBufferDeviceAddress(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferDeviceAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         VkDeviceAddress result;
     } *params = args;
     VkBufferDeviceAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36413,16 +36413,16 @@ static NTSTATUS thunk32_vkGetBufferDeviceAddressEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferDeviceAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         VkDeviceAddress result;
     } *params = args;
     VkBufferDeviceAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36446,16 +36446,16 @@ static NTSTATUS thunk32_vkGetBufferDeviceAddressKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferDeviceAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         VkDeviceAddress result;
     } *params = args;
     VkBufferDeviceAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferDeviceAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36479,16 +36479,16 @@ static NTSTATUS thunk32_vkGetBufferMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkBuffer DECLSPEC_ALIGN(8) buffer;
-        VkMemoryRequirements32 *pMemoryRequirements;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkMemoryRequirements pMemoryRequirements_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->buffer), params->pMemoryRequirements);

-    wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle(params->device)->device, params->buffer, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buffer, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
     return STATUS_SUCCESS;
 }

@@ -36512,21 +36512,21 @@ static NTSTATUS thunk32_vkGetBufferMemoryRequirements2(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferMemoryRequirementsInfo232 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkBufferMemoryRequirementsInfo2 pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36551,21 +36551,21 @@ static NTSTATUS thunk32_vkGetBufferMemoryRequirements2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferMemoryRequirementsInfo232 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkBufferMemoryRequirementsInfo2 pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkBufferMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkBufferMemoryRequirementsInfo2_win32_to_host((const VkBufferMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36590,16 +36590,16 @@ static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddress(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferDeviceAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         uint64_t result;
     } *params = args;
     VkBufferDeviceAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36623,16 +36623,16 @@ static NTSTATUS thunk32_vkGetBufferOpaqueCaptureAddressKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkBufferDeviceAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         uint64_t result;
     } *params = args;
     VkBufferDeviceAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkBufferDeviceAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkBufferDeviceAddressInfo_win32_to_host((const VkBufferDeviceAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetBufferOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -36656,21 +36656,21 @@ static NTSTATUS thunk32_vkGetCalibratedTimestampsEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t timestampCount;
-        const VkCalibratedTimestampInfoEXT32 *pTimestampInfos;
-        uint64_t *pTimestamps;
-        uint64_t *pMaxDeviation;
+        PTR32 pTimestampInfos;
+        PTR32 pTimestamps;
+        PTR32 pMaxDeviation;
         VkResult result;
     } *params = args;
     const VkCalibratedTimestampInfoEXT *pTimestampInfos_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %p, %p\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);
+    TRACE("%#x, %u, %#x, %#x, %#x\n", params->device, params->timestampCount, params->pTimestampInfos, params->pTimestamps, params->pMaxDeviation);

init_conversion_context(&ctx);
-    pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(&ctx, params->pTimestampInfos, params->timestampCount);
-    params->result = wine_vkGetCalibratedTimestampsEXT(params->device, params->timestampCount, pTimestampInfos_host, params->pTimestamps, params->pMaxDeviation);
+    pTimestampInfos_host = convert_VkCalibratedTimestampInfoEXT_array_win32_to_host(&ctx, (const VkCalibratedTimestampInfoEXT32 *)UlongToPtr(params->pTimestampInfos), params->timestampCount);
+    params->result = wine_vkGetCalibratedTimestampsEXT((VkDevice)UlongToPtr(params->device), params->timestampCount, pTimestampInfos_host, (uint64_t *)UlongToPtr(params->pTimestamps), (uint64_t *)UlongToPtr(params->pMaxDeviation));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36695,14 +36695,14 @@ static NTSTATUS thunk32_vkGetDeferredOperationMaxConcurrencyKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
         uint32_t result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle(params->device)->device, params->operation);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
     return STATUS_SUCCESS;
 }

@@ -36726,14 +36726,14 @@ static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeferredOperationKHR DECLSPEC_ALIGN(8) operation;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->operation));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle(params->device)->device, params->operation);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeferredOperationResultKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->operation);
     return STATUS_SUCCESS;
 }

@@ -36757,14 +36757,14 @@ static NTSTATUS thunk32_vkGetDescriptorSetHostMappingVALVE(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
-        void **ppData;
+        PTR32 ppData;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), params->ppData);

-    wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle(params->device)->device, params->descriptorSet, params->ppData);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetHostMappingVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, (void **)UlongToPtr(params->ppData));
     return STATUS_SUCCESS;
 }

@@ -36788,19 +36788,19 @@ static NTSTATUS thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorSetBindingReferenceVALVE32 *pBindingReference;
-        VkDescriptorSetLayoutHostMappingInfoVALVE32 *pHostMapping;
+        PTR32 device;
+        PTR32 pBindingReference;
+        PTR32 pHostMapping;
     } *params = args;
     VkDescriptorSetBindingReferenceVALVE pBindingReference_host;
     VkDescriptorSetLayoutHostMappingInfoVALVE pHostMapping_host;

-    TRACE("%p, %p, %p\n", params->device, params->pBindingReference, params->pHostMapping);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pBindingReference, params->pHostMapping);

-    convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(params->pBindingReference, &pBindingReference_host);
-    convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(params->pHostMapping, &pHostMapping_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle(params->device)->device, &pBindingReference_host, &pHostMapping_host);
-    convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, params->pHostMapping);
+    convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host((const VkDescriptorSetBindingReferenceVALVE32 *)UlongToPtr(params->pBindingReference), &pBindingReference_host);
+    convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host((VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping), &pHostMapping_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutHostMappingInfoVALVE(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pBindingReference_host, &pHostMapping_host);
+    convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(&pHostMapping_host, (VkDescriptorSetLayoutHostMappingInfoVALVE32 *)UlongToPtr(params->pHostMapping));
     return STATUS_SUCCESS;
 }

@@ -36824,21 +36824,21 @@ static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupport(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
-        VkDescriptorSetLayoutSupport32 *pSupport;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pSupport;
     } *params = args;
     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
     VkDescriptorSetLayoutSupport pSupport_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);

init_conversion_context(&ctx);
-    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, params->pSupport, &pSupport_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pSupport_host);
-    convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, params->pSupport);
+    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupport(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
+    convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36863,21 +36863,21 @@ static NTSTATUS thunk32_vkGetDescriptorSetLayoutSupportKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDescriptorSetLayoutCreateInfo32 *pCreateInfo;
-        VkDescriptorSetLayoutSupport32 *pSupport;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pSupport;
     } *params = args;
     VkDescriptorSetLayoutCreateInfo pCreateInfo_host;
     VkDescriptorSetLayoutSupport pSupport_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pSupport);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pSupport);

init_conversion_context(&ctx);
-    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, params->pSupport, &pSupport_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pSupport_host);
-    convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, params->pSupport);
+    convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(&ctx, (const VkDescriptorSetLayoutCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    convert_VkDescriptorSetLayoutSupport_win32_to_host(&ctx, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport), &pSupport_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorSetLayoutSupportKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pSupport_host);
+    convert_VkDescriptorSetLayoutSupport_host_to_win32(&pSupport_host, (VkDescriptorSetLayoutSupport32 *)UlongToPtr(params->pSupport));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36902,16 +36902,16 @@ static NTSTATUS thunk32_vkGetDeviceAccelerationStructureCompatibilityKHR(void *a
 {
     struct
     {
-        VkDevice device;
-        const VkAccelerationStructureVersionInfoKHR32 *pVersionInfo;
-        VkAccelerationStructureCompatibilityKHR *pCompatibility;
+        PTR32 device;
+        PTR32 pVersionInfo;
+        PTR32 pCompatibility;
     } *params = args;
     VkAccelerationStructureVersionInfoKHR pVersionInfo_host;

-    TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);

-    convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(params->pVersionInfo, &pVersionInfo_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle(params->device)->device, &pVersionInfo_host, params->pCompatibility);
+    convert_VkAccelerationStructureVersionInfoKHR_win32_to_host((const VkAccelerationStructureVersionInfoKHR32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pVersionInfo_host, (VkAccelerationStructureCompatibilityKHR *)UlongToPtr(params->pCompatibility));
     return STATUS_SUCCESS;
 }

@@ -36935,21 +36935,21 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceBufferMemoryRequirements32 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkDeviceBufferMemoryRequirements pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -36974,21 +36974,21 @@ static NTSTATUS thunk32_vkGetDeviceBufferMemoryRequirementsKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceBufferMemoryRequirements32 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkDeviceBufferMemoryRequirements pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkDeviceBufferMemoryRequirements_win32_to_host(&ctx, (const VkDeviceBufferMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceBufferMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37013,27 +37013,27 @@ static NTSTATUS thunk32_vkGetDeviceFaultInfoEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        VkDeviceFaultCountsEXT32 *pFaultCounts;
-        VkDeviceFaultInfoEXT32 *pFaultInfo;
+        PTR32 device;
+        PTR32 pFaultCounts;
+        PTR32 pFaultInfo;
         VkResult result;
     } *params = args;
     VkDeviceFaultCountsEXT pFaultCounts_host;
     VkDeviceFaultInfoEXT *pFaultInfo_host = NULL;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pFaultCounts, params->pFaultInfo);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pFaultCounts, params->pFaultInfo);

init_conversion_context(&ctx);
-    convert_VkDeviceFaultCountsEXT_win32_to_host(params->pFaultCounts, &pFaultCounts_host);
+    convert_VkDeviceFaultCountsEXT_win32_to_host((VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts), &pFaultCounts_host);
     if (params->pFaultInfo)
     {
         pFaultInfo_host = conversion_context_alloc(&ctx, sizeof(*pFaultInfo_host));
-        convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, params->pFaultInfo, pFaultInfo_host);
+        convert_VkDeviceFaultInfoEXT_win32_to_host(&ctx, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo), pFaultInfo_host);
     }
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle(params->device)->device, &pFaultCounts_host, pFaultInfo_host);
-    convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, params->pFaultCounts);
-    convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, params->pFaultInfo);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceFaultInfoEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pFaultCounts_host, pFaultInfo_host);
+    convert_VkDeviceFaultCountsEXT_host_to_win32(&pFaultCounts_host, (VkDeviceFaultCountsEXT32 *)UlongToPtr(params->pFaultCounts));
+    convert_VkDeviceFaultInfoEXT_host_to_win32(pFaultInfo_host, (VkDeviceFaultInfoEXT32 *)UlongToPtr(params->pFaultInfo));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37058,16 +37058,16 @@ static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeatures(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t heapIndex;
         uint32_t localDeviceIndex;
         uint32_t remoteDeviceIndex;
-        VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
+        PTR32 pPeerMemoryFeatures;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
+    TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);

-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, (VkPeerMemoryFeatureFlags *)UlongToPtr(params->pPeerMemoryFeatures));
     return STATUS_SUCCESS;
 }

@@ -37091,16 +37091,16 @@ static NTSTATUS thunk32_vkGetDeviceGroupPeerMemoryFeaturesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t heapIndex;
         uint32_t localDeviceIndex;
         uint32_t remoteDeviceIndex;
-        VkPeerMemoryFeatureFlags *pPeerMemoryFeatures;
+        PTR32 pPeerMemoryFeatures;
     } *params = args;

-    TRACE("%p, %u, %u, %u, %p\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
+    TRACE("%#x, %u, %u, %u, %#x\n", params->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);

-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle(params->device)->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, params->pPeerMemoryFeatures);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->heapIndex, params->localDeviceIndex, params->remoteDeviceIndex, (VkPeerMemoryFeatureFlags *)UlongToPtr(params->pPeerMemoryFeatures));
     return STATUS_SUCCESS;
 }

@@ -37124,17 +37124,17 @@ static NTSTATUS thunk32_vkGetDeviceGroupPresentCapabilitiesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        VkDeviceGroupPresentCapabilitiesKHR32 *pDeviceGroupPresentCapabilities;
+        PTR32 device;
+        PTR32 pDeviceGroupPresentCapabilities;
         VkResult result;
     } *params = args;
     VkDeviceGroupPresentCapabilitiesKHR pDeviceGroupPresentCapabilities_host;

-    TRACE("%p, %p\n", params->device, params->pDeviceGroupPresentCapabilities);
+    TRACE("%#x, %#x\n", params->device, params->pDeviceGroupPresentCapabilities);

-    convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(params->pDeviceGroupPresentCapabilities, &pDeviceGroupPresentCapabilities_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle(params->device)->device, &pDeviceGroupPresentCapabilities_host);
-    convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, params->pDeviceGroupPresentCapabilities);
+    convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host((VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities), &pDeviceGroupPresentCapabilities_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDeviceGroupPresentCapabilities_host);
+    convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(&pDeviceGroupPresentCapabilities_host, (VkDeviceGroupPresentCapabilitiesKHR32 *)UlongToPtr(params->pDeviceGroupPresentCapabilities));
     return STATUS_SUCCESS;
 }

@@ -37158,15 +37158,15 @@ static NTSTATUS thunk32_vkGetDeviceGroupSurfacePresentModesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        VkDeviceGroupPresentModeFlagsKHR *pModes;
+        PTR32 pModes;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->surface), params->pModes);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle(params->device)->device, wine_surface_from_handle(params->surface)->driver_surface, params->pModes);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_surface_from_handle(params->surface)->driver_surface, (VkDeviceGroupPresentModeFlagsKHR *)UlongToPtr(params->pModes));
     return STATUS_SUCCESS;
 }

@@ -37190,21 +37190,21 @@ static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceImageMemoryRequirements32 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkDeviceImageMemoryRequirements pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37229,21 +37229,21 @@ static NTSTATUS thunk32_vkGetDeviceImageMemoryRequirementsKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceImageMemoryRequirements32 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkDeviceImageMemoryRequirements pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37268,22 +37268,22 @@ static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceImageMemoryRequirements32 *pInfo;
-        uint32_t *pSparseMemoryRequirementCount;
-        VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pSparseMemoryRequirementCount;
+        PTR32 pSparseMemoryRequirements;
     } *params = args;
     VkDeviceImageMemoryRequirements pInfo_host;
     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
-    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
+    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageSparseMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
+    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37308,22 +37308,22 @@ static NTSTATUS thunk32_vkGetDeviceImageSparseMemoryRequirementsKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceImageMemoryRequirements32 *pInfo;
-        uint32_t *pSparseMemoryRequirementCount;
-        VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pSparseMemoryRequirementCount;
+        PTR32 pSparseMemoryRequirements;
     } *params = args;
     VkDeviceImageMemoryRequirements pInfo_host;
     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
-    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
+    convert_VkDeviceImageMemoryRequirements_win32_to_host(&ctx, (const VkDeviceImageMemoryRequirements32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceImageSparseMemoryRequirementsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
+    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37348,14 +37348,14 @@ static NTSTATUS thunk32_vkGetDeviceMemoryCommitment(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
-        VkDeviceSize *pCommittedMemoryInBytes;
+        PTR32 pCommittedMemoryInBytes;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->memory), params->pCommittedMemoryInBytes);

-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle(params->device)->device, params->memory, params->pCommittedMemoryInBytes);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryCommitment(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, (VkDeviceSize *)UlongToPtr(params->pCommittedMemoryInBytes));
     return STATUS_SUCCESS;
 }

@@ -37379,16 +37379,16 @@ static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddress(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         uint64_t result;
     } *params = args;
     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddress(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -37412,16 +37412,16 @@ static NTSTATUS thunk32_vkGetDeviceMemoryOpaqueCaptureAddressKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceMemoryOpaqueCaptureAddressInfo32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         uint64_t result;
     } *params = args;
     VkDeviceMemoryOpaqueCaptureAddressInfo pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host((const VkDeviceMemoryOpaqueCaptureAddressInfo32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -37445,16 +37445,16 @@ static NTSTATUS thunk32_vkGetDeviceMicromapCompatibilityEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkMicromapVersionInfoEXT32 *pVersionInfo;
-        VkAccelerationStructureCompatibilityKHR *pCompatibility;
+        PTR32 device;
+        PTR32 pVersionInfo;
+        PTR32 pCompatibility;
     } *params = args;
     VkMicromapVersionInfoEXT pVersionInfo_host;

-    TRACE("%p, %p, %p\n", params->device, params->pVersionInfo, params->pCompatibility);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pVersionInfo, params->pCompatibility);

-    convert_VkMicromapVersionInfoEXT_win32_to_host(params->pVersionInfo, &pVersionInfo_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle(params->device)->device, &pVersionInfo_host, params->pCompatibility);
+    convert_VkMicromapVersionInfoEXT_win32_to_host((const VkMicromapVersionInfoEXT32 *)UlongToPtr(params->pVersionInfo), &pVersionInfo_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceMicromapCompatibilityEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pVersionInfo_host, (VkAccelerationStructureCompatibilityKHR *)UlongToPtr(params->pCompatibility));
     return STATUS_SUCCESS;
 }

@@ -37478,18 +37478,18 @@ static NTSTATUS thunk32_vkGetDeviceQueue(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t queueFamilyIndex;
         uint32_t queueIndex;
-        VkQueue *pQueue;
+        PTR32 pQueue;
     } *params = args;
     VkQueue pQueue_host;

-    TRACE("%p, %u, %u, %p\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);
+    TRACE("%#x, %u, %u, %#x\n", params->device, params->queueFamilyIndex, params->queueIndex, params->pQueue);

-    pQueue_host = *params->pQueue;
-    wine_vkGetDeviceQueue(params->device, params->queueFamilyIndex, params->queueIndex, &pQueue_host);
-    *params->pQueue = pQueue_host;
+    pQueue_host = *(VkQueue *)UlongToPtr(params->pQueue);
+    wine_vkGetDeviceQueue((VkDevice)UlongToPtr(params->device), params->queueFamilyIndex, params->queueIndex, &pQueue_host);
+    *(VkQueue *)UlongToPtr(params->pQueue) = pQueue_host;
     return STATUS_SUCCESS;
 }

@@ -37513,19 +37513,19 @@ static NTSTATUS thunk32_vkGetDeviceQueue2(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDeviceQueueInfo232 *pQueueInfo;
-        VkQueue *pQueue;
+        PTR32 device;
+        PTR32 pQueueInfo;
+        PTR32 pQueue;
     } *params = args;
     VkDeviceQueueInfo2 pQueueInfo_host;
     VkQueue pQueue_host;

-    TRACE("%p, %p, %p\n", params->device, params->pQueueInfo, params->pQueue);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pQueueInfo, params->pQueue);

-    convert_VkDeviceQueueInfo2_win32_to_host(params->pQueueInfo, &pQueueInfo_host);
-    pQueue_host = *params->pQueue;
-    wine_vkGetDeviceQueue2(params->device, &pQueueInfo_host, &pQueue_host);
-    *params->pQueue = pQueue_host;
+    convert_VkDeviceQueueInfo2_win32_to_host((const VkDeviceQueueInfo232 *)UlongToPtr(params->pQueueInfo), &pQueueInfo_host);
+    pQueue_host = *(VkQueue *)UlongToPtr(params->pQueue);
+    wine_vkGetDeviceQueue2((VkDevice)UlongToPtr(params->device), &pQueueInfo_host, &pQueue_host);
+    *(VkQueue *)UlongToPtr(params->pQueue) = pQueue_host;
     return STATUS_SUCCESS;
 }

@@ -37549,15 +37549,15 @@ static NTSTATUS thunk32_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(void *ar
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkRenderPass DECLSPEC_ALIGN(8) renderpass;
-        VkExtent2D *pMaxWorkgroupSize;
+        PTR32 pMaxWorkgroupSize;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderpass), params->pMaxWorkgroupSize);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle(params->device)->device, params->renderpass, params->pMaxWorkgroupSize);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderpass, (VkExtent2D *)UlongToPtr(params->pMaxWorkgroupSize));
     return STATUS_SUCCESS;
 }

@@ -37581,22 +37581,22 @@ static NTSTATUS thunk32_vkGetDynamicRenderingTilePropertiesQCOM(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkRenderingInfo32 *pRenderingInfo;
-        VkTilePropertiesQCOM32 *pProperties;
+        PTR32 device;
+        PTR32 pRenderingInfo;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;
     VkRenderingInfo pRenderingInfo_host;
     VkTilePropertiesQCOM pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pRenderingInfo, params->pProperties);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pRenderingInfo, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkRenderingInfo_win32_to_host(&ctx, params->pRenderingInfo, &pRenderingInfo_host);
-    convert_VkTilePropertiesQCOM_win32_to_host(params->pProperties, &pProperties_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle(params->device)->device, &pRenderingInfo_host, &pProperties_host);
-    convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, params->pProperties);
+    convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
+    convert_VkTilePropertiesQCOM_win32_to_host((VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), &pProperties_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDynamicRenderingTilePropertiesQCOM(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pRenderingInfo_host, &pProperties_host);
+    convert_VkTilePropertiesQCOM_host_to_win32(&pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37621,14 +37621,14 @@ static NTSTATUS thunk32_vkGetEventStatus(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetEventStatus(wine_device_from_handle(params->device)->device, params->event);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetEventStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
     return STATUS_SUCCESS;
 }

@@ -37652,14 +37652,14 @@ static NTSTATUS thunk32_vkGetFenceStatus(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkFence DECLSPEC_ALIGN(8) fence;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->fence));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFenceStatus(wine_device_from_handle(params->device)->device, params->fence);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFenceStatus(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fence);
     return STATUS_SUCCESS;
 }

@@ -37683,21 +37683,21 @@ static NTSTATUS thunk32_vkGetFramebufferTilePropertiesQCOM(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkFramebuffer DECLSPEC_ALIGN(8) framebuffer;
-        uint32_t *pPropertiesCount;
-        VkTilePropertiesQCOM32 *pProperties;
+        PTR32 pPropertiesCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;
     VkTilePropertiesQCOM *pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->framebuffer), params->pPropertiesCount, params->pProperties);

init_conversion_context(&ctx);
-    pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(&ctx, params->pProperties, *params->pPropertiesCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle(params->device)->device, params->framebuffer, params->pPropertiesCount, pProperties_host);
-    convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertiesCount);
+    pProperties_host = convert_VkTilePropertiesQCOM_array_win32_to_host(&ctx, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetFramebufferTilePropertiesQCOM(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->framebuffer, (uint32_t *)UlongToPtr(params->pPropertiesCount), pProperties_host);
+    convert_VkTilePropertiesQCOM_array_host_to_win32(pProperties_host, (VkTilePropertiesQCOM32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertiesCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37722,21 +37722,21 @@ static NTSTATUS thunk32_vkGetGeneratedCommandsMemoryRequirementsNV(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkGeneratedCommandsMemoryRequirementsInfoNV32 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkGeneratedCommandsMemoryRequirementsInfoNV pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host((const VkGeneratedCommandsMemoryRequirementsInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetGeneratedCommandsMemoryRequirementsNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37761,16 +37761,16 @@ static NTSTATUS thunk32_vkGetImageMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
-        VkMemoryRequirements32 *pMemoryRequirements;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkMemoryRequirements pMemoryRequirements_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pMemoryRequirements);

-    wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements32 *)UlongToPtr(params->pMemoryRequirements));
     return STATUS_SUCCESS;
 }

@@ -37794,21 +37794,21 @@ static NTSTATUS thunk32_vkGetImageMemoryRequirements2(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageMemoryRequirementsInfo232 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkImageMemoryRequirementsInfo2 pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37833,21 +37833,21 @@ static NTSTATUS thunk32_vkGetImageMemoryRequirements2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageMemoryRequirementsInfo232 *pInfo;
-        VkMemoryRequirements232 *pMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pMemoryRequirements;
     } *params = args;
     VkImageMemoryRequirementsInfo2 pInfo_host;
     VkMemoryRequirements2 pMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pInfo, params->pMemoryRequirements);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pInfo, params->pMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, params->pInfo, &pInfo_host);
-    convert_VkMemoryRequirements2_win32_to_host(&ctx, params->pMemoryRequirements, &pMemoryRequirements_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, &pMemoryRequirements_host);
-    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, params->pMemoryRequirements);
+    convert_VkImageMemoryRequirementsInfo2_win32_to_host(&ctx, (const VkImageMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    convert_VkMemoryRequirements2_win32_to_host(&ctx, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements), &pMemoryRequirements_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, &pMemoryRequirements_host);
+    convert_VkMemoryRequirements2_host_to_win32(&pMemoryRequirements_host, (VkMemoryRequirements232 *)UlongToPtr(params->pMemoryRequirements));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37872,20 +37872,20 @@ static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
-        uint32_t *pSparseMemoryRequirementCount;
-        VkSparseImageMemoryRequirements32 *pSparseMemoryRequirements;
+        PTR32 pSparseMemoryRequirementCount;
+        PTR32 pSparseMemoryRequirements;
     } *params = args;
     VkSparseImageMemoryRequirements *pSparseMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);

init_conversion_context(&ctx);
-    pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *params->pSparseMemoryRequirementCount) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *params->pSparseMemoryRequirementCount) : NULL;
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle(params->device)->device, params->image, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
-    convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
+    pSparseMemoryRequirements_host = (params->pSparseMemoryRequirements && *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) ? conversion_context_alloc(&ctx, sizeof(*pSparseMemoryRequirements_host) * *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount)) : NULL;
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
+    convert_VkSparseImageMemoryRequirements_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements32 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37910,22 +37910,22 @@ static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageSparseMemoryRequirementsInfo232 *pInfo;
-        uint32_t *pSparseMemoryRequirementCount;
-        VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pSparseMemoryRequirementCount;
+        PTR32 pSparseMemoryRequirements;
     } *params = args;
     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
-    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
-    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
+    convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements2(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
+    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37950,22 +37950,22 @@ static NTSTATUS thunk32_vkGetImageSparseMemoryRequirements2KHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageSparseMemoryRequirementsInfo232 *pInfo;
-        uint32_t *pSparseMemoryRequirementCount;
-        VkSparseImageMemoryRequirements232 *pSparseMemoryRequirements;
+        PTR32 device;
+        PTR32 pInfo;
+        PTR32 pSparseMemoryRequirementCount;
+        PTR32 pSparseMemoryRequirements;
     } *params = args;
     VkImageSparseMemoryRequirementsInfo2 pInfo_host;
     VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pInfo, params->pSparseMemoryRequirementCount, params->pSparseMemoryRequirements);

init_conversion_context(&ctx);
-    convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(params->pInfo, &pInfo_host);
-    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle(params->device)->device, &pInfo_host, params->pSparseMemoryRequirementCount, pSparseMemoryRequirements_host);
-    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, params->pSparseMemoryRequirements, *params->pSparseMemoryRequirementCount);
+    convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host((const VkImageSparseMemoryRequirementsInfo232 *)UlongToPtr(params->pInfo), &pInfo_host);
+    pSparseMemoryRequirements_host = convert_VkSparseImageMemoryRequirements2_array_win32_to_host(&ctx, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSparseMemoryRequirements2KHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host, (uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount), pSparseMemoryRequirements_host);
+    convert_VkSparseImageMemoryRequirements2_array_host_to_win32(pSparseMemoryRequirements_host, (VkSparseImageMemoryRequirements232 *)UlongToPtr(params->pSparseMemoryRequirements), *(uint32_t *)UlongToPtr(params->pSparseMemoryRequirementCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -37990,17 +37990,17 @@ static NTSTATUS thunk32_vkGetImageSubresourceLayout(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
-        const VkImageSubresource *pSubresource;
-        VkSubresourceLayout32 *pLayout;
+        PTR32 pSubresource;
+        PTR32 pLayout;
     } *params = args;
     VkSubresourceLayout pLayout_host;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);

-    wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle(params->device)->device, params->image, params->pSubresource, &pLayout_host);
-    convert_VkSubresourceLayout_host_to_win32(&pLayout_host, params->pLayout);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSubresourceLayout(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, (const VkImageSubresource *)UlongToPtr(params->pSubresource), &pLayout_host);
+    convert_VkSubresourceLayout_host_to_win32(&pLayout_host, (VkSubresourceLayout32 *)UlongToPtr(params->pLayout));
     return STATUS_SUCCESS;
 }

@@ -38024,22 +38024,22 @@ static NTSTATUS thunk32_vkGetImageSubresourceLayout2EXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImage DECLSPEC_ALIGN(8) image;
-        const VkImageSubresource2EXT32 *pSubresource;
-        VkSubresourceLayout2EXT32 *pLayout;
+        PTR32 pSubresource;
+        PTR32 pLayout;
     } *params = args;
     VkImageSubresource2EXT pSubresource_host;
     VkSubresourceLayout2EXT pLayout_host;
     struct conversion_context ctx;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->image), params->pSubresource, params->pLayout);

init_conversion_context(&ctx);
-    convert_VkImageSubresource2EXT_win32_to_host(params->pSubresource, &pSubresource_host);
-    convert_VkSubresourceLayout2EXT_win32_to_host(&ctx, params->pLayout, &pLayout_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle(params->device)->device, params->image, &pSubresource_host, &pLayout_host);
-    convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, params->pLayout);
+    convert_VkImageSubresource2EXT_win32_to_host((const VkImageSubresource2EXT32 *)UlongToPtr(params->pSubresource), &pSubresource_host);
+    convert_VkSubresourceLayout2EXT_win32_to_host(&ctx, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout), &pLayout_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageSubresourceLayout2EXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->image, &pSubresource_host, &pLayout_host);
+    convert_VkSubresourceLayout2EXT_host_to_win32(&pLayout_host, (VkSubresourceLayout2EXT32 *)UlongToPtr(params->pLayout));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38064,18 +38064,18 @@ static NTSTATUS thunk32_vkGetImageViewAddressNVX(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkImageView DECLSPEC_ALIGN(8) imageView;
-        VkImageViewAddressPropertiesNVX32 *pProperties;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;
     VkImageViewAddressPropertiesNVX pProperties_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->imageView), params->pProperties);

-    convert_VkImageViewAddressPropertiesNVX_win32_to_host(params->pProperties, &pProperties_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle(params->device)->device, params->imageView, &pProperties_host);
-    convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, params->pProperties);
+    convert_VkImageViewAddressPropertiesNVX_win32_to_host((VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties), &pProperties_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewAddressNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->imageView, &pProperties_host);
+    convert_VkImageViewAddressPropertiesNVX_host_to_win32(&pProperties_host, (VkImageViewAddressPropertiesNVX32 *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -38099,16 +38099,16 @@ static NTSTATUS thunk32_vkGetImageViewHandleNVX(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkImageViewHandleInfoNVX32 *pInfo;
+        PTR32 device;
+        PTR32 pInfo;
         uint32_t result;
     } *params = args;
     VkImageViewHandleInfoNVX pInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInfo);

-    convert_VkImageViewHandleInfoNVX_win32_to_host(params->pInfo, &pInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle(params->device)->device, &pInfo_host);
+    convert_VkImageViewHandleInfoNVX_win32_to_host((const VkImageViewHandleInfoNVX32 *)UlongToPtr(params->pInfo), &pInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetImageViewHandleNVX(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInfo_host);
     return STATUS_SUCCESS;
 }

@@ -38132,19 +38132,19 @@ static NTSTATUS thunk32_vkGetMemoryHostPointerPropertiesEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkExternalMemoryHandleTypeFlagBits handleType;
-        const void *pHostPointer;
-        VkMemoryHostPointerPropertiesEXT32 *pMemoryHostPointerProperties;
+        PTR32 pHostPointer;
+        PTR32 pMemoryHostPointerProperties;
         VkResult result;
     } *params = args;
     VkMemoryHostPointerPropertiesEXT pMemoryHostPointerProperties_host;

-    TRACE("%p, %#x, %p, %p\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->handleType, params->pHostPointer, params->pMemoryHostPointerProperties);

-    convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(params->pMemoryHostPointerProperties, &pMemoryHostPointerProperties_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle(params->device)->device, params->handleType, params->pHostPointer, &pMemoryHostPointerProperties_host);
-    convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, params->pMemoryHostPointerProperties);
+    convert_VkMemoryHostPointerPropertiesEXT_win32_to_host((VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties), &pMemoryHostPointerProperties_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetMemoryHostPointerPropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->handleType, (const void *)UlongToPtr(params->pHostPointer), &pMemoryHostPointerProperties_host);
+    convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(&pMemoryHostPointerProperties_host, (VkMemoryHostPointerPropertiesEXT32 *)UlongToPtr(params->pMemoryHostPointerProperties));
     return STATUS_SUCCESS;
 }

@@ -38168,20 +38168,20 @@ static NTSTATUS thunk32_vkGetMicromapBuildSizesEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkAccelerationStructureBuildTypeKHR buildType;
-        const VkMicromapBuildInfoEXT32 *pBuildInfo;
-        VkMicromapBuildSizesInfoEXT32 *pSizeInfo;
+        PTR32 pBuildInfo;
+        PTR32 pSizeInfo;
     } *params = args;
     VkMicromapBuildInfoEXT pBuildInfo_host;
     VkMicromapBuildSizesInfoEXT pSizeInfo_host;

-    TRACE("%p, %#x, %p, %p\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->buildType, params->pBuildInfo, params->pSizeInfo);

-    convert_VkMicromapBuildInfoEXT_win32_to_host(params->pBuildInfo, &pBuildInfo_host);
-    convert_VkMicromapBuildSizesInfoEXT_win32_to_host(params->pSizeInfo, &pSizeInfo_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle(params->device)->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
-    convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, params->pSizeInfo);
+    convert_VkMicromapBuildInfoEXT_win32_to_host((const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pBuildInfo), &pBuildInfo_host);
+    convert_VkMicromapBuildSizesInfoEXT_win32_to_host((VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo), &pSizeInfo_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetMicromapBuildSizesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->buildType, &pBuildInfo_host, &pSizeInfo_host);
+    convert_VkMicromapBuildSizesInfoEXT_host_to_win32(&pSizeInfo_host, (VkMicromapBuildSizesInfoEXT32 *)UlongToPtr(params->pSizeInfo));
     return STATUS_SUCCESS;
 }

@@ -38205,18 +38205,18 @@ static NTSTATUS thunk32_vkGetPerformanceParameterINTEL(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPerformanceParameterTypeINTEL parameter;
-        VkPerformanceValueINTEL32 *pValue;
+        PTR32 pValue;
         VkResult result;
     } *params = args;
     VkPerformanceValueINTEL pValue_host;

-    TRACE("%p, %#x, %p\n", params->device, params->parameter, params->pValue);
+    TRACE("%#x, %#x, %#x\n", params->device, params->parameter, params->pValue);

-    convert_VkPerformanceValueINTEL_win32_to_host(params->pValue, &pValue_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle(params->device)->device, params->parameter, &pValue_host);
-    convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, params->pValue);
+    convert_VkPerformanceValueINTEL_win32_to_host((VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue), &pValue_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPerformanceParameterINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->parameter, &pValue_host);
+    convert_VkPerformanceValueINTEL_host_to_win32(&pValue_host, (VkPerformanceValueINTEL32 *)UlongToPtr(params->pValue));
     return STATUS_SUCCESS;
 }

@@ -38240,15 +38240,15 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *arg
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pTimeDomainCount;
-        VkTimeDomainEXT *pTimeDomains;
+        PTR32 physicalDevice;
+        PTR32 pTimeDomainCount;
+        PTR32 pTimeDomains;
         VkResult result;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);

-    params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(params->physicalDevice, params->pTimeDomainCount, params->pTimeDomains);
+    params->result = wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT((VkPhysicalDevice)UlongToPtr(params->physicalDevice), (uint32_t *)UlongToPtr(params->pTimeDomainCount), (VkTimeDomainEXT *)UlongToPtr(params->pTimeDomains));
     return STATUS_SUCCESS;
 }

@@ -38272,20 +38272,20 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(void *a
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pPropertyCount;
-        VkCooperativeMatrixPropertiesNV32 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;
     VkCooperativeMatrixPropertiesNV *pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPropertyCount, params->pProperties);

init_conversion_context(&ctx);
-    pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pPropertyCount, pProperties_host);
-    convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
+    pProperties_host = convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(&ctx, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
+    convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(pProperties_host, (VkCooperativeMatrixPropertiesNV32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38310,19 +38310,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalBufferInfo32 *pExternalBufferInfo;
-        VkExternalBufferProperties32 *pExternalBufferProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalBufferInfo;
+        PTR32 pExternalBufferProperties;
     } *params = args;
     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
     VkExternalBufferProperties pExternalBufferProperties_host;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);

-    convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(params->pExternalBufferInfo, &pExternalBufferInfo_host);
-    convert_VkExternalBufferProperties_win32_to_host(params->pExternalBufferProperties, &pExternalBufferProperties_host);
-    wine_vkGetPhysicalDeviceExternalBufferProperties(params->physicalDevice, &pExternalBufferInfo_host, &pExternalBufferProperties_host);
-    convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, params->pExternalBufferProperties);
+    convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
+    convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
+    wine_vkGetPhysicalDeviceExternalBufferProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
+    convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
     return STATUS_SUCCESS;
 }

@@ -38346,19 +38346,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *arg
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalBufferInfo32 *pExternalBufferInfo;
-        VkExternalBufferProperties32 *pExternalBufferProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalBufferInfo;
+        PTR32 pExternalBufferProperties;
     } *params = args;
     VkPhysicalDeviceExternalBufferInfo pExternalBufferInfo_host;
     VkExternalBufferProperties pExternalBufferProperties_host;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalBufferInfo, params->pExternalBufferProperties);

-    convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(params->pExternalBufferInfo, &pExternalBufferInfo_host);
-    convert_VkExternalBufferProperties_win32_to_host(params->pExternalBufferProperties, &pExternalBufferProperties_host);
-    wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(params->physicalDevice, &pExternalBufferInfo_host, &pExternalBufferProperties_host);
-    convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, params->pExternalBufferProperties);
+    convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host((const VkPhysicalDeviceExternalBufferInfo32 *)UlongToPtr(params->pExternalBufferInfo), &pExternalBufferInfo_host);
+    convert_VkExternalBufferProperties_win32_to_host((VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties), &pExternalBufferProperties_host);
+    wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalBufferInfo_host, &pExternalBufferProperties_host);
+    convert_VkExternalBufferProperties_host_to_win32(&pExternalBufferProperties_host, (VkExternalBufferProperties32 *)UlongToPtr(params->pExternalBufferProperties));
     return STATUS_SUCCESS;
 }

@@ -38382,19 +38382,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFenceProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalFenceInfo32 *pExternalFenceInfo;
-        VkExternalFenceProperties32 *pExternalFenceProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalFenceInfo;
+        PTR32 pExternalFenceProperties;
     } *params = args;
     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
     VkExternalFenceProperties pExternalFenceProperties_host;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);

-    convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(params->pExternalFenceInfo, &pExternalFenceInfo_host);
-    convert_VkExternalFenceProperties_win32_to_host(params->pExternalFenceProperties, &pExternalFenceProperties_host);
-    wine_vkGetPhysicalDeviceExternalFenceProperties(params->physicalDevice, &pExternalFenceInfo_host, &pExternalFenceProperties_host);
-    convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, params->pExternalFenceProperties);
+    convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
+    convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
+    wine_vkGetPhysicalDeviceExternalFenceProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
+    convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
     return STATUS_SUCCESS;
 }

@@ -38418,19 +38418,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalFenceInfo32 *pExternalFenceInfo;
-        VkExternalFenceProperties32 *pExternalFenceProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalFenceInfo;
+        PTR32 pExternalFenceProperties;
     } *params = args;
     VkPhysicalDeviceExternalFenceInfo pExternalFenceInfo_host;
     VkExternalFenceProperties pExternalFenceProperties_host;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalFenceInfo, params->pExternalFenceProperties);

-    convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(params->pExternalFenceInfo, &pExternalFenceInfo_host);
-    convert_VkExternalFenceProperties_win32_to_host(params->pExternalFenceProperties, &pExternalFenceProperties_host);
-    wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(params->physicalDevice, &pExternalFenceInfo_host, &pExternalFenceProperties_host);
-    convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, params->pExternalFenceProperties);
+    convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host((const VkPhysicalDeviceExternalFenceInfo32 *)UlongToPtr(params->pExternalFenceInfo), &pExternalFenceInfo_host);
+    convert_VkExternalFenceProperties_win32_to_host((VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties), &pExternalFenceProperties_host);
+    wine_vkGetPhysicalDeviceExternalFencePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalFenceInfo_host, &pExternalFenceProperties_host);
+    convert_VkExternalFenceProperties_host_to_win32(&pExternalFenceProperties_host, (VkExternalFenceProperties32 *)UlongToPtr(params->pExternalFenceProperties));
     return STATUS_SUCCESS;
 }

@@ -38454,21 +38454,21 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphoreProperties(void *arg
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalSemaphoreInfo32 *pExternalSemaphoreInfo;
-        VkExternalSemaphoreProperties32 *pExternalSemaphoreProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalSemaphoreInfo;
+        PTR32 pExternalSemaphoreProperties;
     } *params = args;
     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
-    convert_VkExternalSemaphoreProperties_win32_to_host(params->pExternalSemaphoreProperties, &pExternalSemaphoreProperties_host);
-    wine_vkGetPhysicalDeviceExternalSemaphoreProperties(params->physicalDevice, &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
-    convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, params->pExternalSemaphoreProperties);
+    convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
+    convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
+    wine_vkGetPhysicalDeviceExternalSemaphoreProperties((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
+    convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38493,21 +38493,21 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceExternalSemaphoreInfo32 *pExternalSemaphoreInfo;
-        VkExternalSemaphoreProperties32 *pExternalSemaphoreProperties;
+        PTR32 physicalDevice;
+        PTR32 pExternalSemaphoreInfo;
+        PTR32 pExternalSemaphoreProperties;
     } *params = args;
     VkPhysicalDeviceExternalSemaphoreInfo pExternalSemaphoreInfo_host;
     VkExternalSemaphoreProperties pExternalSemaphoreProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pExternalSemaphoreInfo, params->pExternalSemaphoreProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, params->pExternalSemaphoreInfo, &pExternalSemaphoreInfo_host);
-    convert_VkExternalSemaphoreProperties_win32_to_host(params->pExternalSemaphoreProperties, &pExternalSemaphoreProperties_host);
-    wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(params->physicalDevice, &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
-    convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, params->pExternalSemaphoreProperties);
+    convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(&ctx, (const VkPhysicalDeviceExternalSemaphoreInfo32 *)UlongToPtr(params->pExternalSemaphoreInfo), &pExternalSemaphoreInfo_host);
+    convert_VkExternalSemaphoreProperties_win32_to_host((VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties), &pExternalSemaphoreProperties_host);
+    wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pExternalSemaphoreInfo_host, &pExternalSemaphoreProperties_host);
+    convert_VkExternalSemaphoreProperties_host_to_win32(&pExternalSemaphoreProperties_host, (VkExternalSemaphoreProperties32 *)UlongToPtr(params->pExternalSemaphoreProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38532,13 +38532,13 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceFeatures *pFeatures;
+        PTR32 physicalDevice;
+        PTR32 pFeatures;
     } *params = args;

-    TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFeatures);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (VkPhysicalDeviceFeatures *)UlongToPtr(params->pFeatures));
     return STATUS_SUCCESS;
 }

@@ -38562,18 +38562,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceFeatures232 *pFeatures;
+        PTR32 physicalDevice;
+        PTR32 pFeatures;
     } *params = args;
     VkPhysicalDeviceFeatures2 pFeatures_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, params->pFeatures, &pFeatures_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFeatures_host);
-    convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, params->pFeatures);
+    convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFeatures_host);
+    convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38598,18 +38598,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFeatures2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceFeatures232 *pFeatures;
+        PTR32 physicalDevice;
+        PTR32 pFeatures;
     } *params = args;
     VkPhysicalDeviceFeatures2 pFeatures_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pFeatures);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pFeatures);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, params->pFeatures, &pFeatures_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFeatures_host);
-    convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, params->pFeatures);
+    convert_VkPhysicalDeviceFeatures2_win32_to_host(&ctx, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures), &pFeatures_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFeatures_host);
+    convert_VkPhysicalDeviceFeatures2_host_to_win32(&pFeatures_host, (VkPhysicalDeviceFeatures232 *)UlongToPtr(params->pFeatures));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38634,14 +38634,14 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkFormat format;
-        VkFormatProperties *pFormatProperties;
+        PTR32 pFormatProperties;
     } *params = args;

-    TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->pFormatProperties);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, (VkFormatProperties *)UlongToPtr(params->pFormatProperties));
     return STATUS_SUCCESS;
 }

@@ -38665,19 +38665,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkFormat format;
-        VkFormatProperties232 *pFormatProperties;
+        PTR32 pFormatProperties;
     } *params = args;
     VkFormatProperties2 pFormatProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);

init_conversion_context(&ctx);
-    convert_VkFormatProperties2_win32_to_host(&ctx, params->pFormatProperties, &pFormatProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, &pFormatProperties_host);
-    convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, params->pFormatProperties);
+    convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, &pFormatProperties_host);
+    convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38702,19 +38702,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFormatProperties2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkFormat format;
-        VkFormatProperties232 *pFormatProperties;
+        PTR32 pFormatProperties;
     } *params = args;
     VkFormatProperties2 pFormatProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %p\n", params->physicalDevice, params->format, params->pFormatProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->format, params->pFormatProperties);

init_conversion_context(&ctx);
-    convert_VkFormatProperties2_win32_to_host(&ctx, params->pFormatProperties, &pFormatProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, &pFormatProperties_host);
-    convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, params->pFormatProperties);
+    convert_VkFormatProperties2_win32_to_host(&ctx, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties), &pFormatProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, &pFormatProperties_host);
+    convert_VkFormatProperties2_host_to_win32(&pFormatProperties_host, (VkFormatProperties232 *)UlongToPtr(params->pFormatProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38739,20 +38739,20 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceFragmentShadingRatesKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pFragmentShadingRateCount;
-        VkPhysicalDeviceFragmentShadingRateKHR32 *pFragmentShadingRates;
+        PTR32 physicalDevice;
+        PTR32 pFragmentShadingRateCount;
+        PTR32 pFragmentShadingRates;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pFragmentShadingRateCount, params->pFragmentShadingRates);

init_conversion_context(&ctx);
-    pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(&ctx, params->pFragmentShadingRates, *params->pFragmentShadingRateCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pFragmentShadingRateCount, pFragmentShadingRates_host);
-    convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, params->pFragmentShadingRates, *params->pFragmentShadingRateCount);
+    pFragmentShadingRates_host = convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(&ctx, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pFragmentShadingRateCount), pFragmentShadingRates_host);
+    convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(pFragmentShadingRates_host, (VkPhysicalDeviceFragmentShadingRateKHR32 *)UlongToPtr(params->pFragmentShadingRates), *(uint32_t *)UlongToPtr(params->pFragmentShadingRateCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38777,21 +38777,21 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkFormat format;
         VkImageType type;
         VkImageTiling tiling;
         VkImageUsageFlags usage;
         VkImageCreateFlags flags;
-        VkImageFormatProperties32 *pImageFormatProperties;
+        PTR32 pImageFormatProperties;
         VkResult result;
     } *params = args;
     VkImageFormatProperties pImageFormatProperties_host;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);
+    TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->tiling, params->usage, params->flags, params->pImageFormatProperties);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
-    convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, params->type, params->tiling, params->usage, params->flags, &pImageFormatProperties_host);
+    convert_VkImageFormatProperties_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties32 *)UlongToPtr(params->pImageFormatProperties));
     return STATUS_SUCCESS;
 }

@@ -38815,22 +38815,22 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceImageFormatInfo232 *pImageFormatInfo;
-        VkImageFormatProperties232 *pImageFormatProperties;
+        PTR32 physicalDevice;
+        PTR32 pImageFormatInfo;
+        PTR32 pImageFormatProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
     VkImageFormatProperties2 pImageFormatProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, params->pImageFormatInfo, &pImageFormatInfo_host);
-    convert_VkImageFormatProperties2_win32_to_host(&ctx, params->pImageFormatProperties, &pImageFormatProperties_host);
-    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2(params->physicalDevice, &pImageFormatInfo_host, &pImageFormatProperties_host);
-    convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
+    convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
+    convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
+    convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38855,22 +38855,22 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceImageFormatInfo232 *pImageFormatInfo;
-        VkImageFormatProperties232 *pImageFormatProperties;
+        PTR32 physicalDevice;
+        PTR32 pImageFormatInfo;
+        PTR32 pImageFormatProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceImageFormatInfo2 pImageFormatInfo_host;
     VkImageFormatProperties2 pImageFormatProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pImageFormatInfo, params->pImageFormatProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, params->pImageFormatInfo, &pImageFormatInfo_host);
-    convert_VkImageFormatProperties2_win32_to_host(&ctx, params->pImageFormatProperties, &pImageFormatProperties_host);
-    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR(params->physicalDevice, &pImageFormatInfo_host, &pImageFormatProperties_host);
-    convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, params->pImageFormatProperties);
+    convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(&ctx, (const VkPhysicalDeviceImageFormatInfo232 *)UlongToPtr(params->pImageFormatInfo), &pImageFormatInfo_host);
+    convert_VkImageFormatProperties2_win32_to_host(&ctx, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties), &pImageFormatProperties_host);
+    params->result = wine_vkGetPhysicalDeviceImageFormatProperties2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pImageFormatInfo_host, &pImageFormatProperties_host);
+    convert_VkImageFormatProperties2_host_to_win32(&pImageFormatProperties_host, (VkImageFormatProperties232 *)UlongToPtr(params->pImageFormatProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38895,15 +38895,15 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceMemoryProperties32 *pMemoryProperties;
+        PTR32 physicalDevice;
+        PTR32 pMemoryProperties;
     } *params = args;
     VkPhysicalDeviceMemoryProperties pMemoryProperties_host;

-    TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
-    convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
+    convert_VkPhysicalDeviceMemoryProperties_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties32 *)UlongToPtr(params->pMemoryProperties));
     return STATUS_SUCCESS;
 }

@@ -38927,18 +38927,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
+        PTR32 physicalDevice;
+        PTR32 pMemoryProperties;
     } *params = args;
     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
-    convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
+    convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
+    convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38963,18 +38963,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMemoryProperties2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceMemoryProperties232 *pMemoryProperties;
+        PTR32 physicalDevice;
+        PTR32 pMemoryProperties;
     } *params = args;
     VkPhysicalDeviceMemoryProperties2 pMemoryProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pMemoryProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pMemoryProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, params->pMemoryProperties, &pMemoryProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pMemoryProperties_host);
-    convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, params->pMemoryProperties);
+    convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(&ctx, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties), &pMemoryProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pMemoryProperties_host);
+    convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(&pMemoryProperties_host, (VkPhysicalDeviceMemoryProperties232 *)UlongToPtr(params->pMemoryProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -38999,17 +38999,17 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceMultisamplePropertiesEXT(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkSampleCountFlagBits samples;
-        VkMultisamplePropertiesEXT32 *pMultisampleProperties;
+        PTR32 pMultisampleProperties;
     } *params = args;
     VkMultisamplePropertiesEXT pMultisampleProperties_host;

-    TRACE("%p, %#x, %p\n", params->physicalDevice, params->samples, params->pMultisampleProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->samples, params->pMultisampleProperties);

-    convert_VkMultisamplePropertiesEXT_win32_to_host(params->pMultisampleProperties, &pMultisampleProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->samples, &pMultisampleProperties_host);
-    convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, params->pMultisampleProperties);
+    convert_VkMultisamplePropertiesEXT_win32_to_host((VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties), &pMultisampleProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->samples, &pMultisampleProperties_host);
+    convert_VkMultisamplePropertiesEXT_host_to_win32(&pMultisampleProperties_host, (VkMultisamplePropertiesEXT32 *)UlongToPtr(params->pMultisampleProperties));
     return STATUS_SUCCESS;
 }

@@ -39033,23 +39033,23 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkOpticalFlowImageFormatInfoNV32 *pOpticalFlowImageFormatInfo;
-        uint32_t *pFormatCount;
-        VkOpticalFlowImageFormatPropertiesNV32 *pImageFormatProperties;
+        PTR32 physicalDevice;
+        PTR32 pOpticalFlowImageFormatInfo;
+        PTR32 pFormatCount;
+        PTR32 pImageFormatProperties;
         VkResult result;
     } *params = args;
     VkOpticalFlowImageFormatInfoNV pOpticalFlowImageFormatInfo_host;
     VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pOpticalFlowImageFormatInfo, params->pFormatCount, params->pImageFormatProperties);

init_conversion_context(&ctx);
-    convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(params->pOpticalFlowImageFormatInfo, &pOpticalFlowImageFormatInfo_host);
-    pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(&ctx, params->pImageFormatProperties, *params->pFormatCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pOpticalFlowImageFormatInfo_host, params->pFormatCount, pImageFormatProperties_host);
-    convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, params->pImageFormatProperties, *params->pFormatCount);
+    convert_VkOpticalFlowImageFormatInfoNV_win32_to_host((const VkOpticalFlowImageFormatInfoNV32 *)UlongToPtr(params->pOpticalFlowImageFormatInfo), &pOpticalFlowImageFormatInfo_host);
+    pImageFormatProperties_host = convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(&ctx, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pOpticalFlowImageFormatInfo_host, (uint32_t *)UlongToPtr(params->pFormatCount), pImageFormatProperties_host);
+    convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(pImageFormatProperties_host, (VkOpticalFlowImageFormatPropertiesNV32 *)UlongToPtr(params->pImageFormatProperties), *(uint32_t *)UlongToPtr(params->pFormatCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39074,16 +39074,16 @@ static NTSTATUS thunk32_vkGetPhysicalDevicePresentRectanglesKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        uint32_t *pRectCount;
-        VkRect2D *pRects;
+        PTR32 pRectCount;
+        PTR32 pRects;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pRectCount, params->pRects);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pRectCount, params->pRects);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pRectCount), (VkRect2D *)UlongToPtr(params->pRects));
     return STATUS_SUCCESS;
 }

@@ -39107,15 +39107,15 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceProperties32 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pProperties;
     } *params = args;
     VkPhysicalDeviceProperties pProperties_host;

-    TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
-    convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, params->pProperties);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
+    convert_VkPhysicalDeviceProperties_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties32 *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -39139,18 +39139,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceProperties232 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pProperties;
     } *params = args;
     VkPhysicalDeviceProperties2 pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
-    convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
+    convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
+    convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39175,18 +39175,18 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceProperties2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        VkPhysicalDeviceProperties232 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pProperties;
     } *params = args;
     VkPhysicalDeviceProperties2 pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->physicalDevice, params->pProperties);
+    TRACE("%#x, %#x\n", params->physicalDevice, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, params->pProperties, &pProperties_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pProperties_host);
-    convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, params->pProperties);
+    convert_VkPhysicalDeviceProperties2_win32_to_host(&ctx, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties), &pProperties_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pProperties_host);
+    convert_VkPhysicalDeviceProperties2_host_to_win32(&pProperties_host, (VkPhysicalDeviceProperties232 *)UlongToPtr(params->pProperties));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39211,16 +39211,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkQueryPoolPerformanceCreateInfoKHR32 *pPerformanceQueryCreateInfo;
-        uint32_t *pNumPasses;
+        PTR32 physicalDevice;
+        PTR32 pPerformanceQueryCreateInfo;
+        PTR32 pNumPasses;
     } *params = args;
     VkQueryPoolPerformanceCreateInfoKHR pPerformanceQueryCreateInfo_host;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pPerformanceQueryCreateInfo, params->pNumPasses);

-    convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(params->pPerformanceQueryCreateInfo, &pPerformanceQueryCreateInfo_host);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pPerformanceQueryCreateInfo_host, params->pNumPasses);
+    convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host((const VkQueryPoolPerformanceCreateInfoKHR32 *)UlongToPtr(params->pPerformanceQueryCreateInfo), &pPerformanceQueryCreateInfo_host);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pPerformanceQueryCreateInfo_host, (uint32_t *)UlongToPtr(params->pNumPasses));
     return STATUS_SUCCESS;
 }

@@ -39244,14 +39244,14 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pQueueFamilyPropertyCount;
-        VkQueueFamilyProperties *pQueueFamilyProperties;
+        PTR32 physicalDevice;
+        PTR32 pQueueFamilyPropertyCount;
+        PTR32 pQueueFamilyProperties;
     } *params = args;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), (VkQueueFamilyProperties *)UlongToPtr(params->pQueueFamilyProperties));
     return STATUS_SUCCESS;
 }

@@ -39275,19 +39275,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pQueueFamilyPropertyCount;
-        VkQueueFamilyProperties232 *pQueueFamilyProperties;
+        PTR32 physicalDevice;
+        PTR32 pQueueFamilyPropertyCount;
+        PTR32 pQueueFamilyProperties;
     } *params = args;
     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);

init_conversion_context(&ctx);
-    pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, pQueueFamilyProperties_host);
-    convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
+    pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), pQueueFamilyProperties_host);
+    convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39312,19 +39312,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceQueueFamilyProperties2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pQueueFamilyPropertyCount;
-        VkQueueFamilyProperties232 *pQueueFamilyProperties;
+        PTR32 physicalDevice;
+        PTR32 pQueueFamilyPropertyCount;
+        PTR32 pQueueFamilyProperties;
     } *params = args;
     VkQueueFamilyProperties2 *pQueueFamilyProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pQueueFamilyPropertyCount, params->pQueueFamilyProperties);

init_conversion_context(&ctx);
-    pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pQueueFamilyPropertyCount, pQueueFamilyProperties_host);
-    convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, params->pQueueFamilyProperties, *params->pQueueFamilyPropertyCount);
+    pQueueFamilyProperties_host = convert_VkQueueFamilyProperties2_array_win32_to_host(&ctx, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount), pQueueFamilyProperties_host);
+    convert_VkQueueFamilyProperties2_array_host_to_win32(pQueueFamilyProperties_host, (VkQueueFamilyProperties232 *)UlongToPtr(params->pQueueFamilyProperties), *(uint32_t *)UlongToPtr(params->pQueueFamilyPropertyCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39349,19 +39349,19 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties(void *arg
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkFormat format;
         VkImageType type;
         VkSampleCountFlagBits samples;
         VkImageUsageFlags usage;
         VkImageTiling tiling;
-        uint32_t *pPropertyCount;
-        VkSparseImageFormatProperties *pProperties;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
     } *params = args;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", params->physicalDevice, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x, %#x, %#x, %#x, %#x, %#x\n", params->physicalDevice, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);

-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->format, params->type, params->samples, params->usage, params->tiling, params->pPropertyCount, params->pProperties);
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->format, params->type, params->samples, params->usage, params->tiling, (uint32_t *)UlongToPtr(params->pPropertyCount), (VkSparseImageFormatProperties *)UlongToPtr(params->pProperties));
     return STATUS_SUCCESS;
 }

@@ -39385,22 +39385,22 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2(void *ar
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceSparseImageFormatInfo232 *pFormatInfo;
-        uint32_t *pPropertyCount;
-        VkSparseImageFormatProperties232 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pFormatInfo;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
     } *params = args;
     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
     VkSparseImageFormatProperties2 *pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(params->pFormatInfo, &pFormatInfo_host);
-    pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFormatInfo_host, params->pPropertyCount, pProperties_host);
-    convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
+    convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
+    pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
+    convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39425,22 +39425,22 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(void
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceSparseImageFormatInfo232 *pFormatInfo;
-        uint32_t *pPropertyCount;
-        VkSparseImageFormatProperties232 *pProperties;
+        PTR32 physicalDevice;
+        PTR32 pFormatInfo;
+        PTR32 pPropertyCount;
+        PTR32 pProperties;
     } *params = args;
     VkPhysicalDeviceSparseImageFormatInfo2 pFormatInfo_host;
     VkSparseImageFormatProperties2 *pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pFormatInfo, params->pPropertyCount, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(params->pFormatInfo, &pFormatInfo_host);
-    pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, params->pProperties, *params->pPropertyCount);
-    wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pFormatInfo_host, params->pPropertyCount, pProperties_host);
-    convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, params->pProperties, *params->pPropertyCount);
+    convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host((const VkPhysicalDeviceSparseImageFormatInfo232 *)UlongToPtr(params->pFormatInfo), &pFormatInfo_host);
+    pProperties_host = convert_VkSparseImageFormatProperties2_array_win32_to_host(&ctx, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
+    wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pFormatInfo_host, (uint32_t *)UlongToPtr(params->pPropertyCount), pProperties_host);
+    convert_VkSparseImageFormatProperties2_array_host_to_win32(pProperties_host, (VkSparseImageFormatProperties232 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pPropertyCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39465,20 +39465,20 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombi
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pCombinationCount;
-        VkFramebufferMixedSamplesCombinationNV32 *pCombinations;
+        PTR32 physicalDevice;
+        PTR32 pCombinationCount;
+        PTR32 pCombinations;
         VkResult result;
     } *params = args;
     VkFramebufferMixedSamplesCombinationNV *pCombinations_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pCombinationCount, params->pCombinations);

init_conversion_context(&ctx);
-    pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(&ctx, params->pCombinations, *params->pCombinationCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pCombinationCount, pCombinations_host);
-    convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, params->pCombinations, *params->pCombinationCount);
+    pCombinations_host = convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(&ctx, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pCombinationCount), pCombinations_host);
+    convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(pCombinations_host, (VkFramebufferMixedSamplesCombinationNV32 *)UlongToPtr(params->pCombinations), *(uint32_t *)UlongToPtr(params->pCombinationCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39503,22 +39503,22 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
-        VkSurfaceCapabilities2KHR32 *pSurfaceCapabilities;
+        PTR32 physicalDevice;
+        PTR32 pSurfaceInfo;
+        PTR32 pSurfaceCapabilities;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
     VkSurfaceCapabilities2KHR pSurfaceCapabilities_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceCapabilities);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(params->pSurfaceInfo, &pSurfaceInfo_host);
-    convert_VkSurfaceCapabilities2KHR_win32_to_host(&ctx, params->pSurfaceCapabilities, &pSurfaceCapabilities_host);
-    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(params->physicalDevice, &pSurfaceInfo_host, &pSurfaceCapabilities_host);
-    convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, params->pSurfaceCapabilities);
+    convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host((const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
+    convert_VkSurfaceCapabilities2KHR_win32_to_host(&ctx, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities), &pSurfaceCapabilities_host);
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), &pSurfaceInfo_host, &pSurfaceCapabilities_host);
+    convert_VkSurfaceCapabilities2KHR_host_to_win32(&pSurfaceCapabilities_host, (VkSurfaceCapabilities2KHR32 *)UlongToPtr(params->pSurfaceCapabilities));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39543,15 +39543,15 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        VkSurfaceCapabilitiesKHR *pSurfaceCapabilities;
+        PTR32 pSurfaceCapabilities;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);
+    TRACE("%#x, 0x%s, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceCapabilities);

-    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(params->physicalDevice, params->surface, params->pSurfaceCapabilities);
+    params->result = wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR((VkPhysicalDevice)UlongToPtr(params->physicalDevice), params->surface, (VkSurfaceCapabilitiesKHR *)UlongToPtr(params->pSurfaceCapabilities));
     return STATUS_SUCCESS;
 }

@@ -39577,23 +39577,23 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormats2KHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        const VkPhysicalDeviceSurfaceInfo2KHR32 *pSurfaceInfo;
-        uint32_t *pSurfaceFormatCount;
-        VkSurfaceFormat2KHR32 *pSurfaceFormats;
+        PTR32 physicalDevice;
+        PTR32 pSurfaceInfo;
+        PTR32 pSurfaceFormatCount;
+        PTR32 pSurfaceFormats;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceSurfaceInfo2KHR pSurfaceInfo_host;
     VkSurfaceFormat2KHR *pSurfaceFormats_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    TRACE("%#x, %#x, %#x, %#x\n", params->physicalDevice, params->pSurfaceInfo, params->pSurfaceFormatCount, params->pSurfaceFormats);

init_conversion_context(&ctx);
-    convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host(params->pSurfaceInfo, &pSurfaceInfo_host);
-    pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(&ctx, params->pSurfaceFormats, *params->pSurfaceFormatCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, &pSurfaceInfo_host, params->pSurfaceFormatCount, pSurfaceFormats_host);
-    convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, params->pSurfaceFormats, *params->pSurfaceFormatCount);
+    convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_host((const VkPhysicalDeviceSurfaceInfo2KHR32 *)UlongToPtr(params->pSurfaceInfo), &pSurfaceInfo_host);
+    pSurfaceFormats_host = convert_VkSurfaceFormat2KHR_array_win32_to_host(&ctx, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormats2KHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, &pSurfaceInfo_host, (uint32_t *)UlongToPtr(params->pSurfaceFormatCount), pSurfaceFormats_host);
+    convert_VkSurfaceFormat2KHR_array_host_to_win32(pSurfaceFormats_host, (VkSurfaceFormat2KHR32 *)UlongToPtr(params->pSurfaceFormats), *(uint32_t *)UlongToPtr(params->pSurfaceFormatCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39618,16 +39618,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceFormatsKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        uint32_t *pSurfaceFormatCount;
-        VkSurfaceFormatKHR *pSurfaceFormats;
+        PTR32 pSurfaceFormatCount;
+        PTR32 pSurfaceFormats;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pSurfaceFormatCount, params->pSurfaceFormats);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pSurfaceFormatCount, params->pSurfaceFormats);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pSurfaceFormatCount), (VkSurfaceFormatKHR *)UlongToPtr(params->pSurfaceFormats));
     return STATUS_SUCCESS;
 }

@@ -39651,16 +39651,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfacePresentModesKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        uint32_t *pPresentModeCount;
-        VkPresentModeKHR *pPresentModes;
+        PTR32 pPresentModeCount;
+        PTR32 pPresentModes;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p, %p\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->physicalDevice, wine_dbgstr_longlong(params->surface), params->pPresentModeCount, params->pPresentModes);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, params->pPresentModeCount, params->pPresentModes);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, wine_surface_from_handle(params->surface)->driver_surface, (uint32_t *)UlongToPtr(params->pPresentModeCount), (VkPresentModeKHR *)UlongToPtr(params->pPresentModes));
     return STATUS_SUCCESS;
 }

@@ -39684,16 +39684,16 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceSurfaceSupportKHR(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         uint32_t queueFamilyIndex;
         VkSurfaceKHR DECLSPEC_ALIGN(8) surface;
-        VkBool32 *pSupported;
+        PTR32 pSupported;
         VkResult result;
     } *params = args;

-    TRACE("%p, %u, 0x%s, %p\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);
+    TRACE("%#x, %u, 0x%s, %#x\n", params->physicalDevice, params->queueFamilyIndex, wine_dbgstr_longlong(params->surface), params->pSupported);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, params->pSupported);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex, wine_surface_from_handle(params->surface)->driver_surface, (VkBool32 *)UlongToPtr(params->pSupported));
     return STATUS_SUCCESS;
 }

@@ -39717,20 +39717,20 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceToolProperties(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pToolCount;
-        VkPhysicalDeviceToolProperties32 *pToolProperties;
+        PTR32 physicalDevice;
+        PTR32 pToolCount;
+        PTR32 pToolProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceToolProperties *pToolProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

init_conversion_context(&ctx);
-    pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, params->pToolProperties, *params->pToolCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, pToolProperties_host);
-    convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, params->pToolProperties, *params->pToolCount);
+    pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceToolProperties(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pToolCount), pToolProperties_host);
+    convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39755,20 +39755,20 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceToolPropertiesEXT(void *args)
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
-        uint32_t *pToolCount;
-        VkPhysicalDeviceToolProperties32 *pToolProperties;
+        PTR32 physicalDevice;
+        PTR32 pToolCount;
+        PTR32 pToolProperties;
         VkResult result;
     } *params = args;
     VkPhysicalDeviceToolProperties *pToolProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->physicalDevice, params->pToolCount, params->pToolProperties);
+    TRACE("%#x, %#x, %#x\n", params->physicalDevice, params->pToolCount, params->pToolProperties);

init_conversion_context(&ctx);
-    pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, params->pToolProperties, *params->pToolCount);
-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->pToolCount, pToolProperties_host);
-    convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, params->pToolProperties, *params->pToolCount);
+    pToolProperties_host = convert_VkPhysicalDeviceToolProperties_array_win32_to_host(&ctx, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, (uint32_t *)UlongToPtr(params->pToolCount), pToolProperties_host);
+    convert_VkPhysicalDeviceToolProperties_array_host_to_win32(pToolProperties_host, (VkPhysicalDeviceToolProperties32 *)UlongToPtr(params->pToolProperties), *(uint32_t *)UlongToPtr(params->pToolCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39793,14 +39793,14 @@ static NTSTATUS thunk32_vkGetPhysicalDeviceWin32PresentationSupportKHR(void *arg
 {
     struct
     {
-        VkPhysicalDevice physicalDevice;
+        PTR32 physicalDevice;
         uint32_t queueFamilyIndex;
         VkBool32 result;
     } *params = args;

-    TRACE("%p, %u\n", params->physicalDevice, params->queueFamilyIndex);
+    TRACE("%#x, %u\n", params->physicalDevice, params->queueFamilyIndex);

-    params->result = wine_phys_dev_from_handle(params->physicalDevice)->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle(params->physicalDevice)->phys_dev, params->queueFamilyIndex);
+    params->result = wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(wine_phys_dev_from_handle((VkPhysicalDevice)UlongToPtr(params->physicalDevice))->phys_dev, params->queueFamilyIndex);
     return STATUS_SUCCESS;
 }

@@ -39824,19 +39824,19 @@ static NTSTATUS thunk32_vkGetPipelineCacheData(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) pipelineCache;
-        size_t *pDataSize;
-        void *pData;
+        PTR32 pDataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;
     size_t pDataSize_host;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipelineCache), params->pDataSize, params->pData);

-    pDataSize_host = *params->pDataSize;
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineCacheData(wine_device_from_handle(params->device)->device, params->pipelineCache, &pDataSize_host, params->pData);
-    *params->pDataSize = pDataSize_host;
+    pDataSize_host = *(size_t *)UlongToPtr(params->pDataSize);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineCacheData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipelineCache, &pDataSize_host, (void *)UlongToPtr(params->pData));
+    *(size_t *)UlongToPtr(params->pDataSize) = pDataSize_host;
     return STATUS_SUCCESS;
 }

@@ -39860,23 +39860,23 @@ static NTSTATUS thunk32_vkGetPipelineExecutableInternalRepresentationsKHR(void *
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
-        uint32_t *pInternalRepresentationCount;
-        VkPipelineExecutableInternalRepresentationKHR32 *pInternalRepresentations;
+        PTR32 device;
+        PTR32 pExecutableInfo;
+        PTR32 pInternalRepresentationCount;
+        PTR32 pInternalRepresentations;
         VkResult result;
     } *params = args;
     VkPipelineExecutableInfoKHR pExecutableInfo_host;
     VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pInternalRepresentationCount, params->pInternalRepresentations);

init_conversion_context(&ctx);
-    convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
-    pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(&ctx, params->pInternalRepresentations, *params->pInternalRepresentationCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pInternalRepresentationCount, pInternalRepresentations_host);
-    convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, params->pInternalRepresentations, *params->pInternalRepresentationCount);
+    convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
+    pInternalRepresentations_host = convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(&ctx, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutableInternalRepresentationsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pExecutableInfo_host, (uint32_t *)UlongToPtr(params->pInternalRepresentationCount), pInternalRepresentations_host);
+    convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(pInternalRepresentations_host, (VkPipelineExecutableInternalRepresentationKHR32 *)UlongToPtr(params->pInternalRepresentations), *(uint32_t *)UlongToPtr(params->pInternalRepresentationCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39901,23 +39901,23 @@ static NTSTATUS thunk32_vkGetPipelineExecutablePropertiesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineInfoKHR32 *pPipelineInfo;
-        uint32_t *pExecutableCount;
-        VkPipelineExecutablePropertiesKHR32 *pProperties;
+        PTR32 device;
+        PTR32 pPipelineInfo;
+        PTR32 pExecutableCount;
+        PTR32 pProperties;
         VkResult result;
     } *params = args;
     VkPipelineInfoKHR pPipelineInfo_host;
     VkPipelineExecutablePropertiesKHR *pProperties_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pExecutableCount, params->pProperties);

init_conversion_context(&ctx);
-    convert_VkPipelineInfoKHR_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
-    pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(&ctx, params->pProperties, *params->pExecutableCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pExecutableCount, pProperties_host);
-    convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, params->pProperties, *params->pExecutableCount);
+    convert_VkPipelineInfoKHR_win32_to_host((const VkPipelineInfoKHR32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
+    pProperties_host = convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(&ctx, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutablePropertiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pPipelineInfo_host, (uint32_t *)UlongToPtr(params->pExecutableCount), pProperties_host);
+    convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(pProperties_host, (VkPipelineExecutablePropertiesKHR32 *)UlongToPtr(params->pProperties), *(uint32_t *)UlongToPtr(params->pExecutableCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39942,23 +39942,23 @@ static NTSTATUS thunk32_vkGetPipelineExecutableStatisticsKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineExecutableInfoKHR32 *pExecutableInfo;
-        uint32_t *pStatisticCount;
-        VkPipelineExecutableStatisticKHR32 *pStatistics;
+        PTR32 device;
+        PTR32 pExecutableInfo;
+        PTR32 pStatisticCount;
+        PTR32 pStatistics;
         VkResult result;
     } *params = args;
     VkPipelineExecutableInfoKHR pExecutableInfo_host;
     VkPipelineExecutableStatisticKHR *pStatistics_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p, %p\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);
+    TRACE("%#x, %#x, %#x, %#x\n", params->device, params->pExecutableInfo, params->pStatisticCount, params->pStatistics);

init_conversion_context(&ctx);
-    convert_VkPipelineExecutableInfoKHR_win32_to_host(params->pExecutableInfo, &pExecutableInfo_host);
-    pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, params->pStatistics, *params->pStatisticCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle(params->device)->device, &pExecutableInfo_host, params->pStatisticCount, pStatistics_host);
-    convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, params->pStatistics, *params->pStatisticCount);
+    convert_VkPipelineExecutableInfoKHR_win32_to_host((const VkPipelineExecutableInfoKHR32 *)UlongToPtr(params->pExecutableInfo), &pExecutableInfo_host);
+    pStatistics_host = convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(&ctx, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelineExecutableStatisticsKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pExecutableInfo_host, (uint32_t *)UlongToPtr(params->pStatisticCount), pStatistics_host);
+    convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(pStatistics_host, (VkPipelineExecutableStatisticKHR32 *)UlongToPtr(params->pStatistics), *(uint32_t *)UlongToPtr(params->pStatisticCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -39983,17 +39983,17 @@ static NTSTATUS thunk32_vkGetPipelinePropertiesEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkPipelineInfoEXT32 *pPipelineInfo;
-        VkBaseOutStructure *pPipelineProperties;
+        PTR32 device;
+        PTR32 pPipelineInfo;
+        PTR32 pPipelineProperties;
         VkResult result;
     } *params = args;
     VkPipelineInfoEXT pPipelineInfo_host;

-    TRACE("%p, %p, %p\n", params->device, params->pPipelineInfo, params->pPipelineProperties);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pPipelineInfo, params->pPipelineProperties);

-    convert_VkPipelineInfoEXT_win32_to_host(params->pPipelineInfo, &pPipelineInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle(params->device)->device, &pPipelineInfo_host, params->pPipelineProperties);
+    convert_VkPipelineInfoEXT_win32_to_host((const VkPipelineInfoEXT32 *)UlongToPtr(params->pPipelineInfo), &pPipelineInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPipelinePropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pPipelineInfo_host, (VkBaseOutStructure *)UlongToPtr(params->pPipelineProperties));
     return STATUS_SUCCESS;
 }

@@ -40017,16 +40017,16 @@ static NTSTATUS thunk32_vkGetPrivateData(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkObjectType objectType;
         uint64_t DECLSPEC_ALIGN(8) objectHandle;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
-        uint64_t *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
+    TRACE("%#x, %#x, 0x%s, 0x%s, %#x\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);

-    wine_device_from_handle(params->device)->funcs.p_vkGetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPrivateData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, (uint64_t *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -40050,16 +40050,16 @@ static NTSTATUS thunk32_vkGetPrivateDataEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkObjectType objectType;
         uint64_t DECLSPEC_ALIGN(8) objectHandle;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
-        uint64_t *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, %p\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);
+    TRACE("%#x, %#x, 0x%s, 0x%s, %#x\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), params->pData);

-    wine_device_from_handle(params->device)->funcs.p_vkGetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->pData);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetPrivateDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, (uint64_t *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -40083,20 +40083,20 @@ static NTSTATUS thunk32_vkGetQueryPoolResults(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
         uint32_t queryCount;
-        size_t dataSize;
-        void *pData;
+        PTR32 dataSize;
+        PTR32 pData;
         VkDeviceSize DECLSPEC_ALIGN(8) stride;
         VkQueryResultFlags flags;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride), params->flags);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetQueryPoolResults(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, params->pData, params->stride, params->flags);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetQueryPoolResults(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount, params->dataSize, (void *)UlongToPtr(params->pData), params->stride, params->flags);
     return STATUS_SUCCESS;
 }

@@ -40120,19 +40120,19 @@ static NTSTATUS thunk32_vkGetQueueCheckpointData2NV(void *args)
 {
     struct
     {
-        VkQueue queue;
-        uint32_t *pCheckpointDataCount;
-        VkCheckpointData2NV32 *pCheckpointData;
+        PTR32 queue;
+        PTR32 pCheckpointDataCount;
+        PTR32 pCheckpointData;
     } *params = args;
     VkCheckpointData2NV *pCheckpointData_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
+    TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);

init_conversion_context(&ctx);
-    pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(&ctx, params->pCheckpointData, *params->pCheckpointDataCount);
-    wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, pCheckpointData_host);
-    convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, params->pCheckpointData, *params->pCheckpointDataCount);
+    pCheckpointData_host = convert_VkCheckpointData2NV_array_win32_to_host(&ctx, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
+    wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkGetQueueCheckpointData2NV(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, (uint32_t *)UlongToPtr(params->pCheckpointDataCount), pCheckpointData_host);
+    convert_VkCheckpointData2NV_array_host_to_win32(pCheckpointData_host, (VkCheckpointData2NV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40157,19 +40157,19 @@ static NTSTATUS thunk32_vkGetQueueCheckpointDataNV(void *args)
 {
     struct
     {
-        VkQueue queue;
-        uint32_t *pCheckpointDataCount;
-        VkCheckpointDataNV32 *pCheckpointData;
+        PTR32 queue;
+        PTR32 pCheckpointDataCount;
+        PTR32 pCheckpointData;
     } *params = args;
     VkCheckpointDataNV *pCheckpointData_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);
+    TRACE("%#x, %#x, %#x\n", params->queue, params->pCheckpointDataCount, params->pCheckpointData);

init_conversion_context(&ctx);
-    pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(&ctx, params->pCheckpointData, *params->pCheckpointDataCount);
-    wine_queue_from_handle(params->queue)->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle(params->queue)->queue, params->pCheckpointDataCount, pCheckpointData_host);
-    convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, params->pCheckpointData, *params->pCheckpointDataCount);
+    pCheckpointData_host = convert_VkCheckpointDataNV_array_win32_to_host(&ctx, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
+    wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkGetQueueCheckpointDataNV(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, (uint32_t *)UlongToPtr(params->pCheckpointDataCount), pCheckpointData_host);
+    convert_VkCheckpointDataNV_array_host_to_win32(pCheckpointData_host, (VkCheckpointDataNV32 *)UlongToPtr(params->pCheckpointData), *(uint32_t *)UlongToPtr(params->pCheckpointDataCount));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40194,18 +40194,18 @@ static NTSTATUS thunk32_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(void *
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t firstGroup;
         uint32_t groupCount;
-        size_t dataSize;
-        void *pData;
+        PTR32 dataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -40229,18 +40229,18 @@ static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t firstGroup;
         uint32_t groupCount;
-        size_t dataSize;
-        void *pData;
+        PTR32 dataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -40264,18 +40264,18 @@ static NTSTATUS thunk32_vkGetRayTracingShaderGroupHandlesNV(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t firstGroup;
         uint32_t groupCount;
-        size_t dataSize;
-        void *pData;
+        PTR32 dataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);
+    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->firstGroup, params->groupCount, wine_dbgstr_longlong(params->dataSize), params->pData);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle(params->device)->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, params->pData);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupHandlesNV(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->firstGroup, params->groupCount, params->dataSize, (void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -40299,16 +40299,16 @@ static NTSTATUS thunk32_vkGetRayTracingShaderGroupStackSizeKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         uint32_t group;
         VkShaderGroupShaderKHR groupShader;
         VkDeviceSize result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->group, params->groupShader);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle(params->device)->device, params->pipeline, params->group, params->groupShader);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->group, params->groupShader);
     return STATUS_SUCCESS;
 }

@@ -40332,14 +40332,14 @@ static NTSTATUS thunk32_vkGetRenderAreaGranularity(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkRenderPass DECLSPEC_ALIGN(8) renderPass;
-        VkExtent2D *pGranularity;
+        PTR32 pGranularity;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->renderPass), params->pGranularity);

-    wine_device_from_handle(params->device)->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle(params->device)->device, params->renderPass, params->pGranularity);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetRenderAreaGranularity(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->renderPass, (VkExtent2D *)UlongToPtr(params->pGranularity));
     return STATUS_SUCCESS;
 }

@@ -40363,15 +40363,15 @@ static NTSTATUS thunk32_vkGetSemaphoreCounterValue(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-        uint64_t *pValue;
+        PTR32 pValue;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSemaphoreCounterValue(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, (uint64_t *)UlongToPtr(params->pValue));
     return STATUS_SUCCESS;
 }

@@ -40395,15 +40395,15 @@ static NTSTATUS thunk32_vkGetSemaphoreCounterValueKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSemaphore DECLSPEC_ALIGN(8) semaphore;
-        uint64_t *pValue;
+        PTR32 pValue;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->semaphore), params->pValue);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle(params->device)->device, params->semaphore, params->pValue);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSemaphoreCounterValueKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->semaphore, (uint64_t *)UlongToPtr(params->pValue));
     return STATUS_SUCCESS;
 }

@@ -40427,21 +40427,21 @@ static NTSTATUS thunk32_vkGetShaderInfoAMD(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
         VkShaderStageFlagBits shaderStage;
         VkShaderInfoTypeAMD infoType;
-        size_t *pInfoSize;
-        void *pInfo;
+        PTR32 pInfoSize;
+        PTR32 pInfo;
         VkResult result;
     } *params = args;
     size_t pInfoSize_host;

-    TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);
+    TRACE("%#x, 0x%s, %#x, %#x, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->pipeline), params->shaderStage, params->infoType, params->pInfoSize, params->pInfo);

-    pInfoSize_host = *params->pInfoSize;
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle(params->device)->device, params->pipeline, params->shaderStage, params->infoType, &pInfoSize_host, params->pInfo);
-    *params->pInfoSize = pInfoSize_host;
+    pInfoSize_host = *(size_t *)UlongToPtr(params->pInfoSize);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderInfoAMD(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->pipeline, params->shaderStage, params->infoType, &pInfoSize_host, (void *)UlongToPtr(params->pInfo));
+    *(size_t *)UlongToPtr(params->pInfoSize) = pInfoSize_host;
     return STATUS_SUCCESS;
 }

@@ -40465,21 +40465,21 @@ static NTSTATUS thunk32_vkGetShaderModuleCreateInfoIdentifierEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkShaderModuleCreateInfo32 *pCreateInfo;
-        VkShaderModuleIdentifierEXT32 *pIdentifier;
+        PTR32 device;
+        PTR32 pCreateInfo;
+        PTR32 pIdentifier;
     } *params = args;
     VkShaderModuleCreateInfo pCreateInfo_host;
     VkShaderModuleIdentifierEXT pIdentifier_host;
     struct conversion_context ctx;

-    TRACE("%p, %p, %p\n", params->device, params->pCreateInfo, params->pIdentifier);
+    TRACE("%#x, %#x, %#x\n", params->device, params->pCreateInfo, params->pIdentifier);

init_conversion_context(&ctx);
-    convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, params->pCreateInfo, &pCreateInfo_host);
-    convert_VkShaderModuleIdentifierEXT_win32_to_host(params->pIdentifier, &pIdentifier_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle(params->device)->device, &pCreateInfo_host, &pIdentifier_host);
-    convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, params->pIdentifier);
+    convert_VkShaderModuleCreateInfo_win32_to_host(&ctx, (const VkShaderModuleCreateInfo32 *)UlongToPtr(params->pCreateInfo), &pCreateInfo_host);
+    convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleCreateInfoIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pCreateInfo_host, &pIdentifier_host);
+    convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40504,17 +40504,17 @@ static NTSTATUS thunk32_vkGetShaderModuleIdentifierEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkShaderModule DECLSPEC_ALIGN(8) shaderModule;
-        VkShaderModuleIdentifierEXT32 *pIdentifier;
+        PTR32 pIdentifier;
     } *params = args;
     VkShaderModuleIdentifierEXT pIdentifier_host;

-    TRACE("%p, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->shaderModule), params->pIdentifier);

-    convert_VkShaderModuleIdentifierEXT_win32_to_host(params->pIdentifier, &pIdentifier_host);
-    wine_device_from_handle(params->device)->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle(params->device)->device, params->shaderModule, &pIdentifier_host);
-    convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, params->pIdentifier);
+    convert_VkShaderModuleIdentifierEXT_win32_to_host((VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier), &pIdentifier_host);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetShaderModuleIdentifierEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->shaderModule, &pIdentifier_host);
+    convert_VkShaderModuleIdentifierEXT_host_to_win32(&pIdentifier_host, (VkShaderModuleIdentifierEXT32 *)UlongToPtr(params->pIdentifier));
     return STATUS_SUCCESS;
 }

@@ -40538,16 +40538,16 @@ static NTSTATUS thunk32_vkGetSwapchainImagesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
-        uint32_t *pSwapchainImageCount;
-        VkImage *pSwapchainImages;
+        PTR32 pSwapchainImageCount;
+        PTR32 pSwapchainImages;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->swapchain), params->pSwapchainImageCount, params->pSwapchainImages);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->pSwapchainImageCount, params->pSwapchainImages);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetSwapchainImagesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, (uint32_t *)UlongToPtr(params->pSwapchainImageCount), (VkImage *)UlongToPtr(params->pSwapchainImages));
     return STATUS_SUCCESS;
 }

@@ -40571,19 +40571,19 @@ static NTSTATUS thunk32_vkGetValidationCacheDataEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache;
-        size_t *pDataSize;
-        void *pData;
+        PTR32 pDataSize;
+        PTR32 pData;
         VkResult result;
     } *params = args;
     size_t pDataSize_host;

-    TRACE("%p, 0x%s, %p, %p\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);
+    TRACE("%#x, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->validationCache), params->pDataSize, params->pData);

-    pDataSize_host = *params->pDataSize;
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle(params->device)->device, params->validationCache, &pDataSize_host, params->pData);
-    *params->pDataSize = pDataSize_host;
+    pDataSize_host = *(size_t *)UlongToPtr(params->pDataSize);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetValidationCacheDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->validationCache, &pDataSize_host, (void *)UlongToPtr(params->pData));
+    *(size_t *)UlongToPtr(params->pDataSize) = pDataSize_host;
     return STATUS_SUCCESS;
 }

@@ -40607,16 +40607,16 @@ static NTSTATUS thunk32_vkInitializePerformanceApiINTEL(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkInitializePerformanceApiInfoINTEL32 *pInitializeInfo;
+        PTR32 device;
+        PTR32 pInitializeInfo;
         VkResult result;
     } *params = args;
     VkInitializePerformanceApiInfoINTEL pInitializeInfo_host;

-    TRACE("%p, %p\n", params->device, params->pInitializeInfo);
+    TRACE("%#x, %#x\n", params->device, params->pInitializeInfo);

-    convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(params->pInitializeInfo, &pInitializeInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device, &pInitializeInfo_host);
+    convert_VkInitializePerformanceApiInfoINTEL_win32_to_host((const VkInitializePerformanceApiInfoINTEL32 *)UlongToPtr(params->pInitializeInfo), &pInitializeInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pInitializeInfo_host);
     return STATUS_SUCCESS;
 }

@@ -40640,19 +40640,19 @@ static NTSTATUS thunk32_vkInvalidateMappedMemoryRanges(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t memoryRangeCount;
-        const VkMappedMemoryRange32 *pMemoryRanges;
+        PTR32 pMemoryRanges;
         VkResult result;
     } *params = args;
     const VkMappedMemoryRange *pMemoryRanges_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->device, params->memoryRangeCount, params->pMemoryRanges);
+    TRACE("%#x, %u, %#x\n", params->device, params->memoryRangeCount, params->pMemoryRanges);

init_conversion_context(&ctx);
-    pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, params->pMemoryRanges, params->memoryRangeCount);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle(params->device)->device, params->memoryRangeCount, pMemoryRanges_host);
+    pMemoryRanges_host = convert_VkMappedMemoryRange_array_win32_to_host(&ctx, (const VkMappedMemoryRange32 *)UlongToPtr(params->pMemoryRanges), params->memoryRangeCount);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkInvalidateMappedMemoryRanges(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memoryRangeCount, pMemoryRanges_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40677,18 +40677,18 @@ static NTSTATUS thunk32_vkMapMemory(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
         VkDeviceSize DECLSPEC_ALIGN(8) size;
         VkMemoryMapFlags flags;
-        void **ppData;
+        PTR32 ppData;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);
+    TRACE("%#x, 0x%s, 0x%s, 0x%s, %#x, %#x\n", params->device, wine_dbgstr_longlong(params->memory), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->size), params->flags, params->ppData);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkMapMemory(wine_device_from_handle(params->device)->device, params->memory, params->offset, params->size, params->flags, params->ppData);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkMapMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, params->offset, params->size, params->flags, (void **)UlongToPtr(params->ppData));
     return STATUS_SUCCESS;
 }

@@ -40712,16 +40712,16 @@ static NTSTATUS thunk32_vkMergePipelineCaches(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPipelineCache DECLSPEC_ALIGN(8) dstCache;
         uint32_t srcCacheCount;
-        const VkPipelineCache *pSrcCaches;
+        PTR32 pSrcCaches;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergePipelineCaches(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkMergePipelineCaches(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->dstCache, params->srcCacheCount, (const VkPipelineCache *)UlongToPtr(params->pSrcCaches));
     return STATUS_SUCCESS;
 }

@@ -40745,16 +40745,16 @@ static NTSTATUS thunk32_vkMergeValidationCachesEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkValidationCacheEXT DECLSPEC_ALIGN(8) dstCache;
         uint32_t srcCacheCount;
-        const VkValidationCacheEXT *pSrcCaches;
+        PTR32 pSrcCaches;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %p\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);
+    TRACE("%#x, 0x%s, %u, %#x\n", params->device, wine_dbgstr_longlong(params->dstCache), params->srcCacheCount, params->pSrcCaches);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle(params->device)->device, params->dstCache, params->srcCacheCount, params->pSrcCaches);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkMergeValidationCachesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->dstCache, params->srcCacheCount, (const VkValidationCacheEXT *)UlongToPtr(params->pSrcCaches));
     return STATUS_SUCCESS;
 }

@@ -40778,15 +40778,15 @@ static NTSTATUS thunk32_vkQueueBeginDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkQueue queue;
-        const VkDebugUtilsLabelEXT32 *pLabelInfo;
+        PTR32 queue;
+        PTR32 pLabelInfo;
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%p, %p\n", params->queue, params->pLabelInfo);
+    TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);

-    convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
-    wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, &pLabelInfo_host);
+    convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
+    wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
     return STATUS_SUCCESS;
 }

@@ -40810,20 +40810,20 @@ static NTSTATUS thunk32_vkQueueBindSparse(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         uint32_t bindInfoCount;
-        const VkBindSparseInfo32 *pBindInfo;
+        PTR32 pBindInfo;
         VkFence DECLSPEC_ALIGN(8) fence;
         VkResult result;
     } *params = args;
     const VkBindSparseInfo *pBindInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));
+    TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->bindInfoCount, params->pBindInfo, wine_dbgstr_longlong(params->fence));

init_conversion_context(&ctx);
-    pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, params->pBindInfo, params->bindInfoCount);
-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle(params->queue)->queue, params->bindInfoCount, pBindInfo_host, params->fence);
+    pBindInfo_host = convert_VkBindSparseInfo_array_win32_to_host(&ctx, (const VkBindSparseInfo32 *)UlongToPtr(params->pBindInfo), params->bindInfoCount);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueBindSparse(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->bindInfoCount, pBindInfo_host, params->fence);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40848,12 +40848,12 @@ static NTSTATUS thunk32_vkQueueEndDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
     } *params = args;

-    TRACE("%p\n", params->queue);
+    TRACE("%#x\n", params->queue);

-    wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue);
+    wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
     return STATUS_SUCCESS;
 }

@@ -40877,15 +40877,15 @@ static NTSTATUS thunk32_vkQueueInsertDebugUtilsLabelEXT(void *args)
 {
     struct
     {
-        VkQueue queue;
-        const VkDebugUtilsLabelEXT32 *pLabelInfo;
+        PTR32 queue;
+        PTR32 pLabelInfo;
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%p, %p\n", params->queue, params->pLabelInfo);
+    TRACE("%#x, %#x\n", params->queue, params->pLabelInfo);

-    convert_VkDebugUtilsLabelEXT_win32_to_host(params->pLabelInfo, &pLabelInfo_host);
-    wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle(params->queue)->queue, &pLabelInfo_host);
+    convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
+    wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pLabelInfo_host);
     return STATUS_SUCCESS;
 }

@@ -40909,18 +40909,18 @@ static NTSTATUS thunk32_vkQueuePresentKHR(void *args)
 {
     struct
     {
-        VkQueue queue;
-        const VkPresentInfoKHR32 *pPresentInfo;
+        PTR32 queue;
+        PTR32 pPresentInfo;
         VkResult result;
     } *params = args;
     VkPresentInfoKHR pPresentInfo_host;
     struct conversion_context ctx;

-    TRACE("%p, %p\n", params->queue, params->pPresentInfo);
+    TRACE("%#x, %#x\n", params->queue, params->pPresentInfo);

init_conversion_context(&ctx);
-    convert_VkPresentInfoKHR_win32_to_host(&ctx, params->pPresentInfo, &pPresentInfo_host);
-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle(params->queue)->queue, &pPresentInfo_host);
+    convert_VkPresentInfoKHR_win32_to_host(&ctx, (const VkPresentInfoKHR32 *)UlongToPtr(params->pPresentInfo), &pPresentInfo_host);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueuePresentKHR(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, &pPresentInfo_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -40945,14 +40945,14 @@ static NTSTATUS thunk32_vkQueueSetPerformanceConfigurationINTEL(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));
+    TRACE("%#x, 0x%s\n", params->queue, wine_dbgstr_longlong(params->configuration));

-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle(params->queue)->queue, params->configuration);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->configuration);
     return STATUS_SUCCESS;
 }

@@ -40981,20 +40981,20 @@ static NTSTATUS thunk32_vkQueueSubmit(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         uint32_t submitCount;
-        const VkSubmitInfo32 *pSubmits;
+        PTR32 pSubmits;
         VkFence DECLSPEC_ALIGN(8) fence;
         VkResult result;
     } *params = args;
     const VkSubmitInfo *pSubmits_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
+    TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

init_conversion_context(&ctx);
-    pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    pSubmits_host = convert_VkSubmitInfo_array_win32_to_host(&ctx, (const VkSubmitInfo32 *)UlongToPtr(params->pSubmits), params->submitCount);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -41024,20 +41024,20 @@ static NTSTATUS thunk32_vkQueueSubmit2(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         uint32_t submitCount;
-        const VkSubmitInfo232 *pSubmits;
+        PTR32 pSubmits;
         VkFence DECLSPEC_ALIGN(8) fence;
         VkResult result;
     } *params = args;
     const VkSubmitInfo2 *pSubmits_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
+    TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

init_conversion_context(&ctx);
-    pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit2(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -41067,20 +41067,20 @@ static NTSTATUS thunk32_vkQueueSubmit2KHR(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         uint32_t submitCount;
-        const VkSubmitInfo232 *pSubmits;
+        PTR32 pSubmits;
         VkFence DECLSPEC_ALIGN(8) fence;
         VkResult result;
     } *params = args;
     const VkSubmitInfo2 *pSubmits_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));
+    TRACE("%#x, %u, %#x, 0x%s\n", params->queue, params->submitCount, params->pSubmits, wine_dbgstr_longlong(params->fence));

init_conversion_context(&ctx);
-    pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, params->pSubmits, params->submitCount);
-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle(params->queue)->queue, params->submitCount, pSubmits_host, params->fence);
+    pSubmits_host = convert_VkSubmitInfo2_array_win32_to_host(&ctx, (const VkSubmitInfo232 *)UlongToPtr(params->pSubmits), params->submitCount);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueSubmit2KHR(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue, params->submitCount, pSubmits_host, params->fence);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -41105,13 +41105,13 @@ static NTSTATUS thunk32_vkQueueWaitIdle(void *args)
 {
     struct
     {
-        VkQueue queue;
+        PTR32 queue;
         VkResult result;
     } *params = args;

-    TRACE("%p\n", params->queue);
+    TRACE("%#x\n", params->queue);

-    params->result = wine_queue_from_handle(params->queue)->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle(params->queue)->queue);
+    params->result = wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->device->funcs.p_vkQueueWaitIdle(wine_queue_from_handle((VkQueue)UlongToPtr(params->queue))->queue);
     return STATUS_SUCCESS;
 }

@@ -41135,14 +41135,14 @@ static NTSTATUS thunk32_vkReleasePerformanceConfigurationINTEL(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkPerformanceConfigurationINTEL DECLSPEC_ALIGN(8) configuration;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->configuration));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle(params->device)->device, params->configuration);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleasePerformanceConfigurationINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->configuration);
     return STATUS_SUCCESS;
 }

@@ -41166,12 +41166,12 @@ static NTSTATUS thunk32_vkReleaseProfilingLockKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
     } *params = args;

-    TRACE("%p\n", params->device);
+    TRACE("%#x\n", params->device);

-    wine_device_from_handle(params->device)->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle(params->device)->device);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkReleaseProfilingLockKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
     return STATUS_SUCCESS;
 }

@@ -41195,14 +41195,14 @@ static NTSTATUS thunk32_vkResetCommandBuffer(void *args)
 {
     struct
     {
-        VkCommandBuffer commandBuffer;
+        PTR32 commandBuffer;
         VkCommandBufferResetFlags flags;
         VkResult result;
     } *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->flags);
+    TRACE("%#x, %#x\n", params->commandBuffer, params->flags);

-    params->result = wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->flags);
+    params->result = wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkResetCommandBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->flags);
     return STATUS_SUCCESS;
 }

@@ -41226,15 +41226,15 @@ static NTSTATUS thunk32_vkResetCommandPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
         VkCommandPoolResetFlags flags;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetCommandPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
     return STATUS_SUCCESS;
 }

@@ -41258,15 +41258,15 @@ static NTSTATUS thunk32_vkResetDescriptorPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool;
         VkDescriptorPoolResetFlags flags;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorPool), params->flags);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetDescriptorPool(wine_device_from_handle(params->device)->device, params->descriptorPool, params->flags);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetDescriptorPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorPool, params->flags);
     return STATUS_SUCCESS;
 }

@@ -41290,14 +41290,14 @@ static NTSTATUS thunk32_vkResetEvent(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetEvent(wine_device_from_handle(params->device)->device, params->event);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
     return STATUS_SUCCESS;
 }

@@ -41321,15 +41321,15 @@ static NTSTATUS thunk32_vkResetFences(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t fenceCount;
-        const VkFence *pFences;
+        PTR32 pFences;
         VkResult result;
     } *params = args;

-    TRACE("%p, %u, %p\n", params->device, params->fenceCount, params->pFences);
+    TRACE("%#x, %u, %#x\n", params->device, params->fenceCount, params->pFences);

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkResetFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetFences(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fenceCount, (const VkFence *)UlongToPtr(params->pFences));
     return STATUS_SUCCESS;
 }

@@ -41353,15 +41353,15 @@ static NTSTATUS thunk32_vkResetQueryPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
         uint32_t queryCount;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
+    TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);

-    wine_device_from_handle(params->device)->funcs.p_vkResetQueryPool(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetQueryPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount);
     return STATUS_SUCCESS;
 }

@@ -41385,15 +41385,15 @@ static NTSTATUS thunk32_vkResetQueryPoolEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkQueryPool DECLSPEC_ALIGN(8) queryPool;
         uint32_t firstQuery;
         uint32_t queryCount;
     } *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
+    TRACE("%#x, 0x%s, %u, %u\n", params->device, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);

-    wine_device_from_handle(params->device)->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle(params->device)->device, params->queryPool, params->firstQuery, params->queryCount);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkResetQueryPoolEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->queryPool, params->firstQuery, params->queryCount);
     return STATUS_SUCCESS;
 }

@@ -41419,16 +41419,16 @@ static NTSTATUS thunk32_vkSetDebugUtilsObjectNameEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDebugUtilsObjectNameInfoEXT32 *pNameInfo;
+        PTR32 device;
+        PTR32 pNameInfo;
         VkResult result;
     } *params = args;
     VkDebugUtilsObjectNameInfoEXT pNameInfo_host;

-    TRACE("%p, %p\n", params->device, params->pNameInfo);
+    TRACE("%#x, %#x\n", params->device, params->pNameInfo);

-    convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(params->pNameInfo, &pNameInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle(params->device)->device, &pNameInfo_host);
+    convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host((const VkDebugUtilsObjectNameInfoEXT32 *)UlongToPtr(params->pNameInfo), &pNameInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectNameEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pNameInfo_host);
     return STATUS_SUCCESS;
 }

@@ -41454,16 +41454,16 @@ static NTSTATUS thunk32_vkSetDebugUtilsObjectTagEXT(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkDebugUtilsObjectTagInfoEXT32 *pTagInfo;
+        PTR32 device;
+        PTR32 pTagInfo;
         VkResult result;
     } *params = args;
     VkDebugUtilsObjectTagInfoEXT pTagInfo_host;

-    TRACE("%p, %p\n", params->device, params->pTagInfo);
+    TRACE("%#x, %#x\n", params->device, params->pTagInfo);

-    convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(params->pTagInfo, &pTagInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle(params->device)->device, &pTagInfo_host);
+    convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host((const VkDebugUtilsObjectTagInfoEXT32 *)UlongToPtr(params->pTagInfo), &pTagInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDebugUtilsObjectTagEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pTagInfo_host);
     return STATUS_SUCCESS;
 }

@@ -41487,14 +41487,14 @@ static NTSTATUS thunk32_vkSetDeviceMemoryPriorityEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
         float priority;
     } *params = args;

-    TRACE("%p, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);
+    TRACE("%#x, 0x%s, %f\n", params->device, wine_dbgstr_longlong(params->memory), params->priority);

-    wine_device_from_handle(params->device)->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle(params->device)->device, params->memory, params->priority);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetDeviceMemoryPriorityEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory, params->priority);
     return STATUS_SUCCESS;
 }

@@ -41518,14 +41518,14 @@ static NTSTATUS thunk32_vkSetEvent(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkEvent DECLSPEC_ALIGN(8) event;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->event));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetEvent(wine_device_from_handle(params->device)->device, params->event);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetEvent(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->event);
     return STATUS_SUCCESS;
 }

@@ -41549,7 +41549,7 @@ static NTSTATUS thunk32_vkSetPrivateData(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkObjectType objectType;
         uint64_t DECLSPEC_ALIGN(8) objectHandle;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
@@ -41557,9 +41557,9 @@ static NTSTATUS thunk32_vkSetPrivateData(void *args)
         VkResult result;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
+    TRACE("%#x, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateData(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetPrivateData(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
     return STATUS_SUCCESS;
 }

@@ -41583,7 +41583,7 @@ static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkObjectType objectType;
         uint64_t DECLSPEC_ALIGN(8) objectHandle;
         VkPrivateDataSlot DECLSPEC_ALIGN(8) privateDataSlot;
@@ -41591,9 +41591,9 @@ static NTSTATUS thunk32_vkSetPrivateDataEXT(void *args)
         VkResult result;
     } *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));
+    TRACE("%#x, %#x, 0x%s, 0x%s, 0x%s\n", params->device, params->objectType, wine_dbgstr_longlong(params->objectHandle), wine_dbgstr_longlong(params->privateDataSlot), wine_dbgstr_longlong(params->data));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle(params->device)->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSetPrivateDataEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->objectType, wine_vk_unwrap_handle(params->objectType, params->objectHandle), params->privateDataSlot, params->data);
     return STATUS_SUCCESS;
 }

@@ -41617,16 +41617,16 @@ static NTSTATUS thunk32_vkSignalSemaphore(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSemaphoreSignalInfo32 *pSignalInfo;
+        PTR32 device;
+        PTR32 pSignalInfo;
         VkResult result;
     } *params = args;
     VkSemaphoreSignalInfo pSignalInfo_host;

-    TRACE("%p, %p\n", params->device, params->pSignalInfo);
+    TRACE("%#x, %#x\n", params->device, params->pSignalInfo);

-    convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphore(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
+    convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphore(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
     return STATUS_SUCCESS;
 }

@@ -41650,16 +41650,16 @@ static NTSTATUS thunk32_vkSignalSemaphoreKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSemaphoreSignalInfo32 *pSignalInfo;
+        PTR32 device;
+        PTR32 pSignalInfo;
         VkResult result;
     } *params = args;
     VkSemaphoreSignalInfo pSignalInfo_host;

-    TRACE("%p, %p\n", params->device, params->pSignalInfo);
+    TRACE("%#x, %#x\n", params->device, params->pSignalInfo);

-    convert_VkSemaphoreSignalInfo_win32_to_host(params->pSignalInfo, &pSignalInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle(params->device)->device, &pSignalInfo_host);
+    convert_VkSemaphoreSignalInfo_win32_to_host((const VkSemaphoreSignalInfo32 *)UlongToPtr(params->pSignalInfo), &pSignalInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkSignalSemaphoreKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pSignalInfo_host);
     return STATUS_SUCCESS;
 }

@@ -41688,19 +41688,19 @@ static NTSTATUS thunk32_vkSubmitDebugUtilsMessageEXT(void *args)
 {
     struct
     {
-        VkInstance instance;
+        PTR32 instance;
         VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
         VkDebugUtilsMessageTypeFlagsEXT messageTypes;
-        const VkDebugUtilsMessengerCallbackDataEXT32 *pCallbackData;
+        PTR32 pCallbackData;
     } *params = args;
     VkDebugUtilsMessengerCallbackDataEXT pCallbackData_host;
     struct conversion_context ctx;

-    TRACE("%p, %#x, %#x, %p\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);
+    TRACE("%#x, %#x, %#x, %#x\n", params->instance, params->messageSeverity, params->messageTypes, params->pCallbackData);

init_conversion_context(&ctx);
-    convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, params->pCallbackData, &pCallbackData_host);
-    wine_instance_from_handle(params->instance)->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle(params->instance)->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
+    convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(&ctx, (const VkDebugUtilsMessengerCallbackDataEXT32 *)UlongToPtr(params->pCallbackData), &pCallbackData_host);
+    wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->funcs.p_vkSubmitDebugUtilsMessageEXT(wine_instance_from_handle((VkInstance)UlongToPtr(params->instance))->instance, params->messageSeverity, params->messageTypes, &pCallbackData_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -41725,14 +41725,14 @@ static NTSTATUS thunk32_vkTrimCommandPool(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
         VkCommandPoolTrimFlags flags;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);

-    wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPool(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTrimCommandPool(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
     return STATUS_SUCCESS;
 }

@@ -41756,14 +41756,14 @@ static NTSTATUS thunk32_vkTrimCommandPoolKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkCommandPool DECLSPEC_ALIGN(8) commandPool;
         VkCommandPoolTrimFlags flags;
     } *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);
+    TRACE("%#x, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->commandPool), params->flags);

-    wine_device_from_handle(params->device)->funcs.p_vkTrimCommandPoolKHR(wine_device_from_handle(params->device)->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkTrimCommandPoolKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, wine_cmd_pool_from_handle(params->commandPool)->command_pool, params->flags);
     return STATUS_SUCCESS;
 }

@@ -41787,12 +41787,12 @@ static NTSTATUS thunk32_vkUninitializePerformanceApiINTEL(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
     } *params = args;

-    TRACE("%p\n", params->device);
+    TRACE("%#x\n", params->device);

-    wine_device_from_handle(params->device)->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle(params->device)->device);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUninitializePerformanceApiINTEL(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device);
     return STATUS_SUCCESS;
 }

@@ -41816,13 +41816,13 @@ static NTSTATUS thunk32_vkUnmapMemory(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDeviceMemory DECLSPEC_ALIGN(8) memory;
     } *params = args;

-    TRACE("%p, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));
+    TRACE("%#x, 0x%s\n", params->device, wine_dbgstr_longlong(params->memory));

-    wine_device_from_handle(params->device)->funcs.p_vkUnmapMemory(wine_device_from_handle(params->device)->device, params->memory);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUnmapMemory(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->memory);
     return STATUS_SUCCESS;
 }

@@ -41846,15 +41846,15 @@ static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
-        const void *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
+    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);

-    wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -41878,15 +41878,15 @@ static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkDescriptorSet DECLSPEC_ALIGN(8) descriptorSet;
         VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate;
-        const void *pData;
+        PTR32 pData;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
+    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);

-    wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }

@@ -41910,22 +41910,22 @@ static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t descriptorWriteCount;
-        const VkWriteDescriptorSet32 *pDescriptorWrites;
+        PTR32 pDescriptorWrites;
         uint32_t descriptorCopyCount;
-        const VkCopyDescriptorSet32 *pDescriptorCopies;
+        PTR32 pDescriptorCopies;
     } *params = args;
     const VkWriteDescriptorSet *pDescriptorWrites_host;
     const VkCopyDescriptorSet *pDescriptorCopies_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
+    TRACE("%#x, %u, %#x, %u, %#x\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);

init_conversion_context(&ctx);
-    pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorWrites, params->descriptorWriteCount);
-    pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, params->pDescriptorCopies, params->descriptorCopyCount);
-    wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
+    pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
+    pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
+    wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
     free_conversion_context(&ctx);
     return STATUS_SUCCESS;
 }
@@ -41950,17 +41950,17 @@ static NTSTATUS thunk32_vkWaitForFences(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t fenceCount;
-        const VkFence *pFences;
+        PTR32 pFences;
         VkBool32 waitAll;
         uint64_t DECLSPEC_ALIGN(8) timeout;
         VkResult result;
     } *params = args;

-    TRACE("%p, %u, %p, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));
+    TRACE("%#x, %u, %#x, %u, 0x%s\n", params->device, params->fenceCount, params->pFences, params->waitAll, wine_dbgstr_longlong(params->timeout));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForFences(wine_device_from_handle(params->device)->device, params->fenceCount, params->pFences, params->waitAll, params->timeout);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitForFences(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->fenceCount, (const VkFence *)UlongToPtr(params->pFences), params->waitAll, params->timeout);
     return STATUS_SUCCESS;
 }

@@ -41984,16 +41984,16 @@ static NTSTATUS thunk32_vkWaitForPresentKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain;
         uint64_t DECLSPEC_ALIGN(8) presentId;
         uint64_t DECLSPEC_ALIGN(8) timeout;
         VkResult result;
     } *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));
+    TRACE("%#x, 0x%s, 0x%s, 0x%s\n", params->device, wine_dbgstr_longlong(params->swapchain), wine_dbgstr_longlong(params->presentId), wine_dbgstr_longlong(params->timeout));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitForPresentKHR(wine_device_from_handle(params->device)->device, params->swapchain, params->presentId, params->timeout);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitForPresentKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->swapchain, params->presentId, params->timeout);
     return STATUS_SUCCESS;
 }

@@ -42017,17 +42017,17 @@ static NTSTATUS thunk32_vkWaitSemaphores(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSemaphoreWaitInfo32 *pWaitInfo;
+        PTR32 device;
+        PTR32 pWaitInfo;
         uint64_t DECLSPEC_ALIGN(8) timeout;
         VkResult result;
     } *params = args;
     VkSemaphoreWaitInfo pWaitInfo_host;

-    TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
+    TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    convert_VkSemaphoreWaitInfo_win32_to_host(params->pWaitInfo, &pWaitInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphores(wine_device_from_handle(params->device)->device, &pWaitInfo_host, params->timeout);
+    convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitSemaphores(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pWaitInfo_host, params->timeout);
     return STATUS_SUCCESS;
 }

@@ -42051,17 +42051,17 @@ static NTSTATUS thunk32_vkWaitSemaphoresKHR(void *args)
 {
     struct
     {
-        VkDevice device;
-        const VkSemaphoreWaitInfo32 *pWaitInfo;
+        PTR32 device;
+        PTR32 pWaitInfo;
         uint64_t DECLSPEC_ALIGN(8) timeout;
         VkResult result;
     } *params = args;
     VkSemaphoreWaitInfo pWaitInfo_host;

-    TRACE("%p, %p, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));
+    TRACE("%#x, %#x, 0x%s\n", params->device, params->pWaitInfo, wine_dbgstr_longlong(params->timeout));

-    convert_VkSemaphoreWaitInfo_win32_to_host(params->pWaitInfo, &pWaitInfo_host);
-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle(params->device)->device, &pWaitInfo_host, params->timeout);
+    convert_VkSemaphoreWaitInfo_win32_to_host((const VkSemaphoreWaitInfo32 *)UlongToPtr(params->pWaitInfo), &pWaitInfo_host);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWaitSemaphoresKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pWaitInfo_host, params->timeout);
     return STATUS_SUCCESS;
 }

@@ -42085,19 +42085,19 @@ static NTSTATUS thunk32_vkWriteAccelerationStructuresPropertiesKHR(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t accelerationStructureCount;
-        const VkAccelerationStructureKHR *pAccelerationStructures;
+        PTR32 pAccelerationStructures;
         VkQueryType queryType;
-        size_t dataSize;
-        void *pData;
-        size_t stride;
+        PTR32 dataSize;
+        PTR32 pData;
+        PTR32 stride;
         VkResult result;
     } *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
+    TRACE("%#x, %u, %#x, %#x, 0x%s, %#x, 0x%s\n", params->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle(params->device)->device, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->dataSize, params->pData, params->stride);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->dataSize, (void *)UlongToPtr(params->pData), params->stride);
     return STATUS_SUCCESS;
 }

@@ -42121,19 +42121,19 @@ static NTSTATUS thunk32_vkWriteMicromapsPropertiesEXT(void *args)
 {
     struct
     {
-        VkDevice device;
+        PTR32 device;
         uint32_t micromapCount;
-        const VkMicromapEXT *pMicromaps;
+        PTR32 pMicromaps;
         VkQueryType queryType;
-        size_t dataSize;
-        void *pData;
-        size_t stride;
+        PTR32 dataSize;
+        PTR32 pData;
+        PTR32 stride;
         VkResult result;
     } *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));
+    TRACE("%#x, %u, %#x, %#x, 0x%s, %#x, 0x%s\n", params->device, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->dataSize), params->pData, wine_dbgstr_longlong(params->stride));

-    params->result = wine_device_from_handle(params->device)->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle(params->device)->device, params->micromapCount, params->pMicromaps, params->queryType, params->dataSize, params->pData, params->stride);
+    params->result = wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkWriteMicromapsPropertiesEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->dataSize, (void *)UlongToPtr(params->pData), params->stride);
     return STATUS_SUCCESS;
 }