diff --git a/dlls/vulkan-1/vulkan-1.spec b/dlls/vulkan-1/vulkan-1.spec
index 1e79611d1f3..326347c9f6d 100644
--- a/dlls/vulkan-1/vulkan-1.spec
+++ b/dlls/vulkan-1/vulkan-1.spec
@@ -8,207 +8,207 @@
 # SPDX-License-Identifier: Apache-2.0 OR MIT
 #
 
-@ stdcall vkAcquireNextImage2KHR(ptr ptr ptr) winevulkan.wine_vkAcquireNextImage2KHR
-@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr) winevulkan.wine_vkAcquireNextImageKHR
-@ stdcall vkAllocateCommandBuffers(ptr ptr ptr) winevulkan.wine_vkAllocateCommandBuffers
-@ stdcall vkAllocateDescriptorSets(ptr ptr ptr) winevulkan.wine_vkAllocateDescriptorSets
-@ stdcall vkAllocateMemory(ptr ptr ptr ptr) winevulkan.wine_vkAllocateMemory
-@ stdcall vkBeginCommandBuffer(ptr ptr) winevulkan.wine_vkBeginCommandBuffer
-@ stdcall vkBindBufferMemory(ptr int64 int64 int64) winevulkan.wine_vkBindBufferMemory
-@ stdcall vkBindBufferMemory2(ptr long ptr) winevulkan.wine_vkBindBufferMemory2
-@ stdcall vkBindImageMemory(ptr int64 int64 int64) winevulkan.wine_vkBindImageMemory
-@ stdcall vkBindImageMemory2(ptr long ptr) winevulkan.wine_vkBindImageMemory2
-@ stdcall vkCmdBeginQuery(ptr int64 long long) winevulkan.wine_vkCmdBeginQuery
-@ stdcall vkCmdBeginRenderPass(ptr ptr long) winevulkan.wine_vkCmdBeginRenderPass
-@ stdcall vkCmdBeginRenderPass2(ptr ptr ptr) winevulkan.wine_vkCmdBeginRenderPass2
-@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) winevulkan.wine_vkCmdBindDescriptorSets
-@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long) winevulkan.wine_vkCmdBindIndexBuffer
-@ stdcall vkCmdBindPipeline(ptr long int64) winevulkan.wine_vkCmdBindPipeline
-@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr) winevulkan.wine_vkCmdBindVertexBuffers
-@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long) winevulkan.wine_vkCmdBlitImage
-@ stdcall vkCmdClearAttachments(ptr long ptr long ptr) winevulkan.wine_vkCmdClearAttachments
-@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr) winevulkan.wine_vkCmdClearColorImage
-@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr) winevulkan.wine_vkCmdClearDepthStencilImage
-@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr) winevulkan.wine_vkCmdCopyBuffer
-@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr) winevulkan.wine_vkCmdCopyBufferToImage
-@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr) winevulkan.wine_vkCmdCopyImage
-@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr) winevulkan.wine_vkCmdCopyImageToBuffer
-@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long) winevulkan.wine_vkCmdCopyQueryPoolResults
-@ stdcall vkCmdDispatch(ptr long long long) winevulkan.wine_vkCmdDispatch
-@ stdcall vkCmdDispatchBase(ptr long long long long long long) winevulkan.wine_vkCmdDispatchBase
-@ stdcall vkCmdDispatchIndirect(ptr int64 int64) winevulkan.wine_vkCmdDispatchIndirect
-@ stdcall vkCmdDraw(ptr long long long long) winevulkan.wine_vkCmdDraw
-@ stdcall vkCmdDrawIndexed(ptr long long long long long) winevulkan.wine_vkCmdDrawIndexed
-@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long) winevulkan.wine_vkCmdDrawIndexedIndirect
-@ stdcall vkCmdDrawIndexedIndirectCount(ptr int64 int64 int64 int64 long long) winevulkan.wine_vkCmdDrawIndexedIndirectCount
-@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long) winevulkan.wine_vkCmdDrawIndirect
-@ stdcall vkCmdDrawIndirectCount(ptr int64 int64 int64 int64 long long) winevulkan.wine_vkCmdDrawIndirectCount
-@ stdcall vkCmdEndQuery(ptr int64 long) winevulkan.wine_vkCmdEndQuery
-@ stdcall vkCmdEndRenderPass(ptr) winevulkan.wine_vkCmdEndRenderPass
-@ stdcall vkCmdEndRenderPass2(ptr ptr) winevulkan.wine_vkCmdEndRenderPass2
-@ stdcall vkCmdExecuteCommands(ptr long ptr) winevulkan.wine_vkCmdExecuteCommands
-@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long) winevulkan.wine_vkCmdFillBuffer
-@ stdcall vkCmdNextSubpass(ptr long) winevulkan.wine_vkCmdNextSubpass
-@ stdcall vkCmdNextSubpass2(ptr ptr ptr) winevulkan.wine_vkCmdNextSubpass2
-@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr) winevulkan.wine_vkCmdPipelineBarrier
-@ stdcall vkCmdPushConstants(ptr int64 long long long ptr) winevulkan.wine_vkCmdPushConstants
-@ stdcall vkCmdResetEvent(ptr int64 long) winevulkan.wine_vkCmdResetEvent
-@ stdcall vkCmdResetQueryPool(ptr int64 long long) winevulkan.wine_vkCmdResetQueryPool
-@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr) winevulkan.wine_vkCmdResolveImage
-@ stdcall vkCmdSetBlendConstants(ptr ptr) winevulkan.wine_vkCmdSetBlendConstants
-@ stdcall vkCmdSetDepthBias(ptr float float float) winevulkan.wine_vkCmdSetDepthBias
-@ stdcall vkCmdSetDepthBounds(ptr float float) winevulkan.wine_vkCmdSetDepthBounds
-@ stdcall vkCmdSetDeviceMask(ptr long) winevulkan.wine_vkCmdSetDeviceMask
-@ stdcall vkCmdSetEvent(ptr int64 long) winevulkan.wine_vkCmdSetEvent
-@ stdcall vkCmdSetLineWidth(ptr float) winevulkan.wine_vkCmdSetLineWidth
-@ stdcall vkCmdSetScissor(ptr long long ptr) winevulkan.wine_vkCmdSetScissor
-@ stdcall vkCmdSetStencilCompareMask(ptr long long) winevulkan.wine_vkCmdSetStencilCompareMask
-@ stdcall vkCmdSetStencilReference(ptr long long) winevulkan.wine_vkCmdSetStencilReference
-@ stdcall vkCmdSetStencilWriteMask(ptr long long) winevulkan.wine_vkCmdSetStencilWriteMask
-@ stdcall vkCmdSetViewport(ptr long long ptr) winevulkan.wine_vkCmdSetViewport
-@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr) winevulkan.wine_vkCmdUpdateBuffer
-@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr) winevulkan.wine_vkCmdWaitEvents
-@ stdcall vkCmdWriteTimestamp(ptr long int64 long) winevulkan.wine_vkCmdWriteTimestamp
-@ stdcall vkCreateBuffer(ptr ptr ptr ptr) winevulkan.wine_vkCreateBuffer
-@ stdcall vkCreateBufferView(ptr ptr ptr ptr) winevulkan.wine_vkCreateBufferView
-@ stdcall vkCreateCommandPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateCommandPool
-@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) winevulkan.wine_vkCreateComputePipelines
-@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorPool
-@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorSetLayout
-@ stdcall vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr) winevulkan.wine_vkCreateDescriptorUpdateTemplate
-@ stdcall vkCreateDevice(ptr ptr ptr ptr) winevulkan.wine_vkCreateDevice
+@ stdcall vkAcquireNextImage2KHR(ptr ptr ptr) winevulkan.vkAcquireNextImage2KHR
+@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr) winevulkan.vkAcquireNextImageKHR
+@ stdcall vkAllocateCommandBuffers(ptr ptr ptr) winevulkan.vkAllocateCommandBuffers
+@ stdcall vkAllocateDescriptorSets(ptr ptr ptr) winevulkan.vkAllocateDescriptorSets
+@ stdcall vkAllocateMemory(ptr ptr ptr ptr) winevulkan.vkAllocateMemory
+@ stdcall vkBeginCommandBuffer(ptr ptr) winevulkan.vkBeginCommandBuffer
+@ stdcall vkBindBufferMemory(ptr int64 int64 int64) winevulkan.vkBindBufferMemory
+@ stdcall vkBindBufferMemory2(ptr long ptr) winevulkan.vkBindBufferMemory2
+@ stdcall vkBindImageMemory(ptr int64 int64 int64) winevulkan.vkBindImageMemory
+@ stdcall vkBindImageMemory2(ptr long ptr) winevulkan.vkBindImageMemory2
+@ stdcall vkCmdBeginQuery(ptr int64 long long) winevulkan.vkCmdBeginQuery
+@ stdcall vkCmdBeginRenderPass(ptr ptr long) winevulkan.vkCmdBeginRenderPass
+@ stdcall vkCmdBeginRenderPass2(ptr ptr ptr) winevulkan.vkCmdBeginRenderPass2
+@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr) winevulkan.vkCmdBindDescriptorSets
+@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long) winevulkan.vkCmdBindIndexBuffer
+@ stdcall vkCmdBindPipeline(ptr long int64) winevulkan.vkCmdBindPipeline
+@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr) winevulkan.vkCmdBindVertexBuffers
+@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long) winevulkan.vkCmdBlitImage
+@ stdcall vkCmdClearAttachments(ptr long ptr long ptr) winevulkan.vkCmdClearAttachments
+@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr) winevulkan.vkCmdClearColorImage
+@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr) winevulkan.vkCmdClearDepthStencilImage
+@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr) winevulkan.vkCmdCopyBuffer
+@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr) winevulkan.vkCmdCopyBufferToImage
+@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr) winevulkan.vkCmdCopyImage
+@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr) winevulkan.vkCmdCopyImageToBuffer
+@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long) winevulkan.vkCmdCopyQueryPoolResults
+@ stdcall vkCmdDispatch(ptr long long long) winevulkan.vkCmdDispatch
+@ stdcall vkCmdDispatchBase(ptr long long long long long long) winevulkan.vkCmdDispatchBase
+@ stdcall vkCmdDispatchIndirect(ptr int64 int64) winevulkan.vkCmdDispatchIndirect
+@ stdcall vkCmdDraw(ptr long long long long) winevulkan.vkCmdDraw
+@ stdcall vkCmdDrawIndexed(ptr long long long long long) winevulkan.vkCmdDrawIndexed
+@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long) winevulkan.vkCmdDrawIndexedIndirect
+@ stdcall vkCmdDrawIndexedIndirectCount(ptr int64 int64 int64 int64 long long) winevulkan.vkCmdDrawIndexedIndirectCount
+@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long) winevulkan.vkCmdDrawIndirect
+@ stdcall vkCmdDrawIndirectCount(ptr int64 int64 int64 int64 long long) winevulkan.vkCmdDrawIndirectCount
+@ stdcall vkCmdEndQuery(ptr int64 long) winevulkan.vkCmdEndQuery
+@ stdcall vkCmdEndRenderPass(ptr) winevulkan.vkCmdEndRenderPass
+@ stdcall vkCmdEndRenderPass2(ptr ptr) winevulkan.vkCmdEndRenderPass2
+@ stdcall vkCmdExecuteCommands(ptr long ptr) winevulkan.vkCmdExecuteCommands
+@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long) winevulkan.vkCmdFillBuffer
+@ stdcall vkCmdNextSubpass(ptr long) winevulkan.vkCmdNextSubpass
+@ stdcall vkCmdNextSubpass2(ptr ptr ptr) winevulkan.vkCmdNextSubpass2
+@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr) winevulkan.vkCmdPipelineBarrier
+@ stdcall vkCmdPushConstants(ptr int64 long long long ptr) winevulkan.vkCmdPushConstants
+@ stdcall vkCmdResetEvent(ptr int64 long) winevulkan.vkCmdResetEvent
+@ stdcall vkCmdResetQueryPool(ptr int64 long long) winevulkan.vkCmdResetQueryPool
+@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr) winevulkan.vkCmdResolveImage
+@ stdcall vkCmdSetBlendConstants(ptr ptr) winevulkan.vkCmdSetBlendConstants
+@ stdcall vkCmdSetDepthBias(ptr float float float) winevulkan.vkCmdSetDepthBias
+@ stdcall vkCmdSetDepthBounds(ptr float float) winevulkan.vkCmdSetDepthBounds
+@ stdcall vkCmdSetDeviceMask(ptr long) winevulkan.vkCmdSetDeviceMask
+@ stdcall vkCmdSetEvent(ptr int64 long) winevulkan.vkCmdSetEvent
+@ stdcall vkCmdSetLineWidth(ptr float) winevulkan.vkCmdSetLineWidth
+@ stdcall vkCmdSetScissor(ptr long long ptr) winevulkan.vkCmdSetScissor
+@ stdcall vkCmdSetStencilCompareMask(ptr long long) winevulkan.vkCmdSetStencilCompareMask
+@ stdcall vkCmdSetStencilReference(ptr long long) winevulkan.vkCmdSetStencilReference
+@ stdcall vkCmdSetStencilWriteMask(ptr long long) winevulkan.vkCmdSetStencilWriteMask
+@ stdcall vkCmdSetViewport(ptr long long ptr) winevulkan.vkCmdSetViewport
+@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr) winevulkan.vkCmdUpdateBuffer
+@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr) winevulkan.vkCmdWaitEvents
+@ stdcall vkCmdWriteTimestamp(ptr long int64 long) winevulkan.vkCmdWriteTimestamp
+@ stdcall vkCreateBuffer(ptr ptr ptr ptr) winevulkan.vkCreateBuffer
+@ stdcall vkCreateBufferView(ptr ptr ptr ptr) winevulkan.vkCreateBufferView
+@ stdcall vkCreateCommandPool(ptr ptr ptr ptr) winevulkan.vkCreateCommandPool
+@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr) winevulkan.vkCreateComputePipelines
+@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr) winevulkan.vkCreateDescriptorPool
+@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr) winevulkan.vkCreateDescriptorSetLayout
+@ stdcall vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr) winevulkan.vkCreateDescriptorUpdateTemplate
+@ stdcall vkCreateDevice(ptr ptr ptr ptr) winevulkan.vkCreateDevice
 @ stub vkCreateDisplayModeKHR
 @ stub vkCreateDisplayPlaneSurfaceKHR
-@ stdcall vkCreateEvent(ptr ptr ptr ptr) winevulkan.wine_vkCreateEvent
-@ stdcall vkCreateFence(ptr ptr ptr ptr) winevulkan.wine_vkCreateFence
-@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr) winevulkan.wine_vkCreateFramebuffer
-@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr) winevulkan.wine_vkCreateGraphicsPipelines
-@ stdcall vkCreateImage(ptr ptr ptr ptr) winevulkan.wine_vkCreateImage
-@ stdcall vkCreateImageView(ptr ptr ptr ptr) winevulkan.wine_vkCreateImageView
-@ stdcall vkCreateInstance(ptr ptr ptr) winevulkan.wine_vkCreateInstance
-@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr) winevulkan.wine_vkCreatePipelineCache
-@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr) winevulkan.wine_vkCreatePipelineLayout
-@ stdcall vkCreateQueryPool(ptr ptr ptr ptr) winevulkan.wine_vkCreateQueryPool
-@ stdcall vkCreateRenderPass(ptr ptr ptr ptr) winevulkan.wine_vkCreateRenderPass
-@ stdcall vkCreateRenderPass2(ptr ptr ptr ptr) winevulkan.wine_vkCreateRenderPass2
-@ stdcall vkCreateSampler(ptr ptr ptr ptr) winevulkan.wine_vkCreateSampler
-@ stdcall vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr) winevulkan.wine_vkCreateSamplerYcbcrConversion
-@ stdcall vkCreateSemaphore(ptr ptr ptr ptr) winevulkan.wine_vkCreateSemaphore
-@ stdcall vkCreateShaderModule(ptr ptr ptr ptr) winevulkan.wine_vkCreateShaderModule
+@ stdcall vkCreateEvent(ptr ptr ptr ptr) winevulkan.vkCreateEvent
+@ stdcall vkCreateFence(ptr ptr ptr ptr) winevulkan.vkCreateFence
+@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr) winevulkan.vkCreateFramebuffer
+@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr) winevulkan.vkCreateGraphicsPipelines
+@ stdcall vkCreateImage(ptr ptr ptr ptr) winevulkan.vkCreateImage
+@ stdcall vkCreateImageView(ptr ptr ptr ptr) winevulkan.vkCreateImageView
+@ stdcall vkCreateInstance(ptr ptr ptr) winevulkan.vkCreateInstance
+@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr) winevulkan.vkCreatePipelineCache
+@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr) winevulkan.vkCreatePipelineLayout
+@ stdcall vkCreateQueryPool(ptr ptr ptr ptr) winevulkan.vkCreateQueryPool
+@ stdcall vkCreateRenderPass(ptr ptr ptr ptr) winevulkan.vkCreateRenderPass
+@ stdcall vkCreateRenderPass2(ptr ptr ptr ptr) winevulkan.vkCreateRenderPass2
+@ stdcall vkCreateSampler(ptr ptr ptr ptr) winevulkan.vkCreateSampler
+@ stdcall vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr) winevulkan.vkCreateSamplerYcbcrConversion
+@ stdcall vkCreateSemaphore(ptr ptr ptr ptr) winevulkan.vkCreateSemaphore
+@ stdcall vkCreateShaderModule(ptr ptr ptr ptr) winevulkan.vkCreateShaderModule
 @ stub vkCreateSharedSwapchainsKHR
-@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr) winevulkan.wine_vkCreateSwapchainKHR
-@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr) winevulkan.wine_vkCreateWin32SurfaceKHR
-@ stdcall vkDestroyBuffer(ptr int64 ptr) winevulkan.wine_vkDestroyBuffer
-@ stdcall vkDestroyBufferView(ptr int64 ptr) winevulkan.wine_vkDestroyBufferView
-@ stdcall vkDestroyCommandPool(ptr int64 ptr) winevulkan.wine_vkDestroyCommandPool
-@ stdcall vkDestroyDescriptorPool(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorPool
-@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorSetLayout
-@ stdcall vkDestroyDescriptorUpdateTemplate(ptr int64 ptr) winevulkan.wine_vkDestroyDescriptorUpdateTemplate
-@ stdcall vkDestroyDevice(ptr ptr) winevulkan.wine_vkDestroyDevice
-@ stdcall vkDestroyEvent(ptr int64 ptr) winevulkan.wine_vkDestroyEvent
-@ stdcall vkDestroyFence(ptr int64 ptr) winevulkan.wine_vkDestroyFence
-@ stdcall vkDestroyFramebuffer(ptr int64 ptr) winevulkan.wine_vkDestroyFramebuffer
-@ stdcall vkDestroyImage(ptr int64 ptr) winevulkan.wine_vkDestroyImage
-@ stdcall vkDestroyImageView(ptr int64 ptr) winevulkan.wine_vkDestroyImageView
-@ stdcall vkDestroyInstance(ptr ptr) winevulkan.wine_vkDestroyInstance
-@ stdcall vkDestroyPipeline(ptr int64 ptr) winevulkan.wine_vkDestroyPipeline
-@ stdcall vkDestroyPipelineCache(ptr int64 ptr) winevulkan.wine_vkDestroyPipelineCache
-@ stdcall vkDestroyPipelineLayout(ptr int64 ptr) winevulkan.wine_vkDestroyPipelineLayout
-@ stdcall vkDestroyQueryPool(ptr int64 ptr) winevulkan.wine_vkDestroyQueryPool
-@ stdcall vkDestroyRenderPass(ptr int64 ptr) winevulkan.wine_vkDestroyRenderPass
-@ stdcall vkDestroySampler(ptr int64 ptr) winevulkan.wine_vkDestroySampler
-@ stdcall vkDestroySamplerYcbcrConversion(ptr int64 ptr) winevulkan.wine_vkDestroySamplerYcbcrConversion
-@ stdcall vkDestroySemaphore(ptr int64 ptr) winevulkan.wine_vkDestroySemaphore
-@ stdcall vkDestroyShaderModule(ptr int64 ptr) winevulkan.wine_vkDestroyShaderModule
-@ stdcall vkDestroySurfaceKHR(ptr int64 ptr) winevulkan.wine_vkDestroySurfaceKHR
-@ stdcall vkDestroySwapchainKHR(ptr int64 ptr) winevulkan.wine_vkDestroySwapchainKHR
-@ stdcall vkDeviceWaitIdle(ptr) winevulkan.wine_vkDeviceWaitIdle
-@ stdcall vkEndCommandBuffer(ptr) winevulkan.wine_vkEndCommandBuffer
-@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr) winevulkan.wine_vkEnumerateDeviceExtensionProperties
-@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr) winevulkan.wine_vkEnumerateDeviceLayerProperties
-@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr) winevulkan.wine_vkEnumerateInstanceExtensionProperties
-@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr) winevulkan.wine_vkEnumerateInstanceLayerProperties
-@ stdcall vkEnumerateInstanceVersion(ptr) winevulkan.wine_vkEnumerateInstanceVersion
-@ stdcall vkEnumeratePhysicalDeviceGroups(ptr ptr ptr) winevulkan.wine_vkEnumeratePhysicalDeviceGroups
-@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) winevulkan.wine_vkEnumeratePhysicalDevices
-@ stdcall vkFlushMappedMemoryRanges(ptr long ptr) winevulkan.wine_vkFlushMappedMemoryRanges
-@ stdcall vkFreeCommandBuffers(ptr int64 long ptr) winevulkan.wine_vkFreeCommandBuffers
-@ stdcall vkFreeDescriptorSets(ptr int64 long ptr) winevulkan.wine_vkFreeDescriptorSets
-@ stdcall vkFreeMemory(ptr int64 ptr) winevulkan.wine_vkFreeMemory
-@ stdcall vkGetBufferDeviceAddress(ptr ptr) winevulkan.wine_vkGetBufferDeviceAddress
-@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetBufferMemoryRequirements
-@ stdcall vkGetBufferMemoryRequirements2(ptr ptr ptr) winevulkan.wine_vkGetBufferMemoryRequirements2
-@ stdcall vkGetBufferOpaqueCaptureAddress(ptr ptr) winevulkan.wine_vkGetBufferOpaqueCaptureAddress
-@ stdcall vkGetDescriptorSetLayoutSupport(ptr ptr ptr) winevulkan.wine_vkGetDescriptorSetLayoutSupport
-@ stdcall vkGetDeviceGroupPeerMemoryFeatures(ptr long long long ptr) winevulkan.wine_vkGetDeviceGroupPeerMemoryFeatures
-@ stdcall vkGetDeviceGroupPresentCapabilitiesKHR(ptr ptr) winevulkan.wine_vkGetDeviceGroupPresentCapabilitiesKHR
-@ stdcall vkGetDeviceGroupSurfacePresentModesKHR(ptr int64 ptr) winevulkan.wine_vkGetDeviceGroupSurfacePresentModesKHR
-@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr) winevulkan.wine_vkGetDeviceMemoryCommitment
-@ stdcall vkGetDeviceMemoryOpaqueCaptureAddress(ptr ptr) winevulkan.wine_vkGetDeviceMemoryOpaqueCaptureAddress
-@ stdcall vkGetDeviceProcAddr(ptr str) winevulkan.wine_vkGetDeviceProcAddr
-@ stdcall vkGetDeviceQueue(ptr long long ptr) winevulkan.wine_vkGetDeviceQueue
-@ stdcall vkGetDeviceQueue2(ptr ptr ptr) winevulkan.wine_vkGetDeviceQueue2
+@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr) winevulkan.vkCreateSwapchainKHR
+@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr) winevulkan.vkCreateWin32SurfaceKHR
+@ stdcall vkDestroyBuffer(ptr int64 ptr) winevulkan.vkDestroyBuffer
+@ stdcall vkDestroyBufferView(ptr int64 ptr) winevulkan.vkDestroyBufferView
+@ stdcall vkDestroyCommandPool(ptr int64 ptr) winevulkan.vkDestroyCommandPool
+@ stdcall vkDestroyDescriptorPool(ptr int64 ptr) winevulkan.vkDestroyDescriptorPool
+@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr) winevulkan.vkDestroyDescriptorSetLayout
+@ stdcall vkDestroyDescriptorUpdateTemplate(ptr int64 ptr) winevulkan.vkDestroyDescriptorUpdateTemplate
+@ stdcall vkDestroyDevice(ptr ptr) winevulkan.vkDestroyDevice
+@ stdcall vkDestroyEvent(ptr int64 ptr) winevulkan.vkDestroyEvent
+@ stdcall vkDestroyFence(ptr int64 ptr) winevulkan.vkDestroyFence
+@ stdcall vkDestroyFramebuffer(ptr int64 ptr) winevulkan.vkDestroyFramebuffer
+@ stdcall vkDestroyImage(ptr int64 ptr) winevulkan.vkDestroyImage
+@ stdcall vkDestroyImageView(ptr int64 ptr) winevulkan.vkDestroyImageView
+@ stdcall vkDestroyInstance(ptr ptr) winevulkan.vkDestroyInstance
+@ stdcall vkDestroyPipeline(ptr int64 ptr) winevulkan.vkDestroyPipeline
+@ stdcall vkDestroyPipelineCache(ptr int64 ptr) winevulkan.vkDestroyPipelineCache
+@ stdcall vkDestroyPipelineLayout(ptr int64 ptr) winevulkan.vkDestroyPipelineLayout
+@ stdcall vkDestroyQueryPool(ptr int64 ptr) winevulkan.vkDestroyQueryPool
+@ stdcall vkDestroyRenderPass(ptr int64 ptr) winevulkan.vkDestroyRenderPass
+@ stdcall vkDestroySampler(ptr int64 ptr) winevulkan.vkDestroySampler
+@ stdcall vkDestroySamplerYcbcrConversion(ptr int64 ptr) winevulkan.vkDestroySamplerYcbcrConversion
+@ stdcall vkDestroySemaphore(ptr int64 ptr) winevulkan.vkDestroySemaphore
+@ stdcall vkDestroyShaderModule(ptr int64 ptr) winevulkan.vkDestroyShaderModule
+@ stdcall vkDestroySurfaceKHR(ptr int64 ptr) winevulkan.vkDestroySurfaceKHR
+@ stdcall vkDestroySwapchainKHR(ptr int64 ptr) winevulkan.vkDestroySwapchainKHR
+@ stdcall vkDeviceWaitIdle(ptr) winevulkan.vkDeviceWaitIdle
+@ stdcall vkEndCommandBuffer(ptr) winevulkan.vkEndCommandBuffer
+@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr) winevulkan.vkEnumerateDeviceExtensionProperties
+@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr) winevulkan.vkEnumerateDeviceLayerProperties
+@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr) winevulkan.vkEnumerateInstanceExtensionProperties
+@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr) winevulkan.vkEnumerateInstanceLayerProperties
+@ stdcall vkEnumerateInstanceVersion(ptr) winevulkan.vkEnumerateInstanceVersion
+@ stdcall vkEnumeratePhysicalDeviceGroups(ptr ptr ptr) winevulkan.vkEnumeratePhysicalDeviceGroups
+@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr) winevulkan.vkEnumeratePhysicalDevices
+@ stdcall vkFlushMappedMemoryRanges(ptr long ptr) winevulkan.vkFlushMappedMemoryRanges
+@ stdcall vkFreeCommandBuffers(ptr int64 long ptr) winevulkan.vkFreeCommandBuffers
+@ stdcall vkFreeDescriptorSets(ptr int64 long ptr) winevulkan.vkFreeDescriptorSets
+@ stdcall vkFreeMemory(ptr int64 ptr) winevulkan.vkFreeMemory
+@ stdcall vkGetBufferDeviceAddress(ptr ptr) winevulkan.vkGetBufferDeviceAddress
+@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr) winevulkan.vkGetBufferMemoryRequirements
+@ stdcall vkGetBufferMemoryRequirements2(ptr ptr ptr) winevulkan.vkGetBufferMemoryRequirements2
+@ stdcall vkGetBufferOpaqueCaptureAddress(ptr ptr) winevulkan.vkGetBufferOpaqueCaptureAddress
+@ stdcall vkGetDescriptorSetLayoutSupport(ptr ptr ptr) winevulkan.vkGetDescriptorSetLayoutSupport
+@ stdcall vkGetDeviceGroupPeerMemoryFeatures(ptr long long long ptr) winevulkan.vkGetDeviceGroupPeerMemoryFeatures
+@ stdcall vkGetDeviceGroupPresentCapabilitiesKHR(ptr ptr) winevulkan.vkGetDeviceGroupPresentCapabilitiesKHR
+@ stdcall vkGetDeviceGroupSurfacePresentModesKHR(ptr int64 ptr) winevulkan.vkGetDeviceGroupSurfacePresentModesKHR
+@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr) winevulkan.vkGetDeviceMemoryCommitment
+@ stdcall vkGetDeviceMemoryOpaqueCaptureAddress(ptr ptr) winevulkan.vkGetDeviceMemoryOpaqueCaptureAddress
+@ stdcall vkGetDeviceProcAddr(ptr str) winevulkan.vkGetDeviceProcAddr
+@ stdcall vkGetDeviceQueue(ptr long long ptr) winevulkan.vkGetDeviceQueue
+@ stdcall vkGetDeviceQueue2(ptr ptr ptr) winevulkan.vkGetDeviceQueue2
 @ stub vkGetDisplayModePropertiesKHR
 @ stub vkGetDisplayPlaneCapabilitiesKHR
 @ stub vkGetDisplayPlaneSupportedDisplaysKHR
-@ stdcall vkGetEventStatus(ptr int64) winevulkan.wine_vkGetEventStatus
-@ stdcall vkGetFenceStatus(ptr int64) winevulkan.wine_vkGetFenceStatus
-@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) winevulkan.wine_vkGetImageMemoryRequirements
-@ stdcall vkGetImageMemoryRequirements2(ptr ptr ptr) winevulkan.wine_vkGetImageMemoryRequirements2
-@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSparseMemoryRequirements
-@ stdcall vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr) winevulkan.wine_vkGetImageSparseMemoryRequirements2
-@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) winevulkan.wine_vkGetImageSubresourceLayout
-@ stdcall vkGetInstanceProcAddr(ptr str) winevulkan.wine_vkGetInstanceProcAddr
+@ stdcall vkGetEventStatus(ptr int64) winevulkan.vkGetEventStatus
+@ stdcall vkGetFenceStatus(ptr int64) winevulkan.vkGetFenceStatus
+@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr) winevulkan.vkGetImageMemoryRequirements
+@ stdcall vkGetImageMemoryRequirements2(ptr ptr ptr) winevulkan.vkGetImageMemoryRequirements2
+@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr) winevulkan.vkGetImageSparseMemoryRequirements
+@ stdcall vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr) winevulkan.vkGetImageSparseMemoryRequirements2
+@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr) winevulkan.vkGetImageSubresourceLayout
+@ stdcall vkGetInstanceProcAddr(ptr str) winevulkan.vkGetInstanceProcAddr
 @ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR
 @ stub vkGetPhysicalDeviceDisplayPropertiesKHR
-@ stdcall vkGetPhysicalDeviceExternalBufferProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceExternalBufferProperties
-@ stdcall vkGetPhysicalDeviceExternalFenceProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceExternalFenceProperties
-@ stdcall vkGetPhysicalDeviceExternalSemaphoreProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceExternalSemaphoreProperties
-@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceFeatures
-@ stdcall vkGetPhysicalDeviceFeatures2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceFeatures2
-@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) winevulkan.wine_vkGetPhysicalDeviceFormatProperties
-@ stdcall vkGetPhysicalDeviceFormatProperties2(ptr long ptr) winevulkan.wine_vkGetPhysicalDeviceFormatProperties2
-@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) winevulkan.wine_vkGetPhysicalDeviceImageFormatProperties
-@ stdcall vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceImageFormatProperties2
-@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceMemoryProperties
-@ stdcall vkGetPhysicalDeviceMemoryProperties2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceMemoryProperties2
-@ stdcall vkGetPhysicalDevicePresentRectanglesKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetPhysicalDevicePresentRectanglesKHR
-@ stdcall vkGetPhysicalDeviceProperties(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceProperties
-@ stdcall vkGetPhysicalDeviceProperties2(ptr ptr) winevulkan.wine_vkGetPhysicalDeviceProperties2
-@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceQueueFamilyProperties
-@ stdcall vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceQueueFamilyProperties2
-@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSparseImageFormatProperties
-@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSparseImageFormatProperties2
-@ stdcall vkGetPhysicalDeviceSurfaceCapabilities2KHR(ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR
-@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR
-@ stdcall vkGetPhysicalDeviceSurfaceFormats2KHR(ptr ptr ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceFormats2KHR
-@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceFormatsKHR
-@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetPhysicalDeviceSurfacePresentModesKHR
-@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr) winevulkan.wine_vkGetPhysicalDeviceSurfaceSupportKHR
-@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long) winevulkan.wine_vkGetPhysicalDeviceWin32PresentationSupportKHR
-@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr) winevulkan.wine_vkGetPipelineCacheData
-@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long) winevulkan.wine_vkGetQueryPoolResults
-@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr) winevulkan.wine_vkGetRenderAreaGranularity
-@ stdcall vkGetSemaphoreCounterValue(ptr int64 ptr) winevulkan.wine_vkGetSemaphoreCounterValue
-@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr) winevulkan.wine_vkGetSwapchainImagesKHR
-@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr) winevulkan.wine_vkInvalidateMappedMemoryRanges
-@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr) winevulkan.wine_vkMapMemory
-@ stdcall vkMergePipelineCaches(ptr int64 long ptr) winevulkan.wine_vkMergePipelineCaches
-@ stdcall vkQueueBindSparse(ptr long ptr int64) winevulkan.wine_vkQueueBindSparse
-@ stdcall vkQueuePresentKHR(ptr ptr) winevulkan.wine_vkQueuePresentKHR
-@ stdcall vkQueueSubmit(ptr long ptr int64) winevulkan.wine_vkQueueSubmit
-@ stdcall vkQueueWaitIdle(ptr) winevulkan.wine_vkQueueWaitIdle
-@ stdcall vkResetCommandBuffer(ptr long) winevulkan.wine_vkResetCommandBuffer
-@ stdcall vkResetCommandPool(ptr int64 long) winevulkan.wine_vkResetCommandPool
-@ stdcall vkResetDescriptorPool(ptr int64 long) winevulkan.wine_vkResetDescriptorPool
-@ stdcall vkResetEvent(ptr int64) winevulkan.wine_vkResetEvent
-@ stdcall vkResetFences(ptr long ptr) winevulkan.wine_vkResetFences
-@ stdcall vkResetQueryPool(ptr int64 long long) winevulkan.wine_vkResetQueryPool
-@ stdcall vkSetEvent(ptr int64) winevulkan.wine_vkSetEvent
-@ stdcall vkSignalSemaphore(ptr ptr) winevulkan.wine_vkSignalSemaphore
-@ stdcall vkTrimCommandPool(ptr int64 long) winevulkan.wine_vkTrimCommandPool
-@ stdcall vkUnmapMemory(ptr int64) winevulkan.wine_vkUnmapMemory
-@ stdcall vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr) winevulkan.wine_vkUpdateDescriptorSetWithTemplate
-@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) winevulkan.wine_vkUpdateDescriptorSets
-@ stdcall vkWaitForFences(ptr long ptr long int64) winevulkan.wine_vkWaitForFences
-@ stdcall vkWaitSemaphores(ptr ptr int64) winevulkan.wine_vkWaitSemaphores
+@ stdcall vkGetPhysicalDeviceExternalBufferProperties(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceExternalBufferProperties
+@ stdcall vkGetPhysicalDeviceExternalFenceProperties(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceExternalFenceProperties
+@ stdcall vkGetPhysicalDeviceExternalSemaphoreProperties(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceExternalSemaphoreProperties
+@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr) winevulkan.vkGetPhysicalDeviceFeatures
+@ stdcall vkGetPhysicalDeviceFeatures2(ptr ptr) winevulkan.vkGetPhysicalDeviceFeatures2
+@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr) winevulkan.vkGetPhysicalDeviceFormatProperties
+@ stdcall vkGetPhysicalDeviceFormatProperties2(ptr long ptr) winevulkan.vkGetPhysicalDeviceFormatProperties2
+@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr) winevulkan.vkGetPhysicalDeviceImageFormatProperties
+@ stdcall vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceImageFormatProperties2
+@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr) winevulkan.vkGetPhysicalDeviceMemoryProperties
+@ stdcall vkGetPhysicalDeviceMemoryProperties2(ptr ptr) winevulkan.vkGetPhysicalDeviceMemoryProperties2
+@ stdcall vkGetPhysicalDevicePresentRectanglesKHR(ptr int64 ptr ptr) winevulkan.vkGetPhysicalDevicePresentRectanglesKHR
+@ stdcall vkGetPhysicalDeviceProperties(ptr ptr) winevulkan.vkGetPhysicalDeviceProperties
+@ stdcall vkGetPhysicalDeviceProperties2(ptr ptr) winevulkan.vkGetPhysicalDeviceProperties2
+@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceQueueFamilyProperties
+@ stdcall vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceQueueFamilyProperties2
+@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr) winevulkan.vkGetPhysicalDeviceSparseImageFormatProperties
+@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr) winevulkan.vkGetPhysicalDeviceSparseImageFormatProperties2
+@ stdcall vkGetPhysicalDeviceSurfaceCapabilities2KHR(ptr ptr ptr) winevulkan.vkGetPhysicalDeviceSurfaceCapabilities2KHR
+@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr) winevulkan.vkGetPhysicalDeviceSurfaceCapabilitiesKHR
+@ stdcall vkGetPhysicalDeviceSurfaceFormats2KHR(ptr ptr ptr ptr) winevulkan.vkGetPhysicalDeviceSurfaceFormats2KHR
+@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr) winevulkan.vkGetPhysicalDeviceSurfaceFormatsKHR
+@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr) winevulkan.vkGetPhysicalDeviceSurfacePresentModesKHR
+@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr) winevulkan.vkGetPhysicalDeviceSurfaceSupportKHR
+@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long) winevulkan.vkGetPhysicalDeviceWin32PresentationSupportKHR
+@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr) winevulkan.vkGetPipelineCacheData
+@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long) winevulkan.vkGetQueryPoolResults
+@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr) winevulkan.vkGetRenderAreaGranularity
+@ stdcall vkGetSemaphoreCounterValue(ptr int64 ptr) winevulkan.vkGetSemaphoreCounterValue
+@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr) winevulkan.vkGetSwapchainImagesKHR
+@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr) winevulkan.vkInvalidateMappedMemoryRanges
+@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr) winevulkan.vkMapMemory
+@ stdcall vkMergePipelineCaches(ptr int64 long ptr) winevulkan.vkMergePipelineCaches
+@ stdcall vkQueueBindSparse(ptr long ptr int64) winevulkan.vkQueueBindSparse
+@ stdcall vkQueuePresentKHR(ptr ptr) winevulkan.vkQueuePresentKHR
+@ stdcall vkQueueSubmit(ptr long ptr int64) winevulkan.vkQueueSubmit
+@ stdcall vkQueueWaitIdle(ptr) winevulkan.vkQueueWaitIdle
+@ stdcall vkResetCommandBuffer(ptr long) winevulkan.vkResetCommandBuffer
+@ stdcall vkResetCommandPool(ptr int64 long) winevulkan.vkResetCommandPool
+@ stdcall vkResetDescriptorPool(ptr int64 long) winevulkan.vkResetDescriptorPool
+@ stdcall vkResetEvent(ptr int64) winevulkan.vkResetEvent
+@ stdcall vkResetFences(ptr long ptr) winevulkan.vkResetFences
+@ stdcall vkResetQueryPool(ptr int64 long long) winevulkan.vkResetQueryPool
+@ stdcall vkSetEvent(ptr int64) winevulkan.vkSetEvent
+@ stdcall vkSignalSemaphore(ptr ptr) winevulkan.vkSignalSemaphore
+@ stdcall vkTrimCommandPool(ptr int64 long) winevulkan.vkTrimCommandPool
+@ stdcall vkUnmapMemory(ptr int64) winevulkan.vkUnmapMemory
+@ stdcall vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr) winevulkan.vkUpdateDescriptorSetWithTemplate
+@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr) winevulkan.vkUpdateDescriptorSets
+@ stdcall vkWaitForFences(ptr long ptr long int64) winevulkan.vkWaitForFences
+@ stdcall vkWaitSemaphores(ptr ptr int64) winevulkan.vkWaitSemaphores
diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 37720d38dcb..69fcd44160e 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -13,2341 +13,2341 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
 
-VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
+VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
 {
     return unix_funcs->p_vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
 }
 
-VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
+VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
 {
     return unix_funcs->p_vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
 }
 
-VkResult WINAPI wine_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
+VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
 {
     return unix_funcs->p_vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
 }
 
-VkResult WINAPI wine_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
+VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
 {
     return unix_funcs->p_vkAcquireProfilingLockKHR(device, pInfo);
 }
 
-VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
+VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
 {
     return unix_funcs->p_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
 }
 
-VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 {
     return unix_funcs->p_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
 }
 
-VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
+VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
 {
     return unix_funcs->p_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
 }
 
-VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
+VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
 {
     return unix_funcs->p_vkBeginCommandBuffer(commandBuffer, pBeginInfo);
 }
 
-VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
+VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
 {
     return unix_funcs->p_vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
 }
 
-VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     return unix_funcs->p_vkBindBufferMemory(device, buffer, memory, memoryOffset);
 }
 
-VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
+VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
     return unix_funcs->p_vkBindBufferMemory2(device, bindInfoCount, pBindInfos);
 }
 
-VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
+VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
     return unix_funcs->p_vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
 }
 
-VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     return unix_funcs->p_vkBindImageMemory(device, image, memory, memoryOffset);
 }
 
-VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
+VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
     return unix_funcs->p_vkBindImageMemory2(device, bindInfoCount, pBindInfos);
 }
 
-VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
+VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
     return unix_funcs->p_vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos);
 }
 
-VkResult WINAPI wine_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
+VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
     return unix_funcs->p_vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
 }
 
-void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
+void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
 {
     unix_funcs->p_vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
 }
 
-void WINAPI wine_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
+void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     unix_funcs->p_vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
 }
 
-void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+void WINAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 {
     unix_funcs->p_vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
 }
 
-void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+void WINAPI vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
 {
     unix_funcs->p_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
 }
 
-void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
+void WINAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 {
     unix_funcs->p_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
 }
 
-void WINAPI wine_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
+void WINAPI vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
     unix_funcs->p_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
 }
 
-void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
+void WINAPI vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
     unix_funcs->p_vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
 }
 
-void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
+void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     unix_funcs->p_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 }
 
-void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
+void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
 {
     unix_funcs->p_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+void WINAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     unix_funcs->p_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
 }
 
-void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+void WINAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     unix_funcs->p_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
 }
 
-void WINAPI wine_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
+void WINAPI vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
 {
     unix_funcs->p_vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
 }
 
-void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
+void WINAPI vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 {
     unix_funcs->p_vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
 }
 
-void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
+void WINAPI vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
 {
     unix_funcs->p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
 }
 
-void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
+void WINAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 {
     unix_funcs->p_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
 }
 
-void WINAPI wine_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
+void WINAPI vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 {
     unix_funcs->p_vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
 }
 
-void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
+void WINAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 {
     unix_funcs->p_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
-void WINAPI wine_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
+void WINAPI vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
 {
     unix_funcs->p_vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo);
 }
 
-void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
+void WINAPI vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
 {
     unix_funcs->p_vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
 }
 
-void WINAPI wine_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
+void WINAPI vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
 {
     unix_funcs->p_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
 }
 
-void WINAPI wine_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
+void WINAPI vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
     unix_funcs->p_vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
 }
 
-void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
+void WINAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 {
     unix_funcs->p_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     unix_funcs->p_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
-void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     unix_funcs->p_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-void WINAPI wine_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
+void WINAPI vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
     unix_funcs->p_vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
 }
 
-void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
+void WINAPI vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
 {
     unix_funcs->p_vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
 }
 
-void WINAPI wine_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
+void WINAPI vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
     unix_funcs->p_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
 }
 
-void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
+void WINAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 {
     unix_funcs->p_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
 }
 
-void WINAPI wine_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
+void WINAPI vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
 {
     unix_funcs->p_vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo);
 }
 
-void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
     unix_funcs->p_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-void WINAPI wine_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
+void WINAPI vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
 {
     unix_funcs->p_vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo);
 }
 
-void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
+void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 {
     unix_funcs->p_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-void WINAPI wine_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
+void WINAPI vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
 {
     unix_funcs->p_vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo);
 }
 
-void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
     unix_funcs->p_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
 }
 
-void WINAPI wine_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
+void WINAPI vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
 {
     unix_funcs->p_vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo);
 }
 
-void WINAPI wine_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
+void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
     unix_funcs->p_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
 }
 
-void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     unix_funcs->p_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
-void WINAPI wine_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
+void WINAPI vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     unix_funcs->p_vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
 }
 
-void WINAPI wine_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
+void WINAPI vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
 {
     unix_funcs->p_vkCmdDebugMarkerEndEXT(commandBuffer);
 }
 
-void WINAPI wine_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
+void WINAPI vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     unix_funcs->p_vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
 }
 
-void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     unix_funcs->p_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
 }
 
-void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     unix_funcs->p_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 }
 
-void WINAPI wine_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     unix_funcs->p_vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 }
 
-void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     unix_funcs->p_vkCmdDispatchIndirect(commandBuffer, buffer, offset);
 }
 
-void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+void WINAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     unix_funcs->p_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+void WINAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
     unix_funcs->p_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+void WINAPI vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
 {
     unix_funcs->p_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
 }
 
-void WINAPI wine_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     unix_funcs->p_vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
 }
 
-void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
+void WINAPI vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
 {
     unix_funcs->p_vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
 }
 
-void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
+void WINAPI vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
 {
     unix_funcs->p_vkCmdEndConditionalRenderingEXT(commandBuffer);
 }
 
-void WINAPI wine_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
+void WINAPI vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
 {
     unix_funcs->p_vkCmdEndDebugUtilsLabelEXT(commandBuffer);
 }
 
-void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+void WINAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 {
     unix_funcs->p_vkCmdEndQuery(commandBuffer, queryPool, query);
 }
 
-void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+void WINAPI vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
 {
     unix_funcs->p_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
 }
 
-void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+void WINAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     unix_funcs->p_vkCmdEndRenderPass(commandBuffer);
 }
 
-void WINAPI wine_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     unix_funcs->p_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
 }
 
-void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     unix_funcs->p_vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
 }
 
-void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
+void WINAPI vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     unix_funcs->p_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 }
 
-void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
+void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
 {
     unix_funcs->p_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
 }
 
-void WINAPI wine_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
+void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     unix_funcs->p_vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
 }
 
-void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+void WINAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     unix_funcs->p_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
-void WINAPI wine_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
+void WINAPI vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     unix_funcs->p_vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
 }
 
-void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+void WINAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     unix_funcs->p_vkCmdNextSubpass(commandBuffer, contents);
 }
 
-void WINAPI wine_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     unix_funcs->p_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
 }
 
-void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     unix_funcs->p_vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
 }
 
-void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+void WINAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
 {
     unix_funcs->p_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-void WINAPI wine_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
+void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
 {
     unix_funcs->p_vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo);
 }
 
-void WINAPI wine_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
+void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     unix_funcs->p_vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
 }
 
-void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
+void WINAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 {
     unix_funcs->p_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
 }
 
-void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
+void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
 {
     unix_funcs->p_vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
 }
 
-void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
+void WINAPI vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
 {
     unix_funcs->p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
 }
 
-void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     unix_funcs->p_vkCmdResetEvent(commandBuffer, event, stageMask);
 }
 
-void WINAPI wine_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
+void WINAPI vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
 {
     unix_funcs->p_vkCmdResetEvent2KHR(commandBuffer, event, stageMask);
 }
 
-void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     unix_funcs->p_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
 }
 
-void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
+void WINAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 {
     unix_funcs->p_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-void WINAPI wine_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
+void WINAPI vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
 {
     unix_funcs->p_vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo);
 }
 
-void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+void WINAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     unix_funcs->p_vkCmdSetBlendConstants(commandBuffer, blendConstants);
 }
 
-void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
+void WINAPI vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
 {
     unix_funcs->p_vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
 }
 
-void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
+void WINAPI vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
 {
     unix_funcs->p_vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
 }
 
-void WINAPI wine_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
+void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
 {
     unix_funcs->p_vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
 }
 
-void WINAPI wine_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
+void WINAPI vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 {
     unix_funcs->p_vkCmdSetCullModeEXT(commandBuffer, cullMode);
 }
 
-void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+void WINAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
     unix_funcs->p_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-void WINAPI wine_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
+void WINAPI vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
 {
     unix_funcs->p_vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable);
 }
 
-void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+void WINAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
     unix_funcs->p_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
 }
 
-void WINAPI wine_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
+void WINAPI vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
 {
     unix_funcs->p_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable);
 }
 
-void WINAPI wine_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
+void WINAPI vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 {
     unix_funcs->p_vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp);
 }
 
-void WINAPI wine_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
+void WINAPI vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
 {
     unix_funcs->p_vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable);
 }
 
-void WINAPI wine_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
+void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
 {
     unix_funcs->p_vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable);
 }
 
-void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+void WINAPI vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     unix_funcs->p_vkCmdSetDeviceMask(commandBuffer, deviceMask);
 }
 
-void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+void WINAPI vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     unix_funcs->p_vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask);
 }
 
-void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
+void WINAPI vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
 {
     unix_funcs->p_vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
 }
 
-void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     unix_funcs->p_vkCmdSetEvent(commandBuffer, event, stageMask);
 }
 
-void WINAPI wine_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
+void WINAPI vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
 {
     unix_funcs->p_vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo);
 }
 
-void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
+void WINAPI vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
 {
     unix_funcs->p_vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
 }
 
-void WINAPI wine_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
+void WINAPI vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     unix_funcs->p_vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
 }
 
-void WINAPI wine_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
+void WINAPI vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     unix_funcs->p_vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
 }
 
-void WINAPI wine_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
+void WINAPI vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
 {
     unix_funcs->p_vkCmdSetFrontFaceEXT(commandBuffer, frontFace);
 }
 
-void WINAPI wine_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
+void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 {
     unix_funcs->p_vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
 }
 
-void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     unix_funcs->p_vkCmdSetLineWidth(commandBuffer, lineWidth);
 }
 
-void WINAPI wine_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
+void WINAPI vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
 {
     unix_funcs->p_vkCmdSetLogicOpEXT(commandBuffer, logicOp);
 }
 
-void WINAPI wine_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
+void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
 {
     unix_funcs->p_vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
 }
 
-VkResult WINAPI wine_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
+VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
 {
     return unix_funcs->p_vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
 }
 
-VkResult WINAPI wine_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
+VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
 {
     return unix_funcs->p_vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
 }
 
-VkResult WINAPI wine_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
+VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
 {
     return unix_funcs->p_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
 }
 
-void WINAPI wine_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
+void WINAPI vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
 {
     unix_funcs->p_vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable);
 }
 
-void WINAPI wine_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
+void WINAPI vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
 {
     unix_funcs->p_vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology);
 }
 
-void WINAPI wine_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
+void WINAPI vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
 {
     unix_funcs->p_vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable);
 }
 
-void WINAPI wine_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
+void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
 {
     unix_funcs->p_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
 }
 
-void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
+void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
 {
     unix_funcs->p_vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
 }
 
-void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
+void WINAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     unix_funcs->p_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
 }
 
-void WINAPI wine_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
+void WINAPI vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     unix_funcs->p_vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors);
 }
 
-void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+void WINAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     unix_funcs->p_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
 }
 
-void WINAPI wine_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
+void WINAPI vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
 {
     unix_funcs->p_vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
 }
 
-void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+void WINAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
     unix_funcs->p_vkCmdSetStencilReference(commandBuffer, faceMask, reference);
 }
 
-void WINAPI wine_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
+void WINAPI vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
 {
     unix_funcs->p_vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable);
 }
 
-void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+void WINAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
     unix_funcs->p_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
 }
 
-void WINAPI wine_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
+void WINAPI vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
 {
     unix_funcs->p_vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
 }
 
-void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
+void WINAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 {
     unix_funcs->p_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
 }
 
-void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
+void WINAPI vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
 {
     unix_funcs->p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
 }
 
-void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
+void WINAPI vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
 {
     unix_funcs->p_vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
 }
 
-void WINAPI wine_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
+void WINAPI vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
 {
     unix_funcs->p_vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports);
 }
 
-void WINAPI wine_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
+void WINAPI vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
 {
     unix_funcs->p_vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
 }
 
-void WINAPI wine_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
+void WINAPI vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
 {
     unix_funcs->p_vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
 }
 
-void WINAPI wine_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
+void WINAPI vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
 {
     unix_funcs->p_vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
 }
 
-void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
+void WINAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 {
     unix_funcs->p_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-void WINAPI wine_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+void WINAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
 {
     unix_funcs->p_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-void WINAPI wine_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
+void WINAPI vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
 {
     unix_funcs->p_vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos);
 }
 
-void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
+void WINAPI vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 }
 
-void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
+void WINAPI vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     unix_funcs->p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 }
 
-void WINAPI wine_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
+void WINAPI vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     unix_funcs->p_vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
 }
 
-void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
+void WINAPI vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     unix_funcs->p_vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
 }
 
-void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+void WINAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 {
     unix_funcs->p_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
 }
 
-void WINAPI wine_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
+void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
 {
     unix_funcs->p_vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query);
 }
 
-VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
+VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
 {
     return unix_funcs->p_vkCompileDeferredNV(device, pipeline, shader);
 }
 
-VkResult WINAPI wine_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
+VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
     return unix_funcs->p_vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo);
 }
 
-VkResult WINAPI wine_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
+VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
     return unix_funcs->p_vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
 }
 
-VkResult WINAPI wine_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
+VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
     return unix_funcs->p_vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
 }
 
-VkResult WINAPI wine_vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
+VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 {
     return unix_funcs->p_vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
 }
 
-VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
+VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
 {
     return unix_funcs->p_vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
 }
 
-VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
+VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 {
     return unix_funcs->p_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 }
 
-VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
+VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 {
     return unix_funcs->p_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
 }
 
-VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
+VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
 {
     return unix_funcs->p_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
 }
 
-VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     return unix_funcs->p_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-VkResult WINAPI wine_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
+VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
 {
     return unix_funcs->p_vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
 }
 
-VkResult WINAPI wine_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
+VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
 {
     return unix_funcs->p_vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
 }
 
-VkResult WINAPI wine_vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
+VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
 {
     return unix_funcs->p_vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
 }
 
-VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
+VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 {
     return unix_funcs->p_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 
-VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
+VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 {
     return unix_funcs->p_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 }
 
-VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
+VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
     return unix_funcs->p_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 }
 
-VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
+VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
     return unix_funcs->p_vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
 }
 
-VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
+VkResult WINAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
 {
     return unix_funcs->p_vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
 }
 
-VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
+VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 {
     return unix_funcs->p_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
 }
 
-VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
+VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 {
     return unix_funcs->p_vkCreateFence(device, pCreateInfo, pAllocator, pFence);
 }
 
-VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
+VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 {
     return unix_funcs->p_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 }
 
-VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     return unix_funcs->p_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
+VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 {
     return unix_funcs->p_vkCreateImage(device, pCreateInfo, pAllocator, pImage);
 }
 
-VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
+VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 {
     return unix_funcs->p_vkCreateImageView(device, pCreateInfo, pAllocator, pView);
 }
 
-VkResult WINAPI wine_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
+VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
 {
     return unix_funcs->p_vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
 }
 
-VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
+VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 {
     return unix_funcs->p_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 }
 
-VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
+VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 {
     return unix_funcs->p_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 }
 
-VkResult WINAPI wine_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
+VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
 {
     return unix_funcs->p_vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot);
 }
 
-VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
+VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 {
     return unix_funcs->p_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 }
 
-VkResult WINAPI wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     return unix_funcs->p_vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     return unix_funcs->p_vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
-VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     return unix_funcs->p_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-VkResult WINAPI wine_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     return unix_funcs->p_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     return unix_funcs->p_vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
-VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
+VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 {
     return unix_funcs->p_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
 }
 
-VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
+VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     return unix_funcs->p_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
 }
 
-VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
+VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     return unix_funcs->p_vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
 }
 
-VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
+VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 {
     return unix_funcs->p_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 }
 
-VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
+VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 {
     return unix_funcs->p_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 }
 
-VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
+VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
 {
     return unix_funcs->p_vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
 }
 
-VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
+VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
 {
     return unix_funcs->p_vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
 }
 
-VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
+VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
 {
     return unix_funcs->p_vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
 }
 
-VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
+VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
 {
     return unix_funcs->p_vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
 }
 
-VkResult WINAPI wine_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
+VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
 {
     return unix_funcs->p_vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
 }
 
-void WINAPI wine_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
+void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
 {
     unix_funcs->p_vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
 }
 
-VkResult WINAPI wine_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
+VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     return unix_funcs->p_vkDeferredOperationJoinKHR(device, operation);
 }
 
-void WINAPI wine_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
 }
 
-void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
 }
 
-void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyBuffer(device, buffer, pAllocator);
 }
 
-void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyBufferView(device, bufferView, pAllocator);
 }
 
-void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyCommandPool(device, commandPool, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDeferredOperationKHR(device, operation, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
 }
 
-void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyDevice(device, pAllocator);
 }
 
-void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyEvent(device, event, pAllocator);
 }
 
-void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyFence(device, fence, pAllocator);
 }
 
-void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyFramebuffer(device, framebuffer, pAllocator);
 }
 
-void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyImage(device, image, pAllocator);
 }
 
-void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyImageView(device, imageView, pAllocator);
 }
 
-void WINAPI wine_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
 }
 
-void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyInstance(instance, pAllocator);
 }
 
-void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyPipeline(device, pipeline, pAllocator);
 }
 
-void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
-void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
 }
 
-void WINAPI wine_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator);
 }
 
-void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyQueryPool(device, queryPool, pAllocator);
 }
 
-void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyRenderPass(device, renderPass, pAllocator);
 }
 
-void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySampler(device, sampler, pAllocator);
 }
 
-void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
 }
 
-void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
 }
 
-void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySemaphore(device, semaphore, pAllocator);
 }
 
-void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyShaderModule(device, shaderModule, pAllocator);
 }
 
-void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySurfaceKHR(instance, surface, pAllocator);
 }
 
-void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
-void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
 }
 
-VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
+VkResult WINAPI vkDeviceWaitIdle(VkDevice device)
 {
     return unix_funcs->p_vkDeviceWaitIdle(device);
 }
 
-VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     return unix_funcs->p_vkEndCommandBuffer(commandBuffer);
 }
 
-VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
+VkResult WINAPI vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
 {
     return unix_funcs->p_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
 }
 
-VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
+VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
 {
     return unix_funcs->p_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
 }
 
-VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
+VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
 {
     return unix_funcs->p_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
 }
 
-VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
+VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
 {
     return unix_funcs->p_vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
 }
 
-VkResult WINAPI wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
+VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
 {
     return unix_funcs->p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
 }
 
-VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
+VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
 {
     return unix_funcs->p_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
 }
 
-VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
     return unix_funcs->p_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
-void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
+void WINAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
 {
     unix_funcs->p_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
 }
 
-VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
 {
     return unix_funcs->p_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 
-void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
+void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
 {
     unix_funcs->p_vkFreeMemory(device, memory, pAllocator);
 }
 
-void WINAPI wine_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
+void WINAPI vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
 {
     unix_funcs->p_vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
 }
 
-VkDeviceAddress WINAPI wine_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
+VkDeviceAddress WINAPI vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
 {
     return unix_funcs->p_vkGetAccelerationStructureDeviceAddressKHR(device, pInfo);
 }
 
-VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
+VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
 {
     return unix_funcs->p_vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
 }
 
-void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
+void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
 {
     unix_funcs->p_vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
 }
 
-VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetBufferDeviceAddress(device, pInfo);
 }
 
-VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+VkDeviceAddress WINAPI vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetBufferDeviceAddressEXT(device, pInfo);
 }
 
-VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+VkDeviceAddress WINAPI vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetBufferDeviceAddressKHR(device, pInfo);
 }
 
-void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
 {
     unix_funcs->p_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     unix_funcs->p_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     unix_funcs->p_vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
 }
 
-uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+uint64_t WINAPI vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetBufferOpaqueCaptureAddress(device, pInfo);
 }
 
-uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetBufferOpaqueCaptureAddressKHR(device, pInfo);
 }
 
-VkResult WINAPI wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
+VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
 {
     return unix_funcs->p_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
 }
 
-uint32_t WINAPI wine_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
+uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     return unix_funcs->p_vkGetDeferredOperationMaxConcurrencyKHR(device, operation);
 }
 
-VkResult WINAPI wine_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
+VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     return unix_funcs->p_vkGetDeferredOperationResultKHR(device, operation);
 }
 
-void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
+void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     unix_funcs->p_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
 }
 
-void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
+void WINAPI vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     unix_funcs->p_vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
 }
 
-void WINAPI wine_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
+void WINAPI vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
 {
     unix_funcs->p_vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
 }
 
-void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
+void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     unix_funcs->p_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
 
-void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
+void WINAPI vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     unix_funcs->p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
 
-VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
+VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
 {
     return unix_funcs->p_vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
 }
 
-VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
+VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
 {
     return unix_funcs->p_vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
 }
 
-void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
+void WINAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
 {
     unix_funcs->p_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
-uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
 }
 
-uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
     return unix_funcs->p_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo);
 }
 
-void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
+void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
 {
     unix_funcs->p_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
 }
 
-void WINAPI wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
+void WINAPI vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
 {
     unix_funcs->p_vkGetDeviceQueue2(device, pQueueInfo, pQueue);
 }
 
-VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
+VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
 {
     return unix_funcs->p_vkGetEventStatus(device, event);
 }
 
-VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
+VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
 {
     return unix_funcs->p_vkGetFenceStatus(device, fence);
 }
 
-void WINAPI wine_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     unix_funcs->p_vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
 {
     unix_funcs->p_vkGetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     unix_funcs->p_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     unix_funcs->p_vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
+void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
 {
     unix_funcs->p_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+void WINAPI vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     unix_funcs->p_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+void WINAPI vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     unix_funcs->p_vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
+void WINAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
 {
     unix_funcs->p_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
 }
 
-VkResult WINAPI wine_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
+VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
 {
     return unix_funcs->p_vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
 }
 
-VkResult WINAPI wine_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
+VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
 {
     return unix_funcs->p_vkGetPerformanceParameterINTEL(device, parameter, pValue);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
+VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains)
 {
     return unix_funcs->p_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
+VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
 {
     return unix_funcs->p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
+void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
+void WINAPI vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
+void WINAPI vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
+void WINAPI vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
+void WINAPI vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
+void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
+void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
 {
     unix_funcs->p_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
+void WINAPI vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     unix_funcs->p_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
+void WINAPI vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     unix_funcs->p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
+void WINAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
+void WINAPI vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
+void WINAPI vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
+VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
 {
     return unix_funcs->p_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
+VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
 {
     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
+VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
 {
     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
+VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
 {
     return unix_funcs->p_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
+void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
+void WINAPI vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
+void WINAPI vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
+void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
+VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
 {
     return unix_funcs->p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
+void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
+void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
 {
     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
+void WINAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
+void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
+void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
+void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
+void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
 }
 
-void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
+void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     unix_funcs->p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
+VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
+VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
+VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
+VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
+VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
+VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
+VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
 {
     return unix_funcs->p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
 }
 
-VkResult WINAPI wine_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
+VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
 {
     return unix_funcs->p_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties);
 }
 
-VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
+VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
 {
     return unix_funcs->p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
 }
 
-VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
+VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
 {
     return unix_funcs->p_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
 }
 
-VkResult WINAPI wine_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
+VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
 {
     return unix_funcs->p_vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
 }
 
-VkResult WINAPI wine_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
+VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
 {
     return unix_funcs->p_vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
 }
 
-VkResult WINAPI wine_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
+VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
 {
     return unix_funcs->p_vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
 }
 
-void WINAPI wine_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData)
+void WINAPI vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData)
 {
     unix_funcs->p_vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData);
 }
 
-VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
+VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     return unix_funcs->p_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 }
 
-void WINAPI wine_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
+void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
 {
     unix_funcs->p_vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
 }
 
-void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
+void WINAPI vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
 {
     unix_funcs->p_vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
 }
 
-VkResult WINAPI wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     return unix_funcs->p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     return unix_funcs->p_vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     return unix_funcs->p_vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-VkDeviceSize WINAPI wine_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
+VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
 {
     return unix_funcs->p_vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
 }
 
-void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
+void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
 {
     unix_funcs->p_vkGetRenderAreaGranularity(device, renderPass, pGranularity);
 }
 
-VkResult WINAPI wine_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
+VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     return unix_funcs->p_vkGetSemaphoreCounterValue(device, semaphore, pValue);
 }
 
-VkResult WINAPI wine_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
+VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     return unix_funcs->p_vkGetSemaphoreCounterValueKHR(device, semaphore, pValue);
 }
 
-VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
+VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
 {
     return unix_funcs->p_vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
 }
 
-VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
+VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
 {
     return unix_funcs->p_vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }
 
-VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
+VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
 {
     return unix_funcs->p_vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
 }
 
-VkResult WINAPI wine_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
+VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
 {
     return unix_funcs->p_vkInitializePerformanceApiINTEL(device, pInitializeInfo);
 }
 
-VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
     return unix_funcs->p_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
 }
 
-VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
+VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
 {
     return unix_funcs->p_vkMapMemory(device, memory, offset, size, flags, ppData);
 }
 
-VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
+VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
 {
     return unix_funcs->p_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
+VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
 {
     return unix_funcs->p_vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-void WINAPI wine_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
+void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     unix_funcs->p_vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
 }
 
-VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
+VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
 {
     return unix_funcs->p_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
 }
 
-void WINAPI wine_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
+void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
 {
     unix_funcs->p_vkQueueEndDebugUtilsLabelEXT(queue);
 }
 
-void WINAPI wine_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
+void WINAPI vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     unix_funcs->p_vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
 }
 
-VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
+VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
 {
     return unix_funcs->p_vkQueuePresentKHR(queue, pPresentInfo);
 }
 
-VkResult WINAPI wine_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
+VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
 {
     return unix_funcs->p_vkQueueSetPerformanceConfigurationINTEL(queue, configuration);
 }
 
-VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
+VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
 {
     return unix_funcs->p_vkQueueSubmit(queue, submitCount, pSubmits, fence);
 }
 
-VkResult WINAPI wine_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
+VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
 {
     return unix_funcs->p_vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence);
 }
 
-VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
+VkResult WINAPI vkQueueWaitIdle(VkQueue queue)
 {
     return unix_funcs->p_vkQueueWaitIdle(queue);
 }
 
-VkResult WINAPI wine_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
+VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
 {
     return unix_funcs->p_vkReleasePerformanceConfigurationINTEL(device, configuration);
 }
 
-void WINAPI wine_vkReleaseProfilingLockKHR(VkDevice device)
+void WINAPI vkReleaseProfilingLockKHR(VkDevice device)
 {
     unix_funcs->p_vkReleaseProfilingLockKHR(device);
 }
 
-VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
     return unix_funcs->p_vkResetCommandBuffer(commandBuffer, flags);
 }
 
-VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
     return unix_funcs->p_vkResetCommandPool(device, commandPool, flags);
 }
 
-VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     return unix_funcs->p_vkResetDescriptorPool(device, descriptorPool, flags);
 }
 
-VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
 {
     return unix_funcs->p_vkResetEvent(device, event);
 }
 
-VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
+VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
 {
     return unix_funcs->p_vkResetFences(device, fenceCount, pFences);
 }
 
-void WINAPI wine_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     unix_funcs->p_vkResetQueryPool(device, queryPool, firstQuery, queryCount);
 }
 
-void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     unix_funcs->p_vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
 }
 
-VkResult WINAPI wine_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
+VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
 {
     return unix_funcs->p_vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
 }
 
-VkResult WINAPI wine_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
+VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
 {
     return unix_funcs->p_vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
 }
 
-VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event)
 {
     return unix_funcs->p_vkSetEvent(device, event);
 }
 
-VkResult WINAPI wine_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
+VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data)
 {
     return unix_funcs->p_vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data);
 }
 
-VkResult WINAPI wine_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
+VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
     return unix_funcs->p_vkSignalSemaphore(device, pSignalInfo);
 }
 
-VkResult WINAPI wine_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
+VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
     return unix_funcs->p_vkSignalSemaphoreKHR(device, pSignalInfo);
 }
 
-void WINAPI wine_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
+void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
 {
     unix_funcs->p_vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData);
 }
 
-void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     unix_funcs->p_vkTrimCommandPool(device, commandPool, flags);
 }
 
-void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+void WINAPI vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     unix_funcs->p_vkTrimCommandPoolKHR(device, commandPool, flags);
 }
 
-void WINAPI wine_vkUninitializePerformanceApiINTEL(VkDevice device)
+void WINAPI vkUninitializePerformanceApiINTEL(VkDevice device)
 {
     unix_funcs->p_vkUninitializePerformanceApiINTEL(device);
 }
 
-void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
 {
     unix_funcs->p_vkUnmapMemory(device, memory);
 }
 
-void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
+void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     unix_funcs->p_vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
 }
 
-void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
+void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     unix_funcs->p_vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
 }
 
-void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
+void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
 {
     unix_funcs->p_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
 }
 
-VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
+VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
 {
     return unix_funcs->p_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
 }
 
-VkResult WINAPI wine_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
+VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     return unix_funcs->p_vkWaitSemaphores(device, pWaitInfo, timeout);
 }
 
-VkResult WINAPI wine_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
+VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     return unix_funcs->p_vkWaitSemaphoresKHR(device, pWaitInfo, timeout);
 }
 
-VkResult WINAPI wine_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
+VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
 {
     return unix_funcs->p_vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
 }
 
 static const struct vulkan_func vk_device_dispatch_table[] =
 {
-    {"vkAcquireNextImage2KHR", &wine_vkAcquireNextImage2KHR},
-    {"vkAcquireNextImageKHR", &wine_vkAcquireNextImageKHR},
-    {"vkAcquirePerformanceConfigurationINTEL", &wine_vkAcquirePerformanceConfigurationINTEL},
-    {"vkAcquireProfilingLockKHR", &wine_vkAcquireProfilingLockKHR},
-    {"vkAllocateCommandBuffers", &wine_vkAllocateCommandBuffers},
-    {"vkAllocateDescriptorSets", &wine_vkAllocateDescriptorSets},
-    {"vkAllocateMemory", &wine_vkAllocateMemory},
-    {"vkBeginCommandBuffer", &wine_vkBeginCommandBuffer},
-    {"vkBindAccelerationStructureMemoryNV", &wine_vkBindAccelerationStructureMemoryNV},
-    {"vkBindBufferMemory", &wine_vkBindBufferMemory},
-    {"vkBindBufferMemory2", &wine_vkBindBufferMemory2},
-    {"vkBindBufferMemory2KHR", &wine_vkBindBufferMemory2KHR},
-    {"vkBindImageMemory", &wine_vkBindImageMemory},
-    {"vkBindImageMemory2", &wine_vkBindImageMemory2},
-    {"vkBindImageMemory2KHR", &wine_vkBindImageMemory2KHR},
-    {"vkBuildAccelerationStructuresKHR", &wine_vkBuildAccelerationStructuresKHR},
-    {"vkCmdBeginConditionalRenderingEXT", &wine_vkCmdBeginConditionalRenderingEXT},
-    {"vkCmdBeginDebugUtilsLabelEXT", &wine_vkCmdBeginDebugUtilsLabelEXT},
-    {"vkCmdBeginQuery", &wine_vkCmdBeginQuery},
-    {"vkCmdBeginQueryIndexedEXT", &wine_vkCmdBeginQueryIndexedEXT},
-    {"vkCmdBeginRenderPass", &wine_vkCmdBeginRenderPass},
-    {"vkCmdBeginRenderPass2", &wine_vkCmdBeginRenderPass2},
-    {"vkCmdBeginRenderPass2KHR", &wine_vkCmdBeginRenderPass2KHR},
-    {"vkCmdBeginTransformFeedbackEXT", &wine_vkCmdBeginTransformFeedbackEXT},
-    {"vkCmdBindDescriptorSets", &wine_vkCmdBindDescriptorSets},
-    {"vkCmdBindIndexBuffer", &wine_vkCmdBindIndexBuffer},
-    {"vkCmdBindPipeline", &wine_vkCmdBindPipeline},
-    {"vkCmdBindPipelineShaderGroupNV", &wine_vkCmdBindPipelineShaderGroupNV},
-    {"vkCmdBindShadingRateImageNV", &wine_vkCmdBindShadingRateImageNV},
-    {"vkCmdBindTransformFeedbackBuffersEXT", &wine_vkCmdBindTransformFeedbackBuffersEXT},
-    {"vkCmdBindVertexBuffers", &wine_vkCmdBindVertexBuffers},
-    {"vkCmdBindVertexBuffers2EXT", &wine_vkCmdBindVertexBuffers2EXT},
-    {"vkCmdBlitImage", &wine_vkCmdBlitImage},
-    {"vkCmdBlitImage2KHR", &wine_vkCmdBlitImage2KHR},
-    {"vkCmdBuildAccelerationStructureNV", &wine_vkCmdBuildAccelerationStructureNV},
-    {"vkCmdBuildAccelerationStructuresIndirectKHR", &wine_vkCmdBuildAccelerationStructuresIndirectKHR},
-    {"vkCmdBuildAccelerationStructuresKHR", &wine_vkCmdBuildAccelerationStructuresKHR},
-    {"vkCmdClearAttachments", &wine_vkCmdClearAttachments},
-    {"vkCmdClearColorImage", &wine_vkCmdClearColorImage},
-    {"vkCmdClearDepthStencilImage", &wine_vkCmdClearDepthStencilImage},
-    {"vkCmdCopyAccelerationStructureKHR", &wine_vkCmdCopyAccelerationStructureKHR},
-    {"vkCmdCopyAccelerationStructureNV", &wine_vkCmdCopyAccelerationStructureNV},
-    {"vkCmdCopyAccelerationStructureToMemoryKHR", &wine_vkCmdCopyAccelerationStructureToMemoryKHR},
-    {"vkCmdCopyBuffer", &wine_vkCmdCopyBuffer},
-    {"vkCmdCopyBuffer2KHR", &wine_vkCmdCopyBuffer2KHR},
-    {"vkCmdCopyBufferToImage", &wine_vkCmdCopyBufferToImage},
-    {"vkCmdCopyBufferToImage2KHR", &wine_vkCmdCopyBufferToImage2KHR},
-    {"vkCmdCopyImage", &wine_vkCmdCopyImage},
-    {"vkCmdCopyImage2KHR", &wine_vkCmdCopyImage2KHR},
-    {"vkCmdCopyImageToBuffer", &wine_vkCmdCopyImageToBuffer},
-    {"vkCmdCopyImageToBuffer2KHR", &wine_vkCmdCopyImageToBuffer2KHR},
-    {"vkCmdCopyMemoryToAccelerationStructureKHR", &wine_vkCmdCopyMemoryToAccelerationStructureKHR},
-    {"vkCmdCopyQueryPoolResults", &wine_vkCmdCopyQueryPoolResults},
-    {"vkCmdDebugMarkerBeginEXT", &wine_vkCmdDebugMarkerBeginEXT},
-    {"vkCmdDebugMarkerEndEXT", &wine_vkCmdDebugMarkerEndEXT},
-    {"vkCmdDebugMarkerInsertEXT", &wine_vkCmdDebugMarkerInsertEXT},
-    {"vkCmdDispatch", &wine_vkCmdDispatch},
-    {"vkCmdDispatchBase", &wine_vkCmdDispatchBase},
-    {"vkCmdDispatchBaseKHR", &wine_vkCmdDispatchBaseKHR},
-    {"vkCmdDispatchIndirect", &wine_vkCmdDispatchIndirect},
-    {"vkCmdDraw", &wine_vkCmdDraw},
-    {"vkCmdDrawIndexed", &wine_vkCmdDrawIndexed},
-    {"vkCmdDrawIndexedIndirect", &wine_vkCmdDrawIndexedIndirect},
-    {"vkCmdDrawIndexedIndirectCount", &wine_vkCmdDrawIndexedIndirectCount},
-    {"vkCmdDrawIndexedIndirectCountAMD", &wine_vkCmdDrawIndexedIndirectCountAMD},
-    {"vkCmdDrawIndexedIndirectCountKHR", &wine_vkCmdDrawIndexedIndirectCountKHR},
-    {"vkCmdDrawIndirect", &wine_vkCmdDrawIndirect},
-    {"vkCmdDrawIndirectByteCountEXT", &wine_vkCmdDrawIndirectByteCountEXT},
-    {"vkCmdDrawIndirectCount", &wine_vkCmdDrawIndirectCount},
-    {"vkCmdDrawIndirectCountAMD", &wine_vkCmdDrawIndirectCountAMD},
-    {"vkCmdDrawIndirectCountKHR", &wine_vkCmdDrawIndirectCountKHR},
-    {"vkCmdDrawMeshTasksIndirectCountNV", &wine_vkCmdDrawMeshTasksIndirectCountNV},
-    {"vkCmdDrawMeshTasksIndirectNV", &wine_vkCmdDrawMeshTasksIndirectNV},
-    {"vkCmdDrawMeshTasksNV", &wine_vkCmdDrawMeshTasksNV},
-    {"vkCmdEndConditionalRenderingEXT", &wine_vkCmdEndConditionalRenderingEXT},
-    {"vkCmdEndDebugUtilsLabelEXT", &wine_vkCmdEndDebugUtilsLabelEXT},
-    {"vkCmdEndQuery", &wine_vkCmdEndQuery},
-    {"vkCmdEndQueryIndexedEXT", &wine_vkCmdEndQueryIndexedEXT},
-    {"vkCmdEndRenderPass", &wine_vkCmdEndRenderPass},
-    {"vkCmdEndRenderPass2", &wine_vkCmdEndRenderPass2},
-    {"vkCmdEndRenderPass2KHR", &wine_vkCmdEndRenderPass2KHR},
-    {"vkCmdEndTransformFeedbackEXT", &wine_vkCmdEndTransformFeedbackEXT},
-    {"vkCmdExecuteCommands", &wine_vkCmdExecuteCommands},
-    {"vkCmdExecuteGeneratedCommandsNV", &wine_vkCmdExecuteGeneratedCommandsNV},
-    {"vkCmdFillBuffer", &wine_vkCmdFillBuffer},
-    {"vkCmdInsertDebugUtilsLabelEXT", &wine_vkCmdInsertDebugUtilsLabelEXT},
-    {"vkCmdNextSubpass", &wine_vkCmdNextSubpass},
-    {"vkCmdNextSubpass2", &wine_vkCmdNextSubpass2},
-    {"vkCmdNextSubpass2KHR", &wine_vkCmdNextSubpass2KHR},
-    {"vkCmdPipelineBarrier", &wine_vkCmdPipelineBarrier},
-    {"vkCmdPipelineBarrier2KHR", &wine_vkCmdPipelineBarrier2KHR},
-    {"vkCmdPreprocessGeneratedCommandsNV", &wine_vkCmdPreprocessGeneratedCommandsNV},
-    {"vkCmdPushConstants", &wine_vkCmdPushConstants},
-    {"vkCmdPushDescriptorSetKHR", &wine_vkCmdPushDescriptorSetKHR},
-    {"vkCmdPushDescriptorSetWithTemplateKHR", &wine_vkCmdPushDescriptorSetWithTemplateKHR},
-    {"vkCmdResetEvent", &wine_vkCmdResetEvent},
-    {"vkCmdResetEvent2KHR", &wine_vkCmdResetEvent2KHR},
-    {"vkCmdResetQueryPool", &wine_vkCmdResetQueryPool},
-    {"vkCmdResolveImage", &wine_vkCmdResolveImage},
-    {"vkCmdResolveImage2KHR", &wine_vkCmdResolveImage2KHR},
-    {"vkCmdSetBlendConstants", &wine_vkCmdSetBlendConstants},
-    {"vkCmdSetCheckpointNV", &wine_vkCmdSetCheckpointNV},
-    {"vkCmdSetCoarseSampleOrderNV", &wine_vkCmdSetCoarseSampleOrderNV},
-    {"vkCmdSetColorWriteEnableEXT", &wine_vkCmdSetColorWriteEnableEXT},
-    {"vkCmdSetCullModeEXT", &wine_vkCmdSetCullModeEXT},
-    {"vkCmdSetDepthBias", &wine_vkCmdSetDepthBias},
-    {"vkCmdSetDepthBiasEnableEXT", &wine_vkCmdSetDepthBiasEnableEXT},
-    {"vkCmdSetDepthBounds", &wine_vkCmdSetDepthBounds},
-    {"vkCmdSetDepthBoundsTestEnableEXT", &wine_vkCmdSetDepthBoundsTestEnableEXT},
-    {"vkCmdSetDepthCompareOpEXT", &wine_vkCmdSetDepthCompareOpEXT},
-    {"vkCmdSetDepthTestEnableEXT", &wine_vkCmdSetDepthTestEnableEXT},
-    {"vkCmdSetDepthWriteEnableEXT", &wine_vkCmdSetDepthWriteEnableEXT},
-    {"vkCmdSetDeviceMask", &wine_vkCmdSetDeviceMask},
-    {"vkCmdSetDeviceMaskKHR", &wine_vkCmdSetDeviceMaskKHR},
-    {"vkCmdSetDiscardRectangleEXT", &wine_vkCmdSetDiscardRectangleEXT},
-    {"vkCmdSetEvent", &wine_vkCmdSetEvent},
-    {"vkCmdSetEvent2KHR", &wine_vkCmdSetEvent2KHR},
-    {"vkCmdSetExclusiveScissorNV", &wine_vkCmdSetExclusiveScissorNV},
-    {"vkCmdSetFragmentShadingRateEnumNV", &wine_vkCmdSetFragmentShadingRateEnumNV},
-    {"vkCmdSetFragmentShadingRateKHR", &wine_vkCmdSetFragmentShadingRateKHR},
-    {"vkCmdSetFrontFaceEXT", &wine_vkCmdSetFrontFaceEXT},
-    {"vkCmdSetLineStippleEXT", &wine_vkCmdSetLineStippleEXT},
-    {"vkCmdSetLineWidth", &wine_vkCmdSetLineWidth},
-    {"vkCmdSetLogicOpEXT", &wine_vkCmdSetLogicOpEXT},
-    {"vkCmdSetPatchControlPointsEXT", &wine_vkCmdSetPatchControlPointsEXT},
-    {"vkCmdSetPerformanceMarkerINTEL", &wine_vkCmdSetPerformanceMarkerINTEL},
-    {"vkCmdSetPerformanceOverrideINTEL", &wine_vkCmdSetPerformanceOverrideINTEL},
-    {"vkCmdSetPerformanceStreamMarkerINTEL", &wine_vkCmdSetPerformanceStreamMarkerINTEL},
-    {"vkCmdSetPrimitiveRestartEnableEXT", &wine_vkCmdSetPrimitiveRestartEnableEXT},
-    {"vkCmdSetPrimitiveTopologyEXT", &wine_vkCmdSetPrimitiveTopologyEXT},
-    {"vkCmdSetRasterizerDiscardEnableEXT", &wine_vkCmdSetRasterizerDiscardEnableEXT},
-    {"vkCmdSetRayTracingPipelineStackSizeKHR", &wine_vkCmdSetRayTracingPipelineStackSizeKHR},
-    {"vkCmdSetSampleLocationsEXT", &wine_vkCmdSetSampleLocationsEXT},
-    {"vkCmdSetScissor", &wine_vkCmdSetScissor},
-    {"vkCmdSetScissorWithCountEXT", &wine_vkCmdSetScissorWithCountEXT},
-    {"vkCmdSetStencilCompareMask", &wine_vkCmdSetStencilCompareMask},
-    {"vkCmdSetStencilOpEXT", &wine_vkCmdSetStencilOpEXT},
-    {"vkCmdSetStencilReference", &wine_vkCmdSetStencilReference},
-    {"vkCmdSetStencilTestEnableEXT", &wine_vkCmdSetStencilTestEnableEXT},
-    {"vkCmdSetStencilWriteMask", &wine_vkCmdSetStencilWriteMask},
-    {"vkCmdSetVertexInputEXT", &wine_vkCmdSetVertexInputEXT},
-    {"vkCmdSetViewport", &wine_vkCmdSetViewport},
-    {"vkCmdSetViewportShadingRatePaletteNV", &wine_vkCmdSetViewportShadingRatePaletteNV},
-    {"vkCmdSetViewportWScalingNV", &wine_vkCmdSetViewportWScalingNV},
-    {"vkCmdSetViewportWithCountEXT", &wine_vkCmdSetViewportWithCountEXT},
-    {"vkCmdTraceRaysIndirectKHR", &wine_vkCmdTraceRaysIndirectKHR},
-    {"vkCmdTraceRaysKHR", &wine_vkCmdTraceRaysKHR},
-    {"vkCmdTraceRaysNV", &wine_vkCmdTraceRaysNV},
-    {"vkCmdUpdateBuffer", &wine_vkCmdUpdateBuffer},
-    {"vkCmdWaitEvents", &wine_vkCmdWaitEvents},
-    {"vkCmdWaitEvents2KHR", &wine_vkCmdWaitEvents2KHR},
-    {"vkCmdWriteAccelerationStructuresPropertiesKHR", &wine_vkCmdWriteAccelerationStructuresPropertiesKHR},
-    {"vkCmdWriteAccelerationStructuresPropertiesNV", &wine_vkCmdWriteAccelerationStructuresPropertiesNV},
-    {"vkCmdWriteBufferMarker2AMD", &wine_vkCmdWriteBufferMarker2AMD},
-    {"vkCmdWriteBufferMarkerAMD", &wine_vkCmdWriteBufferMarkerAMD},
-    {"vkCmdWriteTimestamp", &wine_vkCmdWriteTimestamp},
-    {"vkCmdWriteTimestamp2KHR", &wine_vkCmdWriteTimestamp2KHR},
-    {"vkCompileDeferredNV", &wine_vkCompileDeferredNV},
-    {"vkCopyAccelerationStructureKHR", &wine_vkCopyAccelerationStructureKHR},
-    {"vkCopyAccelerationStructureToMemoryKHR", &wine_vkCopyAccelerationStructureToMemoryKHR},
-    {"vkCopyMemoryToAccelerationStructureKHR", &wine_vkCopyMemoryToAccelerationStructureKHR},
-    {"vkCreateAccelerationStructureKHR", &wine_vkCreateAccelerationStructureKHR},
-    {"vkCreateAccelerationStructureNV", &wine_vkCreateAccelerationStructureNV},
-    {"vkCreateBuffer", &wine_vkCreateBuffer},
-    {"vkCreateBufferView", &wine_vkCreateBufferView},
-    {"vkCreateCommandPool", &wine_vkCreateCommandPool},
-    {"vkCreateComputePipelines", &wine_vkCreateComputePipelines},
-    {"vkCreateDeferredOperationKHR", &wine_vkCreateDeferredOperationKHR},
-    {"vkCreateDescriptorPool", &wine_vkCreateDescriptorPool},
-    {"vkCreateDescriptorSetLayout", &wine_vkCreateDescriptorSetLayout},
-    {"vkCreateDescriptorUpdateTemplate", &wine_vkCreateDescriptorUpdateTemplate},
-    {"vkCreateDescriptorUpdateTemplateKHR", &wine_vkCreateDescriptorUpdateTemplateKHR},
-    {"vkCreateEvent", &wine_vkCreateEvent},
-    {"vkCreateFence", &wine_vkCreateFence},
-    {"vkCreateFramebuffer", &wine_vkCreateFramebuffer},
-    {"vkCreateGraphicsPipelines", &wine_vkCreateGraphicsPipelines},
-    {"vkCreateImage", &wine_vkCreateImage},
-    {"vkCreateImageView", &wine_vkCreateImageView},
-    {"vkCreateIndirectCommandsLayoutNV", &wine_vkCreateIndirectCommandsLayoutNV},
-    {"vkCreatePipelineCache", &wine_vkCreatePipelineCache},
-    {"vkCreatePipelineLayout", &wine_vkCreatePipelineLayout},
-    {"vkCreatePrivateDataSlotEXT", &wine_vkCreatePrivateDataSlotEXT},
-    {"vkCreateQueryPool", &wine_vkCreateQueryPool},
-    {"vkCreateRayTracingPipelinesKHR", &wine_vkCreateRayTracingPipelinesKHR},
-    {"vkCreateRayTracingPipelinesNV", &wine_vkCreateRayTracingPipelinesNV},
-    {"vkCreateRenderPass", &wine_vkCreateRenderPass},
-    {"vkCreateRenderPass2", &wine_vkCreateRenderPass2},
-    {"vkCreateRenderPass2KHR", &wine_vkCreateRenderPass2KHR},
-    {"vkCreateSampler", &wine_vkCreateSampler},
-    {"vkCreateSamplerYcbcrConversion", &wine_vkCreateSamplerYcbcrConversion},
-    {"vkCreateSamplerYcbcrConversionKHR", &wine_vkCreateSamplerYcbcrConversionKHR},
-    {"vkCreateSemaphore", &wine_vkCreateSemaphore},
-    {"vkCreateShaderModule", &wine_vkCreateShaderModule},
-    {"vkCreateSwapchainKHR", &wine_vkCreateSwapchainKHR},
-    {"vkCreateValidationCacheEXT", &wine_vkCreateValidationCacheEXT},
-    {"vkDebugMarkerSetObjectNameEXT", &wine_vkDebugMarkerSetObjectNameEXT},
-    {"vkDebugMarkerSetObjectTagEXT", &wine_vkDebugMarkerSetObjectTagEXT},
-    {"vkDeferredOperationJoinKHR", &wine_vkDeferredOperationJoinKHR},
-    {"vkDestroyAccelerationStructureKHR", &wine_vkDestroyAccelerationStructureKHR},
-    {"vkDestroyAccelerationStructureNV", &wine_vkDestroyAccelerationStructureNV},
-    {"vkDestroyBuffer", &wine_vkDestroyBuffer},
-    {"vkDestroyBufferView", &wine_vkDestroyBufferView},
-    {"vkDestroyCommandPool", &wine_vkDestroyCommandPool},
-    {"vkDestroyDeferredOperationKHR", &wine_vkDestroyDeferredOperationKHR},
-    {"vkDestroyDescriptorPool", &wine_vkDestroyDescriptorPool},
-    {"vkDestroyDescriptorSetLayout", &wine_vkDestroyDescriptorSetLayout},
-    {"vkDestroyDescriptorUpdateTemplate", &wine_vkDestroyDescriptorUpdateTemplate},
-    {"vkDestroyDescriptorUpdateTemplateKHR", &wine_vkDestroyDescriptorUpdateTemplateKHR},
-    {"vkDestroyDevice", &wine_vkDestroyDevice},
-    {"vkDestroyEvent", &wine_vkDestroyEvent},
-    {"vkDestroyFence", &wine_vkDestroyFence},
-    {"vkDestroyFramebuffer", &wine_vkDestroyFramebuffer},
-    {"vkDestroyImage", &wine_vkDestroyImage},
-    {"vkDestroyImageView", &wine_vkDestroyImageView},
-    {"vkDestroyIndirectCommandsLayoutNV", &wine_vkDestroyIndirectCommandsLayoutNV},
-    {"vkDestroyPipeline", &wine_vkDestroyPipeline},
-    {"vkDestroyPipelineCache", &wine_vkDestroyPipelineCache},
-    {"vkDestroyPipelineLayout", &wine_vkDestroyPipelineLayout},
-    {"vkDestroyPrivateDataSlotEXT", &wine_vkDestroyPrivateDataSlotEXT},
-    {"vkDestroyQueryPool", &wine_vkDestroyQueryPool},
-    {"vkDestroyRenderPass", &wine_vkDestroyRenderPass},
-    {"vkDestroySampler", &wine_vkDestroySampler},
-    {"vkDestroySamplerYcbcrConversion", &wine_vkDestroySamplerYcbcrConversion},
-    {"vkDestroySamplerYcbcrConversionKHR", &wine_vkDestroySamplerYcbcrConversionKHR},
-    {"vkDestroySemaphore", &wine_vkDestroySemaphore},
-    {"vkDestroyShaderModule", &wine_vkDestroyShaderModule},
-    {"vkDestroySwapchainKHR", &wine_vkDestroySwapchainKHR},
-    {"vkDestroyValidationCacheEXT", &wine_vkDestroyValidationCacheEXT},
-    {"vkDeviceWaitIdle", &wine_vkDeviceWaitIdle},
-    {"vkEndCommandBuffer", &wine_vkEndCommandBuffer},
-    {"vkFlushMappedMemoryRanges", &wine_vkFlushMappedMemoryRanges},
-    {"vkFreeCommandBuffers", &wine_vkFreeCommandBuffers},
-    {"vkFreeDescriptorSets", &wine_vkFreeDescriptorSets},
-    {"vkFreeMemory", &wine_vkFreeMemory},
-    {"vkGetAccelerationStructureBuildSizesKHR", &wine_vkGetAccelerationStructureBuildSizesKHR},
-    {"vkGetAccelerationStructureDeviceAddressKHR", &wine_vkGetAccelerationStructureDeviceAddressKHR},
-    {"vkGetAccelerationStructureHandleNV", &wine_vkGetAccelerationStructureHandleNV},
-    {"vkGetAccelerationStructureMemoryRequirementsNV", &wine_vkGetAccelerationStructureMemoryRequirementsNV},
-    {"vkGetBufferDeviceAddress", &wine_vkGetBufferDeviceAddress},
-    {"vkGetBufferDeviceAddressEXT", &wine_vkGetBufferDeviceAddressEXT},
-    {"vkGetBufferDeviceAddressKHR", &wine_vkGetBufferDeviceAddressKHR},
-    {"vkGetBufferMemoryRequirements", &wine_vkGetBufferMemoryRequirements},
-    {"vkGetBufferMemoryRequirements2", &wine_vkGetBufferMemoryRequirements2},
-    {"vkGetBufferMemoryRequirements2KHR", &wine_vkGetBufferMemoryRequirements2KHR},
-    {"vkGetBufferOpaqueCaptureAddress", &wine_vkGetBufferOpaqueCaptureAddress},
-    {"vkGetBufferOpaqueCaptureAddressKHR", &wine_vkGetBufferOpaqueCaptureAddressKHR},
-    {"vkGetCalibratedTimestampsEXT", &wine_vkGetCalibratedTimestampsEXT},
-    {"vkGetDeferredOperationMaxConcurrencyKHR", &wine_vkGetDeferredOperationMaxConcurrencyKHR},
-    {"vkGetDeferredOperationResultKHR", &wine_vkGetDeferredOperationResultKHR},
-    {"vkGetDescriptorSetLayoutSupport", &wine_vkGetDescriptorSetLayoutSupport},
-    {"vkGetDescriptorSetLayoutSupportKHR", &wine_vkGetDescriptorSetLayoutSupportKHR},
-    {"vkGetDeviceAccelerationStructureCompatibilityKHR", &wine_vkGetDeviceAccelerationStructureCompatibilityKHR},
-    {"vkGetDeviceGroupPeerMemoryFeatures", &wine_vkGetDeviceGroupPeerMemoryFeatures},
-    {"vkGetDeviceGroupPeerMemoryFeaturesKHR", &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR},
-    {"vkGetDeviceGroupPresentCapabilitiesKHR", &wine_vkGetDeviceGroupPresentCapabilitiesKHR},
-    {"vkGetDeviceGroupSurfacePresentModesKHR", &wine_vkGetDeviceGroupSurfacePresentModesKHR},
-    {"vkGetDeviceMemoryCommitment", &wine_vkGetDeviceMemoryCommitment},
-    {"vkGetDeviceMemoryOpaqueCaptureAddress", &wine_vkGetDeviceMemoryOpaqueCaptureAddress},
-    {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", &wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR},
-    {"vkGetDeviceProcAddr", &wine_vkGetDeviceProcAddr},
-    {"vkGetDeviceQueue", &wine_vkGetDeviceQueue},
-    {"vkGetDeviceQueue2", &wine_vkGetDeviceQueue2},
-    {"vkGetEventStatus", &wine_vkGetEventStatus},
-    {"vkGetFenceStatus", &wine_vkGetFenceStatus},
-    {"vkGetGeneratedCommandsMemoryRequirementsNV", &wine_vkGetGeneratedCommandsMemoryRequirementsNV},
-    {"vkGetImageMemoryRequirements", &wine_vkGetImageMemoryRequirements},
-    {"vkGetImageMemoryRequirements2", &wine_vkGetImageMemoryRequirements2},
-    {"vkGetImageMemoryRequirements2KHR", &wine_vkGetImageMemoryRequirements2KHR},
-    {"vkGetImageSparseMemoryRequirements", &wine_vkGetImageSparseMemoryRequirements},
-    {"vkGetImageSparseMemoryRequirements2", &wine_vkGetImageSparseMemoryRequirements2},
-    {"vkGetImageSparseMemoryRequirements2KHR", &wine_vkGetImageSparseMemoryRequirements2KHR},
-    {"vkGetImageSubresourceLayout", &wine_vkGetImageSubresourceLayout},
-    {"vkGetMemoryHostPointerPropertiesEXT", &wine_vkGetMemoryHostPointerPropertiesEXT},
-    {"vkGetPerformanceParameterINTEL", &wine_vkGetPerformanceParameterINTEL},
-    {"vkGetPipelineCacheData", &wine_vkGetPipelineCacheData},
-    {"vkGetPipelineExecutableInternalRepresentationsKHR", &wine_vkGetPipelineExecutableInternalRepresentationsKHR},
-    {"vkGetPipelineExecutablePropertiesKHR", &wine_vkGetPipelineExecutablePropertiesKHR},
-    {"vkGetPipelineExecutableStatisticsKHR", &wine_vkGetPipelineExecutableStatisticsKHR},
-    {"vkGetPrivateDataEXT", &wine_vkGetPrivateDataEXT},
-    {"vkGetQueryPoolResults", &wine_vkGetQueryPoolResults},
-    {"vkGetQueueCheckpointData2NV", &wine_vkGetQueueCheckpointData2NV},
-    {"vkGetQueueCheckpointDataNV", &wine_vkGetQueueCheckpointDataNV},
-    {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", &wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR},
-    {"vkGetRayTracingShaderGroupHandlesKHR", &wine_vkGetRayTracingShaderGroupHandlesKHR},
-    {"vkGetRayTracingShaderGroupHandlesNV", &wine_vkGetRayTracingShaderGroupHandlesNV},
-    {"vkGetRayTracingShaderGroupStackSizeKHR", &wine_vkGetRayTracingShaderGroupStackSizeKHR},
-    {"vkGetRenderAreaGranularity", &wine_vkGetRenderAreaGranularity},
-    {"vkGetSemaphoreCounterValue", &wine_vkGetSemaphoreCounterValue},
-    {"vkGetSemaphoreCounterValueKHR", &wine_vkGetSemaphoreCounterValueKHR},
-    {"vkGetShaderInfoAMD", &wine_vkGetShaderInfoAMD},
-    {"vkGetSwapchainImagesKHR", &wine_vkGetSwapchainImagesKHR},
-    {"vkGetValidationCacheDataEXT", &wine_vkGetValidationCacheDataEXT},
-    {"vkInitializePerformanceApiINTEL", &wine_vkInitializePerformanceApiINTEL},
-    {"vkInvalidateMappedMemoryRanges", &wine_vkInvalidateMappedMemoryRanges},
-    {"vkMapMemory", &wine_vkMapMemory},
-    {"vkMergePipelineCaches", &wine_vkMergePipelineCaches},
-    {"vkMergeValidationCachesEXT", &wine_vkMergeValidationCachesEXT},
-    {"vkQueueBeginDebugUtilsLabelEXT", &wine_vkQueueBeginDebugUtilsLabelEXT},
-    {"vkQueueBindSparse", &wine_vkQueueBindSparse},
-    {"vkQueueEndDebugUtilsLabelEXT", &wine_vkQueueEndDebugUtilsLabelEXT},
-    {"vkQueueInsertDebugUtilsLabelEXT", &wine_vkQueueInsertDebugUtilsLabelEXT},
-    {"vkQueuePresentKHR", &wine_vkQueuePresentKHR},
-    {"vkQueueSetPerformanceConfigurationINTEL", &wine_vkQueueSetPerformanceConfigurationINTEL},
-    {"vkQueueSubmit", &wine_vkQueueSubmit},
-    {"vkQueueSubmit2KHR", &wine_vkQueueSubmit2KHR},
-    {"vkQueueWaitIdle", &wine_vkQueueWaitIdle},
-    {"vkReleasePerformanceConfigurationINTEL", &wine_vkReleasePerformanceConfigurationINTEL},
-    {"vkReleaseProfilingLockKHR", &wine_vkReleaseProfilingLockKHR},
-    {"vkResetCommandBuffer", &wine_vkResetCommandBuffer},
-    {"vkResetCommandPool", &wine_vkResetCommandPool},
-    {"vkResetDescriptorPool", &wine_vkResetDescriptorPool},
-    {"vkResetEvent", &wine_vkResetEvent},
-    {"vkResetFences", &wine_vkResetFences},
-    {"vkResetQueryPool", &wine_vkResetQueryPool},
-    {"vkResetQueryPoolEXT", &wine_vkResetQueryPoolEXT},
-    {"vkSetDebugUtilsObjectNameEXT", &wine_vkSetDebugUtilsObjectNameEXT},
-    {"vkSetDebugUtilsObjectTagEXT", &wine_vkSetDebugUtilsObjectTagEXT},
-    {"vkSetEvent", &wine_vkSetEvent},
-    {"vkSetPrivateDataEXT", &wine_vkSetPrivateDataEXT},
-    {"vkSignalSemaphore", &wine_vkSignalSemaphore},
-    {"vkSignalSemaphoreKHR", &wine_vkSignalSemaphoreKHR},
-    {"vkTrimCommandPool", &wine_vkTrimCommandPool},
-    {"vkTrimCommandPoolKHR", &wine_vkTrimCommandPoolKHR},
-    {"vkUninitializePerformanceApiINTEL", &wine_vkUninitializePerformanceApiINTEL},
-    {"vkUnmapMemory", &wine_vkUnmapMemory},
-    {"vkUpdateDescriptorSetWithTemplate", &wine_vkUpdateDescriptorSetWithTemplate},
-    {"vkUpdateDescriptorSetWithTemplateKHR", &wine_vkUpdateDescriptorSetWithTemplateKHR},
-    {"vkUpdateDescriptorSets", &wine_vkUpdateDescriptorSets},
-    {"vkWaitForFences", &wine_vkWaitForFences},
-    {"vkWaitSemaphores", &wine_vkWaitSemaphores},
-    {"vkWaitSemaphoresKHR", &wine_vkWaitSemaphoresKHR},
-    {"vkWriteAccelerationStructuresPropertiesKHR", &wine_vkWriteAccelerationStructuresPropertiesKHR},
+    {"vkAcquireNextImage2KHR", &vkAcquireNextImage2KHR},
+    {"vkAcquireNextImageKHR", &vkAcquireNextImageKHR},
+    {"vkAcquirePerformanceConfigurationINTEL", &vkAcquirePerformanceConfigurationINTEL},
+    {"vkAcquireProfilingLockKHR", &vkAcquireProfilingLockKHR},
+    {"vkAllocateCommandBuffers", &vkAllocateCommandBuffers},
+    {"vkAllocateDescriptorSets", &vkAllocateDescriptorSets},
+    {"vkAllocateMemory", &vkAllocateMemory},
+    {"vkBeginCommandBuffer", &vkBeginCommandBuffer},
+    {"vkBindAccelerationStructureMemoryNV", &vkBindAccelerationStructureMemoryNV},
+    {"vkBindBufferMemory", &vkBindBufferMemory},
+    {"vkBindBufferMemory2", &vkBindBufferMemory2},
+    {"vkBindBufferMemory2KHR", &vkBindBufferMemory2KHR},
+    {"vkBindImageMemory", &vkBindImageMemory},
+    {"vkBindImageMemory2", &vkBindImageMemory2},
+    {"vkBindImageMemory2KHR", &vkBindImageMemory2KHR},
+    {"vkBuildAccelerationStructuresKHR", &vkBuildAccelerationStructuresKHR},
+    {"vkCmdBeginConditionalRenderingEXT", &vkCmdBeginConditionalRenderingEXT},
+    {"vkCmdBeginDebugUtilsLabelEXT", &vkCmdBeginDebugUtilsLabelEXT},
+    {"vkCmdBeginQuery", &vkCmdBeginQuery},
+    {"vkCmdBeginQueryIndexedEXT", &vkCmdBeginQueryIndexedEXT},
+    {"vkCmdBeginRenderPass", &vkCmdBeginRenderPass},
+    {"vkCmdBeginRenderPass2", &vkCmdBeginRenderPass2},
+    {"vkCmdBeginRenderPass2KHR", &vkCmdBeginRenderPass2KHR},
+    {"vkCmdBeginTransformFeedbackEXT", &vkCmdBeginTransformFeedbackEXT},
+    {"vkCmdBindDescriptorSets", &vkCmdBindDescriptorSets},
+    {"vkCmdBindIndexBuffer", &vkCmdBindIndexBuffer},
+    {"vkCmdBindPipeline", &vkCmdBindPipeline},
+    {"vkCmdBindPipelineShaderGroupNV", &vkCmdBindPipelineShaderGroupNV},
+    {"vkCmdBindShadingRateImageNV", &vkCmdBindShadingRateImageNV},
+    {"vkCmdBindTransformFeedbackBuffersEXT", &vkCmdBindTransformFeedbackBuffersEXT},
+    {"vkCmdBindVertexBuffers", &vkCmdBindVertexBuffers},
+    {"vkCmdBindVertexBuffers2EXT", &vkCmdBindVertexBuffers2EXT},
+    {"vkCmdBlitImage", &vkCmdBlitImage},
+    {"vkCmdBlitImage2KHR", &vkCmdBlitImage2KHR},
+    {"vkCmdBuildAccelerationStructureNV", &vkCmdBuildAccelerationStructureNV},
+    {"vkCmdBuildAccelerationStructuresIndirectKHR", &vkCmdBuildAccelerationStructuresIndirectKHR},
+    {"vkCmdBuildAccelerationStructuresKHR", &vkCmdBuildAccelerationStructuresKHR},
+    {"vkCmdClearAttachments", &vkCmdClearAttachments},
+    {"vkCmdClearColorImage", &vkCmdClearColorImage},
+    {"vkCmdClearDepthStencilImage", &vkCmdClearDepthStencilImage},
+    {"vkCmdCopyAccelerationStructureKHR", &vkCmdCopyAccelerationStructureKHR},
+    {"vkCmdCopyAccelerationStructureNV", &vkCmdCopyAccelerationStructureNV},
+    {"vkCmdCopyAccelerationStructureToMemoryKHR", &vkCmdCopyAccelerationStructureToMemoryKHR},
+    {"vkCmdCopyBuffer", &vkCmdCopyBuffer},
+    {"vkCmdCopyBuffer2KHR", &vkCmdCopyBuffer2KHR},
+    {"vkCmdCopyBufferToImage", &vkCmdCopyBufferToImage},
+    {"vkCmdCopyBufferToImage2KHR", &vkCmdCopyBufferToImage2KHR},
+    {"vkCmdCopyImage", &vkCmdCopyImage},
+    {"vkCmdCopyImage2KHR", &vkCmdCopyImage2KHR},
+    {"vkCmdCopyImageToBuffer", &vkCmdCopyImageToBuffer},
+    {"vkCmdCopyImageToBuffer2KHR", &vkCmdCopyImageToBuffer2KHR},
+    {"vkCmdCopyMemoryToAccelerationStructureKHR", &vkCmdCopyMemoryToAccelerationStructureKHR},
+    {"vkCmdCopyQueryPoolResults", &vkCmdCopyQueryPoolResults},
+    {"vkCmdDebugMarkerBeginEXT", &vkCmdDebugMarkerBeginEXT},
+    {"vkCmdDebugMarkerEndEXT", &vkCmdDebugMarkerEndEXT},
+    {"vkCmdDebugMarkerInsertEXT", &vkCmdDebugMarkerInsertEXT},
+    {"vkCmdDispatch", &vkCmdDispatch},
+    {"vkCmdDispatchBase", &vkCmdDispatchBase},
+    {"vkCmdDispatchBaseKHR", &vkCmdDispatchBaseKHR},
+    {"vkCmdDispatchIndirect", &vkCmdDispatchIndirect},
+    {"vkCmdDraw", &vkCmdDraw},
+    {"vkCmdDrawIndexed", &vkCmdDrawIndexed},
+    {"vkCmdDrawIndexedIndirect", &vkCmdDrawIndexedIndirect},
+    {"vkCmdDrawIndexedIndirectCount", &vkCmdDrawIndexedIndirectCount},
+    {"vkCmdDrawIndexedIndirectCountAMD", &vkCmdDrawIndexedIndirectCountAMD},
+    {"vkCmdDrawIndexedIndirectCountKHR", &vkCmdDrawIndexedIndirectCountKHR},
+    {"vkCmdDrawIndirect", &vkCmdDrawIndirect},
+    {"vkCmdDrawIndirectByteCountEXT", &vkCmdDrawIndirectByteCountEXT},
+    {"vkCmdDrawIndirectCount", &vkCmdDrawIndirectCount},
+    {"vkCmdDrawIndirectCountAMD", &vkCmdDrawIndirectCountAMD},
+    {"vkCmdDrawIndirectCountKHR", &vkCmdDrawIndirectCountKHR},
+    {"vkCmdDrawMeshTasksIndirectCountNV", &vkCmdDrawMeshTasksIndirectCountNV},
+    {"vkCmdDrawMeshTasksIndirectNV", &vkCmdDrawMeshTasksIndirectNV},
+    {"vkCmdDrawMeshTasksNV", &vkCmdDrawMeshTasksNV},
+    {"vkCmdEndConditionalRenderingEXT", &vkCmdEndConditionalRenderingEXT},
+    {"vkCmdEndDebugUtilsLabelEXT", &vkCmdEndDebugUtilsLabelEXT},
+    {"vkCmdEndQuery", &vkCmdEndQuery},
+    {"vkCmdEndQueryIndexedEXT", &vkCmdEndQueryIndexedEXT},
+    {"vkCmdEndRenderPass", &vkCmdEndRenderPass},
+    {"vkCmdEndRenderPass2", &vkCmdEndRenderPass2},
+    {"vkCmdEndRenderPass2KHR", &vkCmdEndRenderPass2KHR},
+    {"vkCmdEndTransformFeedbackEXT", &vkCmdEndTransformFeedbackEXT},
+    {"vkCmdExecuteCommands", &vkCmdExecuteCommands},
+    {"vkCmdExecuteGeneratedCommandsNV", &vkCmdExecuteGeneratedCommandsNV},
+    {"vkCmdFillBuffer", &vkCmdFillBuffer},
+    {"vkCmdInsertDebugUtilsLabelEXT", &vkCmdInsertDebugUtilsLabelEXT},
+    {"vkCmdNextSubpass", &vkCmdNextSubpass},
+    {"vkCmdNextSubpass2", &vkCmdNextSubpass2},
+    {"vkCmdNextSubpass2KHR", &vkCmdNextSubpass2KHR},
+    {"vkCmdPipelineBarrier", &vkCmdPipelineBarrier},
+    {"vkCmdPipelineBarrier2KHR", &vkCmdPipelineBarrier2KHR},
+    {"vkCmdPreprocessGeneratedCommandsNV", &vkCmdPreprocessGeneratedCommandsNV},
+    {"vkCmdPushConstants", &vkCmdPushConstants},
+    {"vkCmdPushDescriptorSetKHR", &vkCmdPushDescriptorSetKHR},
+    {"vkCmdPushDescriptorSetWithTemplateKHR", &vkCmdPushDescriptorSetWithTemplateKHR},
+    {"vkCmdResetEvent", &vkCmdResetEvent},
+    {"vkCmdResetEvent2KHR", &vkCmdResetEvent2KHR},
+    {"vkCmdResetQueryPool", &vkCmdResetQueryPool},
+    {"vkCmdResolveImage", &vkCmdResolveImage},
+    {"vkCmdResolveImage2KHR", &vkCmdResolveImage2KHR},
+    {"vkCmdSetBlendConstants", &vkCmdSetBlendConstants},
+    {"vkCmdSetCheckpointNV", &vkCmdSetCheckpointNV},
+    {"vkCmdSetCoarseSampleOrderNV", &vkCmdSetCoarseSampleOrderNV},
+    {"vkCmdSetColorWriteEnableEXT", &vkCmdSetColorWriteEnableEXT},
+    {"vkCmdSetCullModeEXT", &vkCmdSetCullModeEXT},
+    {"vkCmdSetDepthBias", &vkCmdSetDepthBias},
+    {"vkCmdSetDepthBiasEnableEXT", &vkCmdSetDepthBiasEnableEXT},
+    {"vkCmdSetDepthBounds", &vkCmdSetDepthBounds},
+    {"vkCmdSetDepthBoundsTestEnableEXT", &vkCmdSetDepthBoundsTestEnableEXT},
+    {"vkCmdSetDepthCompareOpEXT", &vkCmdSetDepthCompareOpEXT},
+    {"vkCmdSetDepthTestEnableEXT", &vkCmdSetDepthTestEnableEXT},
+    {"vkCmdSetDepthWriteEnableEXT", &vkCmdSetDepthWriteEnableEXT},
+    {"vkCmdSetDeviceMask", &vkCmdSetDeviceMask},
+    {"vkCmdSetDeviceMaskKHR", &vkCmdSetDeviceMaskKHR},
+    {"vkCmdSetDiscardRectangleEXT", &vkCmdSetDiscardRectangleEXT},
+    {"vkCmdSetEvent", &vkCmdSetEvent},
+    {"vkCmdSetEvent2KHR", &vkCmdSetEvent2KHR},
+    {"vkCmdSetExclusiveScissorNV", &vkCmdSetExclusiveScissorNV},
+    {"vkCmdSetFragmentShadingRateEnumNV", &vkCmdSetFragmentShadingRateEnumNV},
+    {"vkCmdSetFragmentShadingRateKHR", &vkCmdSetFragmentShadingRateKHR},
+    {"vkCmdSetFrontFaceEXT", &vkCmdSetFrontFaceEXT},
+    {"vkCmdSetLineStippleEXT", &vkCmdSetLineStippleEXT},
+    {"vkCmdSetLineWidth", &vkCmdSetLineWidth},
+    {"vkCmdSetLogicOpEXT", &vkCmdSetLogicOpEXT},
+    {"vkCmdSetPatchControlPointsEXT", &vkCmdSetPatchControlPointsEXT},
+    {"vkCmdSetPerformanceMarkerINTEL", &vkCmdSetPerformanceMarkerINTEL},
+    {"vkCmdSetPerformanceOverrideINTEL", &vkCmdSetPerformanceOverrideINTEL},
+    {"vkCmdSetPerformanceStreamMarkerINTEL", &vkCmdSetPerformanceStreamMarkerINTEL},
+    {"vkCmdSetPrimitiveRestartEnableEXT", &vkCmdSetPrimitiveRestartEnableEXT},
+    {"vkCmdSetPrimitiveTopologyEXT", &vkCmdSetPrimitiveTopologyEXT},
+    {"vkCmdSetRasterizerDiscardEnableEXT", &vkCmdSetRasterizerDiscardEnableEXT},
+    {"vkCmdSetRayTracingPipelineStackSizeKHR", &vkCmdSetRayTracingPipelineStackSizeKHR},
+    {"vkCmdSetSampleLocationsEXT", &vkCmdSetSampleLocationsEXT},
+    {"vkCmdSetScissor", &vkCmdSetScissor},
+    {"vkCmdSetScissorWithCountEXT", &vkCmdSetScissorWithCountEXT},
+    {"vkCmdSetStencilCompareMask", &vkCmdSetStencilCompareMask},
+    {"vkCmdSetStencilOpEXT", &vkCmdSetStencilOpEXT},
+    {"vkCmdSetStencilReference", &vkCmdSetStencilReference},
+    {"vkCmdSetStencilTestEnableEXT", &vkCmdSetStencilTestEnableEXT},
+    {"vkCmdSetStencilWriteMask", &vkCmdSetStencilWriteMask},
+    {"vkCmdSetVertexInputEXT", &vkCmdSetVertexInputEXT},
+    {"vkCmdSetViewport", &vkCmdSetViewport},
+    {"vkCmdSetViewportShadingRatePaletteNV", &vkCmdSetViewportShadingRatePaletteNV},
+    {"vkCmdSetViewportWScalingNV", &vkCmdSetViewportWScalingNV},
+    {"vkCmdSetViewportWithCountEXT", &vkCmdSetViewportWithCountEXT},
+    {"vkCmdTraceRaysIndirectKHR", &vkCmdTraceRaysIndirectKHR},
+    {"vkCmdTraceRaysKHR", &vkCmdTraceRaysKHR},
+    {"vkCmdTraceRaysNV", &vkCmdTraceRaysNV},
+    {"vkCmdUpdateBuffer", &vkCmdUpdateBuffer},
+    {"vkCmdWaitEvents", &vkCmdWaitEvents},
+    {"vkCmdWaitEvents2KHR", &vkCmdWaitEvents2KHR},
+    {"vkCmdWriteAccelerationStructuresPropertiesKHR", &vkCmdWriteAccelerationStructuresPropertiesKHR},
+    {"vkCmdWriteAccelerationStructuresPropertiesNV", &vkCmdWriteAccelerationStructuresPropertiesNV},
+    {"vkCmdWriteBufferMarker2AMD", &vkCmdWriteBufferMarker2AMD},
+    {"vkCmdWriteBufferMarkerAMD", &vkCmdWriteBufferMarkerAMD},
+    {"vkCmdWriteTimestamp", &vkCmdWriteTimestamp},
+    {"vkCmdWriteTimestamp2KHR", &vkCmdWriteTimestamp2KHR},
+    {"vkCompileDeferredNV", &vkCompileDeferredNV},
+    {"vkCopyAccelerationStructureKHR", &vkCopyAccelerationStructureKHR},
+    {"vkCopyAccelerationStructureToMemoryKHR", &vkCopyAccelerationStructureToMemoryKHR},
+    {"vkCopyMemoryToAccelerationStructureKHR", &vkCopyMemoryToAccelerationStructureKHR},
+    {"vkCreateAccelerationStructureKHR", &vkCreateAccelerationStructureKHR},
+    {"vkCreateAccelerationStructureNV", &vkCreateAccelerationStructureNV},
+    {"vkCreateBuffer", &vkCreateBuffer},
+    {"vkCreateBufferView", &vkCreateBufferView},
+    {"vkCreateCommandPool", &vkCreateCommandPool},
+    {"vkCreateComputePipelines", &vkCreateComputePipelines},
+    {"vkCreateDeferredOperationKHR", &vkCreateDeferredOperationKHR},
+    {"vkCreateDescriptorPool", &vkCreateDescriptorPool},
+    {"vkCreateDescriptorSetLayout", &vkCreateDescriptorSetLayout},
+    {"vkCreateDescriptorUpdateTemplate", &vkCreateDescriptorUpdateTemplate},
+    {"vkCreateDescriptorUpdateTemplateKHR", &vkCreateDescriptorUpdateTemplateKHR},
+    {"vkCreateEvent", &vkCreateEvent},
+    {"vkCreateFence", &vkCreateFence},
+    {"vkCreateFramebuffer", &vkCreateFramebuffer},
+    {"vkCreateGraphicsPipelines", &vkCreateGraphicsPipelines},
+    {"vkCreateImage", &vkCreateImage},
+    {"vkCreateImageView", &vkCreateImageView},
+    {"vkCreateIndirectCommandsLayoutNV", &vkCreateIndirectCommandsLayoutNV},
+    {"vkCreatePipelineCache", &vkCreatePipelineCache},
+    {"vkCreatePipelineLayout", &vkCreatePipelineLayout},
+    {"vkCreatePrivateDataSlotEXT", &vkCreatePrivateDataSlotEXT},
+    {"vkCreateQueryPool", &vkCreateQueryPool},
+    {"vkCreateRayTracingPipelinesKHR", &vkCreateRayTracingPipelinesKHR},
+    {"vkCreateRayTracingPipelinesNV", &vkCreateRayTracingPipelinesNV},
+    {"vkCreateRenderPass", &vkCreateRenderPass},
+    {"vkCreateRenderPass2", &vkCreateRenderPass2},
+    {"vkCreateRenderPass2KHR", &vkCreateRenderPass2KHR},
+    {"vkCreateSampler", &vkCreateSampler},
+    {"vkCreateSamplerYcbcrConversion", &vkCreateSamplerYcbcrConversion},
+    {"vkCreateSamplerYcbcrConversionKHR", &vkCreateSamplerYcbcrConversionKHR},
+    {"vkCreateSemaphore", &vkCreateSemaphore},
+    {"vkCreateShaderModule", &vkCreateShaderModule},
+    {"vkCreateSwapchainKHR", &vkCreateSwapchainKHR},
+    {"vkCreateValidationCacheEXT", &vkCreateValidationCacheEXT},
+    {"vkDebugMarkerSetObjectNameEXT", &vkDebugMarkerSetObjectNameEXT},
+    {"vkDebugMarkerSetObjectTagEXT", &vkDebugMarkerSetObjectTagEXT},
+    {"vkDeferredOperationJoinKHR", &vkDeferredOperationJoinKHR},
+    {"vkDestroyAccelerationStructureKHR", &vkDestroyAccelerationStructureKHR},
+    {"vkDestroyAccelerationStructureNV", &vkDestroyAccelerationStructureNV},
+    {"vkDestroyBuffer", &vkDestroyBuffer},
+    {"vkDestroyBufferView", &vkDestroyBufferView},
+    {"vkDestroyCommandPool", &vkDestroyCommandPool},
+    {"vkDestroyDeferredOperationKHR", &vkDestroyDeferredOperationKHR},
+    {"vkDestroyDescriptorPool", &vkDestroyDescriptorPool},
+    {"vkDestroyDescriptorSetLayout", &vkDestroyDescriptorSetLayout},
+    {"vkDestroyDescriptorUpdateTemplate", &vkDestroyDescriptorUpdateTemplate},
+    {"vkDestroyDescriptorUpdateTemplateKHR", &vkDestroyDescriptorUpdateTemplateKHR},
+    {"vkDestroyDevice", &vkDestroyDevice},
+    {"vkDestroyEvent", &vkDestroyEvent},
+    {"vkDestroyFence", &vkDestroyFence},
+    {"vkDestroyFramebuffer", &vkDestroyFramebuffer},
+    {"vkDestroyImage", &vkDestroyImage},
+    {"vkDestroyImageView", &vkDestroyImageView},
+    {"vkDestroyIndirectCommandsLayoutNV", &vkDestroyIndirectCommandsLayoutNV},
+    {"vkDestroyPipeline", &vkDestroyPipeline},
+    {"vkDestroyPipelineCache", &vkDestroyPipelineCache},
+    {"vkDestroyPipelineLayout", &vkDestroyPipelineLayout},
+    {"vkDestroyPrivateDataSlotEXT", &vkDestroyPrivateDataSlotEXT},
+    {"vkDestroyQueryPool", &vkDestroyQueryPool},
+    {"vkDestroyRenderPass", &vkDestroyRenderPass},
+    {"vkDestroySampler", &vkDestroySampler},
+    {"vkDestroySamplerYcbcrConversion", &vkDestroySamplerYcbcrConversion},
+    {"vkDestroySamplerYcbcrConversionKHR", &vkDestroySamplerYcbcrConversionKHR},
+    {"vkDestroySemaphore", &vkDestroySemaphore},
+    {"vkDestroyShaderModule", &vkDestroyShaderModule},
+    {"vkDestroySwapchainKHR", &vkDestroySwapchainKHR},
+    {"vkDestroyValidationCacheEXT", &vkDestroyValidationCacheEXT},
+    {"vkDeviceWaitIdle", &vkDeviceWaitIdle},
+    {"vkEndCommandBuffer", &vkEndCommandBuffer},
+    {"vkFlushMappedMemoryRanges", &vkFlushMappedMemoryRanges},
+    {"vkFreeCommandBuffers", &vkFreeCommandBuffers},
+    {"vkFreeDescriptorSets", &vkFreeDescriptorSets},
+    {"vkFreeMemory", &vkFreeMemory},
+    {"vkGetAccelerationStructureBuildSizesKHR", &vkGetAccelerationStructureBuildSizesKHR},
+    {"vkGetAccelerationStructureDeviceAddressKHR", &vkGetAccelerationStructureDeviceAddressKHR},
+    {"vkGetAccelerationStructureHandleNV", &vkGetAccelerationStructureHandleNV},
+    {"vkGetAccelerationStructureMemoryRequirementsNV", &vkGetAccelerationStructureMemoryRequirementsNV},
+    {"vkGetBufferDeviceAddress", &vkGetBufferDeviceAddress},
+    {"vkGetBufferDeviceAddressEXT", &vkGetBufferDeviceAddressEXT},
+    {"vkGetBufferDeviceAddressKHR", &vkGetBufferDeviceAddressKHR},
+    {"vkGetBufferMemoryRequirements", &vkGetBufferMemoryRequirements},
+    {"vkGetBufferMemoryRequirements2", &vkGetBufferMemoryRequirements2},
+    {"vkGetBufferMemoryRequirements2KHR", &vkGetBufferMemoryRequirements2KHR},
+    {"vkGetBufferOpaqueCaptureAddress", &vkGetBufferOpaqueCaptureAddress},
+    {"vkGetBufferOpaqueCaptureAddressKHR", &vkGetBufferOpaqueCaptureAddressKHR},
+    {"vkGetCalibratedTimestampsEXT", &vkGetCalibratedTimestampsEXT},
+    {"vkGetDeferredOperationMaxConcurrencyKHR", &vkGetDeferredOperationMaxConcurrencyKHR},
+    {"vkGetDeferredOperationResultKHR", &vkGetDeferredOperationResultKHR},
+    {"vkGetDescriptorSetLayoutSupport", &vkGetDescriptorSetLayoutSupport},
+    {"vkGetDescriptorSetLayoutSupportKHR", &vkGetDescriptorSetLayoutSupportKHR},
+    {"vkGetDeviceAccelerationStructureCompatibilityKHR", &vkGetDeviceAccelerationStructureCompatibilityKHR},
+    {"vkGetDeviceGroupPeerMemoryFeatures", &vkGetDeviceGroupPeerMemoryFeatures},
+    {"vkGetDeviceGroupPeerMemoryFeaturesKHR", &vkGetDeviceGroupPeerMemoryFeaturesKHR},
+    {"vkGetDeviceGroupPresentCapabilitiesKHR", &vkGetDeviceGroupPresentCapabilitiesKHR},
+    {"vkGetDeviceGroupSurfacePresentModesKHR", &vkGetDeviceGroupSurfacePresentModesKHR},
+    {"vkGetDeviceMemoryCommitment", &vkGetDeviceMemoryCommitment},
+    {"vkGetDeviceMemoryOpaqueCaptureAddress", &vkGetDeviceMemoryOpaqueCaptureAddress},
+    {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", &vkGetDeviceMemoryOpaqueCaptureAddressKHR},
+    {"vkGetDeviceProcAddr", &vkGetDeviceProcAddr},
+    {"vkGetDeviceQueue", &vkGetDeviceQueue},
+    {"vkGetDeviceQueue2", &vkGetDeviceQueue2},
+    {"vkGetEventStatus", &vkGetEventStatus},
+    {"vkGetFenceStatus", &vkGetFenceStatus},
+    {"vkGetGeneratedCommandsMemoryRequirementsNV", &vkGetGeneratedCommandsMemoryRequirementsNV},
+    {"vkGetImageMemoryRequirements", &vkGetImageMemoryRequirements},
+    {"vkGetImageMemoryRequirements2", &vkGetImageMemoryRequirements2},
+    {"vkGetImageMemoryRequirements2KHR", &vkGetImageMemoryRequirements2KHR},
+    {"vkGetImageSparseMemoryRequirements", &vkGetImageSparseMemoryRequirements},
+    {"vkGetImageSparseMemoryRequirements2", &vkGetImageSparseMemoryRequirements2},
+    {"vkGetImageSparseMemoryRequirements2KHR", &vkGetImageSparseMemoryRequirements2KHR},
+    {"vkGetImageSubresourceLayout", &vkGetImageSubresourceLayout},
+    {"vkGetMemoryHostPointerPropertiesEXT", &vkGetMemoryHostPointerPropertiesEXT},
+    {"vkGetPerformanceParameterINTEL", &vkGetPerformanceParameterINTEL},
+    {"vkGetPipelineCacheData", &vkGetPipelineCacheData},
+    {"vkGetPipelineExecutableInternalRepresentationsKHR", &vkGetPipelineExecutableInternalRepresentationsKHR},
+    {"vkGetPipelineExecutablePropertiesKHR", &vkGetPipelineExecutablePropertiesKHR},
+    {"vkGetPipelineExecutableStatisticsKHR", &vkGetPipelineExecutableStatisticsKHR},
+    {"vkGetPrivateDataEXT", &vkGetPrivateDataEXT},
+    {"vkGetQueryPoolResults", &vkGetQueryPoolResults},
+    {"vkGetQueueCheckpointData2NV", &vkGetQueueCheckpointData2NV},
+    {"vkGetQueueCheckpointDataNV", &vkGetQueueCheckpointDataNV},
+    {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", &vkGetRayTracingCaptureReplayShaderGroupHandlesKHR},
+    {"vkGetRayTracingShaderGroupHandlesKHR", &vkGetRayTracingShaderGroupHandlesKHR},
+    {"vkGetRayTracingShaderGroupHandlesNV", &vkGetRayTracingShaderGroupHandlesNV},
+    {"vkGetRayTracingShaderGroupStackSizeKHR", &vkGetRayTracingShaderGroupStackSizeKHR},
+    {"vkGetRenderAreaGranularity", &vkGetRenderAreaGranularity},
+    {"vkGetSemaphoreCounterValue", &vkGetSemaphoreCounterValue},
+    {"vkGetSemaphoreCounterValueKHR", &vkGetSemaphoreCounterValueKHR},
+    {"vkGetShaderInfoAMD", &vkGetShaderInfoAMD},
+    {"vkGetSwapchainImagesKHR", &vkGetSwapchainImagesKHR},
+    {"vkGetValidationCacheDataEXT", &vkGetValidationCacheDataEXT},
+    {"vkInitializePerformanceApiINTEL", &vkInitializePerformanceApiINTEL},
+    {"vkInvalidateMappedMemoryRanges", &vkInvalidateMappedMemoryRanges},
+    {"vkMapMemory", &vkMapMemory},
+    {"vkMergePipelineCaches", &vkMergePipelineCaches},
+    {"vkMergeValidationCachesEXT", &vkMergeValidationCachesEXT},
+    {"vkQueueBeginDebugUtilsLabelEXT", &vkQueueBeginDebugUtilsLabelEXT},
+    {"vkQueueBindSparse", &vkQueueBindSparse},
+    {"vkQueueEndDebugUtilsLabelEXT", &vkQueueEndDebugUtilsLabelEXT},
+    {"vkQueueInsertDebugUtilsLabelEXT", &vkQueueInsertDebugUtilsLabelEXT},
+    {"vkQueuePresentKHR", &vkQueuePresentKHR},
+    {"vkQueueSetPerformanceConfigurationINTEL", &vkQueueSetPerformanceConfigurationINTEL},
+    {"vkQueueSubmit", &vkQueueSubmit},
+    {"vkQueueSubmit2KHR", &vkQueueSubmit2KHR},
+    {"vkQueueWaitIdle", &vkQueueWaitIdle},
+    {"vkReleasePerformanceConfigurationINTEL", &vkReleasePerformanceConfigurationINTEL},
+    {"vkReleaseProfilingLockKHR", &vkReleaseProfilingLockKHR},
+    {"vkResetCommandBuffer", &vkResetCommandBuffer},
+    {"vkResetCommandPool", &vkResetCommandPool},
+    {"vkResetDescriptorPool", &vkResetDescriptorPool},
+    {"vkResetEvent", &vkResetEvent},
+    {"vkResetFences", &vkResetFences},
+    {"vkResetQueryPool", &vkResetQueryPool},
+    {"vkResetQueryPoolEXT", &vkResetQueryPoolEXT},
+    {"vkSetDebugUtilsObjectNameEXT", &vkSetDebugUtilsObjectNameEXT},
+    {"vkSetDebugUtilsObjectTagEXT", &vkSetDebugUtilsObjectTagEXT},
+    {"vkSetEvent", &vkSetEvent},
+    {"vkSetPrivateDataEXT", &vkSetPrivateDataEXT},
+    {"vkSignalSemaphore", &vkSignalSemaphore},
+    {"vkSignalSemaphoreKHR", &vkSignalSemaphoreKHR},
+    {"vkTrimCommandPool", &vkTrimCommandPool},
+    {"vkTrimCommandPoolKHR", &vkTrimCommandPoolKHR},
+    {"vkUninitializePerformanceApiINTEL", &vkUninitializePerformanceApiINTEL},
+    {"vkUnmapMemory", &vkUnmapMemory},
+    {"vkUpdateDescriptorSetWithTemplate", &vkUpdateDescriptorSetWithTemplate},
+    {"vkUpdateDescriptorSetWithTemplateKHR", &vkUpdateDescriptorSetWithTemplateKHR},
+    {"vkUpdateDescriptorSets", &vkUpdateDescriptorSets},
+    {"vkWaitForFences", &vkWaitForFences},
+    {"vkWaitSemaphores", &vkWaitSemaphores},
+    {"vkWaitSemaphoresKHR", &vkWaitSemaphoresKHR},
+    {"vkWriteAccelerationStructuresPropertiesKHR", &vkWriteAccelerationStructuresPropertiesKHR},
 };
 
 static const struct vulkan_func vk_phys_dev_dispatch_table[] =
 {
-    {"vkCreateDevice", &wine_vkCreateDevice},
-    {"vkEnumerateDeviceExtensionProperties", &wine_vkEnumerateDeviceExtensionProperties},
-    {"vkEnumerateDeviceLayerProperties", &wine_vkEnumerateDeviceLayerProperties},
-    {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", &wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
-    {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", &wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
-    {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", &wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
-    {"vkGetPhysicalDeviceExternalBufferProperties", &wine_vkGetPhysicalDeviceExternalBufferProperties},
-    {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR},
-    {"vkGetPhysicalDeviceExternalFenceProperties", &wine_vkGetPhysicalDeviceExternalFenceProperties},
-    {"vkGetPhysicalDeviceExternalFencePropertiesKHR", &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR},
-    {"vkGetPhysicalDeviceExternalSemaphoreProperties", &wine_vkGetPhysicalDeviceExternalSemaphoreProperties},
-    {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", &wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
-    {"vkGetPhysicalDeviceFeatures", &wine_vkGetPhysicalDeviceFeatures},
-    {"vkGetPhysicalDeviceFeatures2", &wine_vkGetPhysicalDeviceFeatures2},
-    {"vkGetPhysicalDeviceFeatures2KHR", &wine_vkGetPhysicalDeviceFeatures2KHR},
-    {"vkGetPhysicalDeviceFormatProperties", &wine_vkGetPhysicalDeviceFormatProperties},
-    {"vkGetPhysicalDeviceFormatProperties2", &wine_vkGetPhysicalDeviceFormatProperties2},
-    {"vkGetPhysicalDeviceFormatProperties2KHR", &wine_vkGetPhysicalDeviceFormatProperties2KHR},
-    {"vkGetPhysicalDeviceFragmentShadingRatesKHR", &wine_vkGetPhysicalDeviceFragmentShadingRatesKHR},
-    {"vkGetPhysicalDeviceImageFormatProperties", &wine_vkGetPhysicalDeviceImageFormatProperties},
-    {"vkGetPhysicalDeviceImageFormatProperties2", &wine_vkGetPhysicalDeviceImageFormatProperties2},
-    {"vkGetPhysicalDeviceImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceImageFormatProperties2KHR},
-    {"vkGetPhysicalDeviceMemoryProperties", &wine_vkGetPhysicalDeviceMemoryProperties},
-    {"vkGetPhysicalDeviceMemoryProperties2", &wine_vkGetPhysicalDeviceMemoryProperties2},
-    {"vkGetPhysicalDeviceMemoryProperties2KHR", &wine_vkGetPhysicalDeviceMemoryProperties2KHR},
-    {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT},
-    {"vkGetPhysicalDevicePresentRectanglesKHR", &wine_vkGetPhysicalDevicePresentRectanglesKHR},
-    {"vkGetPhysicalDeviceProperties", &wine_vkGetPhysicalDeviceProperties},
-    {"vkGetPhysicalDeviceProperties2", &wine_vkGetPhysicalDeviceProperties2},
-    {"vkGetPhysicalDeviceProperties2KHR", &wine_vkGetPhysicalDeviceProperties2KHR},
-    {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", &wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
-    {"vkGetPhysicalDeviceQueueFamilyProperties", &wine_vkGetPhysicalDeviceQueueFamilyProperties},
-    {"vkGetPhysicalDeviceQueueFamilyProperties2", &wine_vkGetPhysicalDeviceQueueFamilyProperties2},
-    {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties", &wine_vkGetPhysicalDeviceSparseImageFormatProperties},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties2", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2},
-    {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
-    {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", &wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
-    {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", &wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR},
-    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
-    {"vkGetPhysicalDeviceSurfaceFormats2KHR", &wine_vkGetPhysicalDeviceSurfaceFormats2KHR},
-    {"vkGetPhysicalDeviceSurfaceFormatsKHR", &wine_vkGetPhysicalDeviceSurfaceFormatsKHR},
-    {"vkGetPhysicalDeviceSurfacePresentModesKHR", &wine_vkGetPhysicalDeviceSurfacePresentModesKHR},
-    {"vkGetPhysicalDeviceSurfaceSupportKHR", &wine_vkGetPhysicalDeviceSurfaceSupportKHR},
-    {"vkGetPhysicalDeviceToolPropertiesEXT", &wine_vkGetPhysicalDeviceToolPropertiesEXT},
-    {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR},
+    {"vkCreateDevice", &vkCreateDevice},
+    {"vkEnumerateDeviceExtensionProperties", &vkEnumerateDeviceExtensionProperties},
+    {"vkEnumerateDeviceLayerProperties", &vkEnumerateDeviceLayerProperties},
+    {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", &vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
+    {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", &vkGetPhysicalDeviceCalibrateableTimeDomainsEXT},
+    {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", &vkGetPhysicalDeviceCooperativeMatrixPropertiesNV},
+    {"vkGetPhysicalDeviceExternalBufferProperties", &vkGetPhysicalDeviceExternalBufferProperties},
+    {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", &vkGetPhysicalDeviceExternalBufferPropertiesKHR},
+    {"vkGetPhysicalDeviceExternalFenceProperties", &vkGetPhysicalDeviceExternalFenceProperties},
+    {"vkGetPhysicalDeviceExternalFencePropertiesKHR", &vkGetPhysicalDeviceExternalFencePropertiesKHR},
+    {"vkGetPhysicalDeviceExternalSemaphoreProperties", &vkGetPhysicalDeviceExternalSemaphoreProperties},
+    {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", &vkGetPhysicalDeviceExternalSemaphorePropertiesKHR},
+    {"vkGetPhysicalDeviceFeatures", &vkGetPhysicalDeviceFeatures},
+    {"vkGetPhysicalDeviceFeatures2", &vkGetPhysicalDeviceFeatures2},
+    {"vkGetPhysicalDeviceFeatures2KHR", &vkGetPhysicalDeviceFeatures2KHR},
+    {"vkGetPhysicalDeviceFormatProperties", &vkGetPhysicalDeviceFormatProperties},
+    {"vkGetPhysicalDeviceFormatProperties2", &vkGetPhysicalDeviceFormatProperties2},
+    {"vkGetPhysicalDeviceFormatProperties2KHR", &vkGetPhysicalDeviceFormatProperties2KHR},
+    {"vkGetPhysicalDeviceFragmentShadingRatesKHR", &vkGetPhysicalDeviceFragmentShadingRatesKHR},
+    {"vkGetPhysicalDeviceImageFormatProperties", &vkGetPhysicalDeviceImageFormatProperties},
+    {"vkGetPhysicalDeviceImageFormatProperties2", &vkGetPhysicalDeviceImageFormatProperties2},
+    {"vkGetPhysicalDeviceImageFormatProperties2KHR", &vkGetPhysicalDeviceImageFormatProperties2KHR},
+    {"vkGetPhysicalDeviceMemoryProperties", &vkGetPhysicalDeviceMemoryProperties},
+    {"vkGetPhysicalDeviceMemoryProperties2", &vkGetPhysicalDeviceMemoryProperties2},
+    {"vkGetPhysicalDeviceMemoryProperties2KHR", &vkGetPhysicalDeviceMemoryProperties2KHR},
+    {"vkGetPhysicalDeviceMultisamplePropertiesEXT", &vkGetPhysicalDeviceMultisamplePropertiesEXT},
+    {"vkGetPhysicalDevicePresentRectanglesKHR", &vkGetPhysicalDevicePresentRectanglesKHR},
+    {"vkGetPhysicalDeviceProperties", &vkGetPhysicalDeviceProperties},
+    {"vkGetPhysicalDeviceProperties2", &vkGetPhysicalDeviceProperties2},
+    {"vkGetPhysicalDeviceProperties2KHR", &vkGetPhysicalDeviceProperties2KHR},
+    {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", &vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
+    {"vkGetPhysicalDeviceQueueFamilyProperties", &vkGetPhysicalDeviceQueueFamilyProperties},
+    {"vkGetPhysicalDeviceQueueFamilyProperties2", &vkGetPhysicalDeviceQueueFamilyProperties2},
+    {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", &vkGetPhysicalDeviceQueueFamilyProperties2KHR},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties", &vkGetPhysicalDeviceSparseImageFormatProperties},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties2", &vkGetPhysicalDeviceSparseImageFormatProperties2},
+    {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", &vkGetPhysicalDeviceSparseImageFormatProperties2KHR},
+    {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", &vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
+    {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", &vkGetPhysicalDeviceSurfaceCapabilities2KHR},
+    {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", &vkGetPhysicalDeviceSurfaceCapabilitiesKHR},
+    {"vkGetPhysicalDeviceSurfaceFormats2KHR", &vkGetPhysicalDeviceSurfaceFormats2KHR},
+    {"vkGetPhysicalDeviceSurfaceFormatsKHR", &vkGetPhysicalDeviceSurfaceFormatsKHR},
+    {"vkGetPhysicalDeviceSurfacePresentModesKHR", &vkGetPhysicalDeviceSurfacePresentModesKHR},
+    {"vkGetPhysicalDeviceSurfaceSupportKHR", &vkGetPhysicalDeviceSurfaceSupportKHR},
+    {"vkGetPhysicalDeviceToolPropertiesEXT", &vkGetPhysicalDeviceToolPropertiesEXT},
+    {"vkGetPhysicalDeviceWin32PresentationSupportKHR", &vkGetPhysicalDeviceWin32PresentationSupportKHR},
 };
 
 static const struct vulkan_func vk_instance_dispatch_table[] =
 {
-    {"vkCreateDebugReportCallbackEXT", &wine_vkCreateDebugReportCallbackEXT},
-    {"vkCreateDebugUtilsMessengerEXT", &wine_vkCreateDebugUtilsMessengerEXT},
-    {"vkCreateWin32SurfaceKHR", &wine_vkCreateWin32SurfaceKHR},
-    {"vkDebugReportMessageEXT", &wine_vkDebugReportMessageEXT},
-    {"vkDestroyDebugReportCallbackEXT", &wine_vkDestroyDebugReportCallbackEXT},
-    {"vkDestroyDebugUtilsMessengerEXT", &wine_vkDestroyDebugUtilsMessengerEXT},
-    {"vkDestroyInstance", &wine_vkDestroyInstance},
-    {"vkDestroySurfaceKHR", &wine_vkDestroySurfaceKHR},
-    {"vkEnumeratePhysicalDeviceGroups", &wine_vkEnumeratePhysicalDeviceGroups},
-    {"vkEnumeratePhysicalDeviceGroupsKHR", &wine_vkEnumeratePhysicalDeviceGroupsKHR},
-    {"vkEnumeratePhysicalDevices", &wine_vkEnumeratePhysicalDevices},
-    {"vkSubmitDebugUtilsMessageEXT", &wine_vkSubmitDebugUtilsMessageEXT},
+    {"vkCreateDebugReportCallbackEXT", &vkCreateDebugReportCallbackEXT},
+    {"vkCreateDebugUtilsMessengerEXT", &vkCreateDebugUtilsMessengerEXT},
+    {"vkCreateWin32SurfaceKHR", &vkCreateWin32SurfaceKHR},
+    {"vkDebugReportMessageEXT", &vkDebugReportMessageEXT},
+    {"vkDestroyDebugReportCallbackEXT", &vkDestroyDebugReportCallbackEXT},
+    {"vkDestroyDebugUtilsMessengerEXT", &vkDestroyDebugUtilsMessengerEXT},
+    {"vkDestroyInstance", &vkDestroyInstance},
+    {"vkDestroySurfaceKHR", &vkDestroySurfaceKHR},
+    {"vkEnumeratePhysicalDeviceGroups", &vkEnumeratePhysicalDeviceGroups},
+    {"vkEnumeratePhysicalDeviceGroupsKHR", &vkEnumeratePhysicalDeviceGroupsKHR},
+    {"vkEnumeratePhysicalDevices", &vkEnumeratePhysicalDevices},
+    {"vkSubmitDebugUtilsMessageEXT", &vkSubmitDebugUtilsMessageEXT},
 };
 
 void *wine_vk_get_device_proc_addr(const char *name)
diff --git a/dlls/winevulkan/loader_thunks.h b/dlls/winevulkan/loader_thunks.h
index f60c1251730..e7257cef508 100644
--- a/dlls/winevulkan/loader_thunks.h
+++ b/dlls/winevulkan/loader_thunks.h
@@ -408,14 +408,4 @@ struct unix_funcs
     VkResult (WINAPI *p_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice, uint32_t, const VkAccelerationStructureKHR *, VkQueryType, size_t, void *, size_t);
 };
 
-/* Functions for which we have custom implementations outside of the thunks. */
-VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
-VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
-VkResult WINAPI wine_vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties);
-VkResult WINAPI wine_vkEnumerateInstanceVersion(uint32_t *pApiVersion);
-PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName);
-PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance instance, const char *pName);
-void WINAPI wine_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties);
-void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties);
-
 #endif /* __WINE_VULKAN_LOADER_THUNKS_H */
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 9bebda773e3..b1877acda17 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -3413,10 +3413,10 @@ def main():
         generator.generate_vulkan_driver_h(f)
 
     with open(WINE_VULKAN_THUNKS_H, "w") as f:
-        generator.generate_thunks_h(f, "unix_")
+        generator.generate_thunks_h(f, "wine_")
 
     with open(WINE_VULKAN_THUNKS_C, "w") as f:
-        generator.generate_thunks_c(f, "unix_")
+        generator.generate_thunks_c(f, "wine_")
 
     with open(WINE_VULKAN_LOADER_THUNKS_H, "w") as f:
         generator.generate_loader_thunks_h(f)
diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c
index d6f501b267a..45eda78e997 100644
--- a/dlls/winevulkan/vulkan.c
+++ b/dlls/winevulkan/vulkan.c
@@ -70,7 +70,7 @@ static uint32_t wine_vk_count_struct_(void *s, VkStructureType t)
 static const struct vulkan_funcs *vk_funcs;
 static VkResult (*p_vkEnumerateInstanceVersion)(uint32_t *version);
 
-void WINAPI unix_vkGetPhysicalDeviceProperties(VkPhysicalDevice physical_device,
+void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physical_device,
         VkPhysicalDeviceProperties *properties);
 
 #define WINE_VK_ADD_DISPATCHABLE_MAPPING(instance, object, native_handle) \
@@ -650,7 +650,7 @@ static void wine_vk_instance_free(struct VkInstance_T *instance)
     free(instance);
 }
 
-VkResult WINAPI unix_vkAllocateCommandBuffers(VkDevice device,
+VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device,
         const VkCommandBufferAllocateInfo *allocate_info, VkCommandBuffer *buffers)
 {
     struct wine_cmd_pool *pool;
@@ -709,7 +709,7 @@ VkResult WINAPI unix_vkAllocateCommandBuffers(VkDevice device,
     return res;
 }
 
-void WINAPI unix_vkCmdExecuteCommands(VkCommandBuffer buffer, uint32_t count,
+void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer buffer, uint32_t count,
         const VkCommandBuffer *buffers)
 {
     VkCommandBuffer *tmp_buffers;
@@ -739,7 +739,7 @@ void WINAPI unix_vkCmdExecuteCommands(VkCommandBuffer buffer, uint32_t count,
     free(tmp_buffers);
 }
 
-VkResult WINAPI unix_vkCreateDevice(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev,
         const VkDeviceCreateInfo *create_info,
         const VkAllocationCallbacks *allocator, VkDevice *device)
 {
@@ -758,7 +758,7 @@ VkResult WINAPI unix_vkCreateDevice(VkPhysicalDevice phys_dev,
     {
         VkPhysicalDeviceProperties properties;
 
-        unix_vkGetPhysicalDeviceProperties(phys_dev, &properties);
+        wine_vkGetPhysicalDeviceProperties(phys_dev, &properties);
 
         TRACE("Device name: %s.\n", debugstr_a(properties.deviceName));
         TRACE("Vendor ID: %#x, Device ID: %#x.\n", properties.vendorID, properties.deviceID);
@@ -834,7 +834,7 @@ fail:
     return res;
 }
 
-VkResult WINAPI unix_vkCreateInstance(const VkInstanceCreateInfo *create_info,
+VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *create_info,
         const VkAllocationCallbacks *allocator, VkInstance *instance)
 {
     VkInstanceCreateInfo create_info_host;
@@ -913,7 +913,7 @@ VkResult WINAPI unix_vkCreateInstance(const VkInstanceCreateInfo *create_info,
     return VK_SUCCESS;
 }
 
-void WINAPI unix_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator)
+void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator)
 {
     TRACE("%p %p\n", device, allocator);
 
@@ -923,7 +923,7 @@ void WINAPI unix_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *a
     wine_vk_device_free(device);
 }
 
-void WINAPI unix_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
+void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *allocator)
 {
     TRACE("%p, %p\n", instance, allocator);
 
@@ -933,7 +933,7 @@ void WINAPI unix_vkDestroyInstance(VkInstance instance, const VkAllocationCallba
     wine_vk_instance_free(instance);
 }
 
-VkResult WINAPI unix_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_dev,
         const char *layer_name, uint32_t *count, VkExtensionProperties *properties)
 {
     TRACE("%p, %p, %p, %p\n", phys_dev, layer_name, count, properties);
@@ -958,7 +958,7 @@ VkResult WINAPI unix_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_
     return *count < phys_dev->extension_count ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
-VkResult WINAPI unix_vkEnumerateInstanceExtensionProperties(const char *layer_name,
+VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *layer_name,
         uint32_t *count, VkExtensionProperties *properties)
 {
     uint32_t num_properties = 0, num_host_properties;
@@ -1015,7 +1015,7 @@ VkResult WINAPI unix_vkEnumerateInstanceExtensionProperties(const char *layer_na
     return *count < num_properties ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
-VkResult WINAPI unix_vkEnumerateDeviceLayerProperties(VkPhysicalDevice phys_dev, uint32_t *count, VkLayerProperties *properties)
+VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice phys_dev, uint32_t *count, VkLayerProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, count, properties);
 
@@ -1023,7 +1023,7 @@ VkResult WINAPI unix_vkEnumerateDeviceLayerProperties(VkPhysicalDevice phys_dev,
     return VK_SUCCESS;
 }
 
-VkResult WINAPI unix_vkEnumerateInstanceVersion(uint32_t *version)
+VkResult WINAPI wine_vkEnumerateInstanceVersion(uint32_t *version)
 {
     VkResult res;
 
@@ -1043,7 +1043,7 @@ VkResult WINAPI unix_vkEnumerateInstanceVersion(uint32_t *version)
     return res;
 }
 
-VkResult WINAPI unix_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *count,
+VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *count,
         VkPhysicalDevice *devices)
 {
     unsigned int i;
@@ -1066,7 +1066,7 @@ VkResult WINAPI unix_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *c
     return *count < instance->phys_dev_count ? VK_INCOMPLETE : VK_SUCCESS;
 }
 
-void WINAPI unix_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool_handle,
+void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool pool_handle,
         uint32_t count, const VkCommandBuffer *buffers)
 {
     struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(pool_handle);
@@ -1095,7 +1095,7 @@ static VkQueue wine_vk_device_find_queue(VkDevice device, const VkDeviceQueueInf
     return VK_NULL_HANDLE;
 }
 
-void WINAPI unix_vkGetDeviceQueue(VkDevice device, uint32_t family_index,
+void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t family_index,
         uint32_t queue_index, VkQueue *queue)
 {
     VkDeviceQueueInfo2 queue_info;
@@ -1110,7 +1110,7 @@ void WINAPI unix_vkGetDeviceQueue(VkDevice device, uint32_t family_index,
     *queue = wine_vk_device_find_queue(device, &queue_info);
 }
 
-void WINAPI unix_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *info, VkQueue *queue)
+void WINAPI wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *info, VkQueue *queue)
 {
     const VkBaseInStructure *chain;
 
@@ -1122,7 +1122,7 @@ void WINAPI unix_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *in
     *queue = wine_vk_device_find_queue(device, info);
 }
 
-VkResult WINAPI unix_vkQueueSubmit(VkQueue queue, uint32_t count,
+VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t count,
         const VkSubmitInfo *submits, VkFence fence)
 {
     VkSubmitInfo *submits_host;
@@ -1177,7 +1177,7 @@ done:
     return res;
 }
 
-VkResult WINAPI unix_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *info,
+VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *info,
         const VkAllocationCallbacks *allocator, VkCommandPool *command_pool)
 {
     struct wine_cmd_pool *object;
@@ -1208,7 +1208,7 @@ VkResult WINAPI unix_vkCreateCommandPool(VkDevice device, const VkCommandPoolCre
     return res;
 }
 
-void WINAPI unix_vkDestroyCommandPool(VkDevice device, VkCommandPool handle,
+void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool handle,
         const VkAllocationCallbacks *allocator)
 {
     struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(handle);
@@ -1263,7 +1263,7 @@ static VkResult wine_vk_enumerate_physical_device_groups(struct VkInstance_T *in
     return res;
 }
 
-VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroups(VkInstance instance,
+VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance,
         uint32_t *count, VkPhysicalDeviceGroupProperties *properties)
 {
     TRACE("%p, %p, %p\n", instance, count, properties);
@@ -1271,7 +1271,7 @@ VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroups(VkInstance instance,
             instance->funcs.p_vkEnumeratePhysicalDeviceGroups, count, properties);
 }
 
-VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
+VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
         uint32_t *count, VkPhysicalDeviceGroupProperties *properties)
 {
     TRACE("%p, %p, %p\n", instance, count, properties);
@@ -1279,7 +1279,7 @@ VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance,
             instance->funcs.p_vkEnumeratePhysicalDeviceGroupsKHR, count, properties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalFenceInfo *fence_info, VkExternalFenceProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, fence_info, properties);
@@ -1288,7 +1288,7 @@ void WINAPI unix_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phy
     properties->externalFenceFeatures = 0;
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalFenceInfo *fence_info, VkExternalFenceProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, fence_info, properties);
@@ -1297,21 +1297,21 @@ void WINAPI unix_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice
     properties->externalFenceFeatures = 0;
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalBufferInfo *buffer_info, VkExternalBufferProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
     memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalBufferInfo *buffer_info, VkExternalBufferProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
     memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceImageFormatInfo2 *format_info, VkImageFormatProperties2 *properties)
 {
     VkExternalImageFormatProperties *external_image_properties;
@@ -1332,7 +1332,7 @@ VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice
     return res;
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceImageFormatInfo2 *format_info, VkImageFormatProperties2 *properties)
 {
     VkExternalImageFormatProperties *external_image_properties;
@@ -1399,7 +1399,7 @@ static inline uint64_t convert_timestamp(VkTimeDomainEXT host_domain, VkTimeDoma
     return value;
 }
 
-VkResult WINAPI unix_vkGetCalibratedTimestampsEXT(VkDevice device,
+VkResult WINAPI wine_vkGetCalibratedTimestampsEXT(VkDevice device,
     uint32_t timestamp_count, const VkCalibratedTimestampInfoEXT *timestamp_infos,
     uint64_t *timestamps, uint64_t *max_deviation)
 {
@@ -1430,7 +1430,7 @@ VkResult WINAPI unix_vkGetCalibratedTimestampsEXT(VkDevice device,
     return res;
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice phys_dev,
     uint32_t *time_domain_count, VkTimeDomainEXT *time_domains)
 {
     BOOL supports_device = FALSE, supports_monotonic = FALSE, supports_monotonic_raw = FALSE;
@@ -1502,7 +1502,7 @@ VkResult WINAPI unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDe
     return res;
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalSemaphoreInfo *semaphore_info, VkExternalSemaphoreProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, semaphore_info, properties);
@@ -1511,7 +1511,7 @@ void WINAPI unix_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice
     properties->externalSemaphoreFeatures = 0;
 }
 
-void WINAPI unix_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice phys_dev,
+void WINAPI wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceExternalSemaphoreInfo *semaphore_info, VkExternalSemaphoreProperties *properties)
 {
     TRACE("%p, %p, %p\n", phys_dev, semaphore_info, properties);
@@ -1520,7 +1520,7 @@ void WINAPI unix_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDev
     properties->externalSemaphoreFeatures = 0;
 }
 
-VkResult WINAPI unix_vkSetPrivateDataEXT(VkDevice device, VkObjectType object_type, uint64_t object_handle,
+VkResult WINAPI wine_vkSetPrivateDataEXT(VkDevice device, VkObjectType object_type, uint64_t object_handle,
         VkPrivateDataSlotEXT private_data_slot, uint64_t data)
 {
     TRACE("%p, %#x, 0x%s, 0x%s, 0x%s\n", device, object_type, wine_dbgstr_longlong(object_handle),
@@ -1530,7 +1530,7 @@ VkResult WINAPI unix_vkSetPrivateDataEXT(VkDevice device, VkObjectType object_ty
     return device->funcs.p_vkSetPrivateDataEXT(device->device, object_type, object_handle, private_data_slot, data);
 }
 
-void WINAPI unix_vkGetPrivateDataEXT(VkDevice device, VkObjectType object_type, uint64_t object_handle,
+void WINAPI wine_vkGetPrivateDataEXT(VkDevice device, VkObjectType object_type, uint64_t object_handle,
         VkPrivateDataSlotEXT private_data_slot, uint64_t *data)
 {
     TRACE("%p, %#x, 0x%s, 0x%s, %p\n", device, object_type, wine_dbgstr_longlong(object_handle),
@@ -1540,7 +1540,7 @@ void WINAPI unix_vkGetPrivateDataEXT(VkDevice device, VkObjectType object_type,
     device->funcs.p_vkGetPrivateDataEXT(device->device, object_type, object_handle, private_data_slot, data);
 }
 
-VkResult WINAPI unix_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *create_info,
+VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *create_info,
         const VkAllocationCallbacks *allocator, VkSwapchainKHR *swapchain)
 {
     VkSwapchainCreateInfoKHR native_info;
@@ -1553,7 +1553,7 @@ VkResult WINAPI unix_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCrea
     return thunk_vkCreateSwapchainKHR(device, &native_info, allocator, swapchain);
 }
 
-VkResult WINAPI unix_vkCreateWin32SurfaceKHR(VkInstance instance,
+VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance,
         const VkWin32SurfaceCreateInfoKHR *createInfo, const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
 {
     struct wine_surface *object;
@@ -1586,7 +1586,7 @@ VkResult WINAPI unix_vkCreateWin32SurfaceKHR(VkInstance instance,
     return VK_SUCCESS;
 }
 
-void WINAPI unix_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *allocator)
+void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *allocator)
 {
     struct wine_surface *object = wine_surface_from_handle(surface);
 
@@ -1601,7 +1601,7 @@ void WINAPI unix_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
     free(object);
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceSurfaceInfo2KHR *surface_info, uint32_t *formats_count, VkSurfaceFormat2KHR *formats)
 {
     VkPhysicalDeviceSurfaceInfo2KHR native_info;
@@ -1629,7 +1629,7 @@ static inline void adjust_max_image_count(VkPhysicalDevice phys_dev, VkSurfaceCa
     }
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice phys_dev,
         VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *capabilities)
 {
     VkResult res;
@@ -1644,7 +1644,7 @@ VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice
     return res;
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice phys_dev,
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice phys_dev,
         const VkPhysicalDeviceSurfaceInfo2KHR *surface_info, VkSurfaceCapabilities2KHR *capabilities)
 {
     VkPhysicalDeviceSurfaceInfo2KHR native_info;
@@ -1663,7 +1663,7 @@ VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice
     return res;
 }
 
-VkResult WINAPI unix_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *create_info,
+VkResult WINAPI wine_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *create_info,
         const VkAllocationCallbacks *allocator, VkDebugUtilsMessengerEXT *messenger)
 {
     VkDebugUtilsMessengerCreateInfoEXT wine_create_info;
@@ -1701,7 +1701,7 @@ VkResult WINAPI unix_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const V
     return VK_SUCCESS;
 }
 
-void WINAPI unix_vkDestroyDebugUtilsMessengerEXT(
+void WINAPI wine_vkDestroyDebugUtilsMessengerEXT(
         VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *allocator)
 {
     struct wine_debug_utils_messenger *object;
@@ -1719,7 +1719,7 @@ void WINAPI unix_vkDestroyDebugUtilsMessengerEXT(
     free(object);
 }
 
-void WINAPI unix_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT severity,
+void WINAPI wine_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT severity,
         VkDebugUtilsMessageTypeFlagsEXT types, const VkDebugUtilsMessengerCallbackDataEXT *callback_data)
 {
     VkDebugUtilsMessengerCallbackDataEXT native_callback_data;
@@ -1744,7 +1744,7 @@ void WINAPI unix_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsM
     free(object_names);
 }
 
-VkResult WINAPI unix_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *tag_info)
+VkResult WINAPI wine_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *tag_info)
 {
     VkDebugUtilsObjectTagInfoEXT wine_tag_info;
 
@@ -1756,7 +1756,7 @@ VkResult WINAPI unix_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugU
     return thunk_vkSetDebugUtilsObjectTagEXT(device, &wine_tag_info);
 }
 
-VkResult WINAPI unix_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *name_info)
+VkResult WINAPI wine_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *name_info)
 {
     VkDebugUtilsObjectNameInfoEXT wine_name_info;
 
@@ -1768,7 +1768,7 @@ VkResult WINAPI unix_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebug
     return thunk_vkSetDebugUtilsObjectNameEXT(device, &wine_name_info);
 }
 
-VkResult WINAPI unix_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *create_info,
+VkResult WINAPI wine_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *create_info,
     const VkAllocationCallbacks *allocator, VkDebugReportCallbackEXT *callback)
 {
     VkDebugReportCallbackCreateInfoEXT wine_create_info;
@@ -1806,7 +1806,7 @@ VkResult WINAPI unix_vkCreateDebugReportCallbackEXT(VkInstance instance, const V
     return VK_SUCCESS;
 }
 
-void WINAPI unix_vkDestroyDebugReportCallbackEXT(
+void WINAPI wine_vkDestroyDebugReportCallbackEXT(
     VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *allocator)
 {
     struct wine_debug_report_callback *object;
@@ -1825,7 +1825,7 @@ void WINAPI unix_vkDestroyDebugReportCallbackEXT(
     free(object);
 }
 
-void WINAPI unix_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT object_type,
+void WINAPI wine_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT object_type,
     uint64_t object, size_t location, int32_t code, const char *layer_prefix, const char *message)
 {
     TRACE("%p, %#x, %#x, 0x%s, 0x%s, %d, %p, %p\n", instance, flags, object_type, wine_dbgstr_longlong(object),
@@ -1837,7 +1837,7 @@ void WINAPI unix_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlags
         instance->instance, flags, object_type, object, location, code, layer_prefix, message);
 }
 
-VkResult WINAPI unix_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *tag_info)
+VkResult WINAPI wine_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *tag_info)
 {
     VkDebugMarkerObjectTagInfoEXT wine_tag_info;
 
@@ -1849,7 +1849,7 @@ VkResult WINAPI unix_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebug
     return thunk_vkDebugMarkerSetObjectTagEXT(device, &wine_tag_info);
 }
 
-VkResult WINAPI unix_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *name_info)
+VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *name_info)
 {
     VkDebugMarkerObjectNameInfoEXT wine_name_info;
 
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 9ad3deb1ae7..e5435e27325 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -3837,7 +3837,7 @@ void free_VkInstanceCreateInfo_struct_chain(VkInstanceCreateInfo *s)
     s->pNext = NULL;
 }
 
-VkResult WINAPI unix_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
+VkResult WINAPI wine_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3854,19 +3854,19 @@ VkResult WINAPI unix_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNext
 #endif
 }
 
-VkResult WINAPI unix_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
+VkResult WINAPI wine_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), wine_dbgstr_longlong(timeout), wine_dbgstr_longlong(semaphore), wine_dbgstr_longlong(fence), pImageIndex);
     return device->funcs.p_vkAcquireNextImageKHR(device->device, swapchain, timeout, semaphore, fence, pImageIndex);
 }
 
-static VkResult WINAPI unix_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
+static VkResult WINAPI wine_vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
 {
     TRACE("%p, %p, %p\n", device, pAcquireInfo, pConfiguration);
     return device->funcs.p_vkAcquirePerformanceConfigurationINTEL(device->device, pAcquireInfo, pConfiguration);
 }
 
-static VkResult WINAPI unix_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
+static VkResult WINAPI wine_vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3883,7 +3883,7 @@ static VkResult WINAPI unix_vkAcquireProfilingLockKHR(VkDevice device, const VkA
 #endif
 }
 
-VkResult WINAPI unix_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI wine_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3900,7 +3900,7 @@ VkResult WINAPI unix_vkAllocateDescriptorSets(VkDevice device, const VkDescripto
 #endif
 }
 
-VkResult WINAPI unix_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
+VkResult WINAPI wine_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3917,7 +3917,7 @@ VkResult WINAPI unix_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInf
 #endif
 }
 
-VkResult WINAPI unix_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
+VkResult WINAPI wine_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3935,7 +3935,7 @@ VkResult WINAPI unix_vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const V
 #endif
 }
 
-static VkResult WINAPI unix_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
+static VkResult WINAPI wine_vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3953,13 +3953,13 @@ static VkResult WINAPI unix_vkBindAccelerationStructureMemoryNV(VkDevice device,
 #endif
 }
 
-VkResult WINAPI unix_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI wine_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
     return device->funcs.p_vkBindBufferMemory(device->device, buffer, memory, memoryOffset);
 }
 
-VkResult WINAPI unix_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
+VkResult WINAPI wine_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3977,7 +3977,7 @@ VkResult WINAPI unix_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount
 #endif
 }
 
-static VkResult WINAPI unix_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
+static VkResult WINAPI wine_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -3995,13 +3995,13 @@ static VkResult WINAPI unix_vkBindBufferMemory2KHR(VkDevice device, uint32_t bin
 #endif
 }
 
-VkResult WINAPI unix_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
+VkResult WINAPI wine_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s\n", device, wine_dbgstr_longlong(image), wine_dbgstr_longlong(memory), wine_dbgstr_longlong(memoryOffset));
     return device->funcs.p_vkBindImageMemory(device->device, image, memory, memoryOffset);
 }
 
-VkResult WINAPI unix_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
+VkResult WINAPI wine_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -4019,7 +4019,7 @@ VkResult WINAPI unix_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
 #endif
 }
 
-static VkResult WINAPI unix_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
+static VkResult WINAPI wine_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -4037,7 +4037,7 @@ static VkResult WINAPI unix_vkBindImageMemory2KHR(VkDevice device, uint32_t bind
 #endif
 }
 
-static VkResult WINAPI unix_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
+static VkResult WINAPI wine_vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -4055,7 +4055,7 @@ static VkResult WINAPI unix_vkBuildAccelerationStructuresKHR(VkDevice device, Vk
 #endif
 }
 
-static void WINAPI unix_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
+static void WINAPI wine_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkConditionalRenderingBeginInfoEXT_host pConditionalRenderingBegin_host;
@@ -4070,25 +4070,25 @@ static void WINAPI unix_vkCmdBeginConditionalRenderingEXT(VkCommandBuffer comman
 #endif
 }
 
-static void WINAPI unix_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
+static void WINAPI wine_vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
     commandBuffer->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
 }
 
-void WINAPI unix_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
+void WINAPI wine_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 {
     TRACE("%p, 0x%s, %u, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags);
     commandBuffer->device->funcs.p_vkCmdBeginQuery(commandBuffer->command_buffer, queryPool, query, flags);
 }
 
-static void WINAPI unix_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
+static void WINAPI wine_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
 {
     TRACE("%p, 0x%s, %u, %#x, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, flags, index);
     commandBuffer->device->funcs.p_vkCmdBeginQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, flags, index);
 }
 
-void WINAPI unix_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
+void WINAPI wine_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkRenderPassBeginInfo_host pRenderPassBegin_host;
@@ -4103,7 +4103,7 @@ void WINAPI unix_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRen
 #endif
 }
 
-void WINAPI unix_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
+void WINAPI wine_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkRenderPassBeginInfo_host pRenderPassBegin_host;
@@ -4118,7 +4118,7 @@ void WINAPI unix_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRe
 #endif
 }
 
-static void WINAPI unix_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
+static void WINAPI wine_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkRenderPassBeginInfo_host pRenderPassBegin_host;
@@ -4133,67 +4133,67 @@ static void WINAPI unix_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
 #endif
 }
 
-static void WINAPI unix_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
+static void WINAPI wine_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
     commandBuffer->device->funcs.p_vkCmdBeginTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 }
 
-void WINAPI unix_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
+void WINAPI wine_vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t *pDynamicOffsets)
 {
     TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(layout), firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
     commandBuffer->device->funcs.p_vkCmdBindDescriptorSets(commandBuffer->command_buffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-void WINAPI unix_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+void WINAPI wine_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), indexType);
     commandBuffer->device->funcs.p_vkCmdBindIndexBuffer(commandBuffer->command_buffer, buffer, offset, indexType);
 }
 
-void WINAPI unix_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+void WINAPI wine_vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     TRACE("%p, %#x, 0x%s\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline));
     commandBuffer->device->funcs.p_vkCmdBindPipeline(commandBuffer->command_buffer, pipelineBindPoint, pipeline);
 }
 
-static void WINAPI unix_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
+static void WINAPI wine_vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
 {
     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineBindPoint, wine_dbgstr_longlong(pipeline), groupIndex);
     commandBuffer->device->funcs.p_vkCmdBindPipelineShaderGroupNV(commandBuffer->command_buffer, pipelineBindPoint, pipeline, groupIndex);
 }
 
-static void WINAPI unix_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
+static void WINAPI wine_vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 {
     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(imageView), imageLayout);
     commandBuffer->device->funcs.p_vkCmdBindShadingRateImageNV(commandBuffer->command_buffer, imageView, imageLayout);
 }
 
-static void WINAPI unix_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
+static void WINAPI wine_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
 {
     TRACE("%p, %u, %u, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
     commandBuffer->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
 }
 
-void WINAPI unix_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
+void WINAPI wine_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 {
     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets);
 }
 
-static void WINAPI unix_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
+static void WINAPI wine_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 {
     TRACE("%p, %u, %u, %p, %p, %p, %p\n", commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
     commandBuffer->device->funcs.p_vkCmdBindVertexBuffers2EXT(commandBuffer->command_buffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
 }
 
-void WINAPI unix_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
+void WINAPI wine_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 {
     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions, filter);
     commandBuffer->device->funcs.p_vkCmdBlitImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
 }
 
-static void WINAPI unix_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
+static void WINAPI wine_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR *pBlitImageInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBlitImageInfo2KHR_host pBlitImageInfo_host;
@@ -4208,7 +4208,7 @@ static void WINAPI unix_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const
 #endif
 }
 
-static void WINAPI unix_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
+static void WINAPI wine_vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkAccelerationStructureInfoNV_host pInfo_host;
@@ -4224,7 +4224,7 @@ static void WINAPI unix_vkCmdBuildAccelerationStructureNV(VkCommandBuffer comman
 #endif
 }
 
-static void WINAPI unix_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
+static void WINAPI wine_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
@@ -4240,7 +4240,7 @@ static void WINAPI unix_vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuf
 #endif
 }
 
-static void WINAPI unix_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
+static void WINAPI wine_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkAccelerationStructureBuildGeometryInfoKHR_host *pInfos_host;
@@ -4256,25 +4256,25 @@ static void WINAPI unix_vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer comm
 #endif
 }
 
-void WINAPI unix_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
+void WINAPI wine_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 {
     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
     commandBuffer->device->funcs.p_vkCmdClearAttachments(commandBuffer->command_buffer, attachmentCount, pAttachments, rectCount, pRects);
 }
 
-void WINAPI unix_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI wine_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pColor, rangeCount, pRanges);
     commandBuffer->device->funcs.p_vkCmdClearColorImage(commandBuffer->command_buffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
-void WINAPI unix_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
+void WINAPI wine_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     TRACE("%p, 0x%s, %#x, %p, %u, %p\n", commandBuffer, wine_dbgstr_longlong(image), imageLayout, pDepthStencil, rangeCount, pRanges);
     commandBuffer->device->funcs.p_vkCmdClearDepthStencilImage(commandBuffer->command_buffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
 }
 
-static void WINAPI unix_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
+static void WINAPI wine_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyAccelerationStructureInfoKHR_host pInfo_host;
@@ -4289,13 +4289,13 @@ static void WINAPI unix_vkCmdCopyAccelerationStructureKHR(VkCommandBuffer comman
 #endif
 }
 
-static void WINAPI unix_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
+static void WINAPI wine_vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
 {
     TRACE("%p, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(dst), wine_dbgstr_longlong(src), mode);
     commandBuffer->device->funcs.p_vkCmdCopyAccelerationStructureNV(commandBuffer->command_buffer, dst, src, mode);
 }
 
-static void WINAPI unix_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
+static void WINAPI wine_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyAccelerationStructureToMemoryInfoKHR_host pInfo_host;
@@ -4310,7 +4310,7 @@ static void WINAPI unix_vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffe
 #endif
 }
 
-void WINAPI unix_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
+void WINAPI wine_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferCopy_host *pRegions_host;
@@ -4326,7 +4326,7 @@ void WINAPI unix_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuff
 #endif
 }
 
-static void WINAPI unix_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
+static void WINAPI wine_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR *pCopyBufferInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyBufferInfo2KHR_host pCopyBufferInfo_host;
@@ -4342,7 +4342,7 @@ static void WINAPI unix_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const
 #endif
 }
 
-void WINAPI unix_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferImageCopy_host *pRegions_host;
@@ -4358,7 +4358,7 @@ void WINAPI unix_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer
 #endif
 }
 
-static void WINAPI unix_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
+static void WINAPI wine_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyBufferToImageInfo2KHR_host pCopyBufferToImageInfo_host;
@@ -4374,13 +4374,13 @@ static void WINAPI unix_vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer
 #endif
 }
 
-void WINAPI unix_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 {
     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
     commandBuffer->device->funcs.p_vkCmdCopyImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-static void WINAPI unix_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
+static void WINAPI wine_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR *pCopyImageInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyImageInfo2KHR_host pCopyImageInfo_host;
@@ -4395,7 +4395,7 @@ static void WINAPI unix_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const
 #endif
 }
 
-void WINAPI unix_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
+void WINAPI wine_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferImageCopy_host *pRegions_host;
@@ -4411,7 +4411,7 @@ void WINAPI unix_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage s
 #endif
 }
 
-static void WINAPI unix_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
+static void WINAPI wine_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyImageToBufferInfo2KHR_host pCopyImageToBufferInfo_host;
@@ -4427,7 +4427,7 @@ static void WINAPI unix_vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer
 #endif
 }
 
-static void WINAPI unix_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
+static void WINAPI wine_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkCopyMemoryToAccelerationStructureInfoKHR_host pInfo_host;
@@ -4442,187 +4442,187 @@ static void WINAPI unix_vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffe
 #endif
 }
 
-void WINAPI unix_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
+void WINAPI wine_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(stride), flags);
     commandBuffer->device->funcs.p_vkCmdCopyQueryPoolResults(commandBuffer->command_buffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
 }
 
-static void WINAPI unix_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
+static void WINAPI wine_vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
     commandBuffer->device->funcs.p_vkCmdDebugMarkerBeginEXT(commandBuffer->command_buffer, pMarkerInfo);
 }
 
-static void WINAPI unix_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
+static void WINAPI wine_vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     commandBuffer->device->funcs.p_vkCmdDebugMarkerEndEXT(commandBuffer->command_buffer);
 }
 
-static void WINAPI unix_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
+static void WINAPI wine_vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
     commandBuffer->device->funcs.p_vkCmdDebugMarkerInsertEXT(commandBuffer->command_buffer, pMarkerInfo);
 }
 
-void WINAPI unix_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI wine_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     TRACE("%p, %u, %u, %u\n", commandBuffer, groupCountX, groupCountY, groupCountZ);
     commandBuffer->device->funcs.p_vkCmdDispatch(commandBuffer->command_buffer, groupCountX, groupCountY, groupCountZ);
 }
 
-void WINAPI unix_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+void WINAPI wine_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
     commandBuffer->device->funcs.p_vkCmdDispatchBase(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 }
 
-static void WINAPI unix_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
+static void WINAPI wine_vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     TRACE("%p, %u, %u, %u, %u, %u, %u\n", commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
     commandBuffer->device->funcs.p_vkCmdDispatchBaseKHR(commandBuffer->command_buffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
 }
 
-void WINAPI unix_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
+void WINAPI wine_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset));
     commandBuffer->device->funcs.p_vkCmdDispatchIndirect(commandBuffer->command_buffer, buffer, offset);
 }
 
-void WINAPI unix_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
+void WINAPI wine_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     TRACE("%p, %u, %u, %u, %u\n", commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
     commandBuffer->device->funcs.p_vkCmdDraw(commandBuffer->command_buffer, vertexCount, instanceCount, firstVertex, firstInstance);
 }
 
-void WINAPI unix_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
+void WINAPI wine_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
     TRACE("%p, %u, %u, %u, %d, %u\n", commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
     commandBuffer->device->funcs.p_vkCmdDrawIndexed(commandBuffer->command_buffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-void WINAPI unix_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
 }
 
-void WINAPI unix_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-void WINAPI unix_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirect(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
+static void WINAPI wine_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
 {
     TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", commandBuffer, instanceCount, firstInstance, wine_dbgstr_longlong(counterBuffer), wine_dbgstr_longlong(counterBufferOffset), counterOffset, vertexStride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirectByteCountEXT(commandBuffer->command_buffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
 }
 
-void WINAPI unix_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+void WINAPI wine_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirectCount(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountAMD(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawIndirectCountKHR(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(countBuffer), wine_dbgstr_longlong(countBufferOffset), maxDrawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer->command_buffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
+static void WINAPI wine_vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(buffer), wine_dbgstr_longlong(offset), drawCount, stride);
     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(commandBuffer->command_buffer, buffer, offset, drawCount, stride);
 }
 
-static void WINAPI unix_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
+static void WINAPI wine_vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
 {
     TRACE("%p, %u, %u\n", commandBuffer, taskCount, firstTask);
     commandBuffer->device->funcs.p_vkCmdDrawMeshTasksNV(commandBuffer->command_buffer, taskCount, firstTask);
 }
 
-static void WINAPI unix_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
+static void WINAPI wine_vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     commandBuffer->device->funcs.p_vkCmdEndConditionalRenderingEXT(commandBuffer->command_buffer);
 }
 
-static void WINAPI unix_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
+static void WINAPI wine_vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     commandBuffer->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(commandBuffer->command_buffer);
 }
 
-void WINAPI unix_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
+void WINAPI wine_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 {
     TRACE("%p, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query);
     commandBuffer->device->funcs.p_vkCmdEndQuery(commandBuffer->command_buffer, queryPool, query);
 }
 
-static void WINAPI unix_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
+static void WINAPI wine_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
 {
     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), query, index);
     commandBuffer->device->funcs.p_vkCmdEndQueryIndexedEXT(commandBuffer->command_buffer, queryPool, query, index);
 }
 
-void WINAPI unix_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
+void WINAPI wine_vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     commandBuffer->device->funcs.p_vkCmdEndRenderPass(commandBuffer->command_buffer);
 }
 
-void WINAPI unix_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI wine_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
     commandBuffer->device->funcs.p_vkCmdEndRenderPass2(commandBuffer->command_buffer, pSubpassEndInfo);
 }
 
-static void WINAPI unix_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
+static void WINAPI wine_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pSubpassEndInfo);
     commandBuffer->device->funcs.p_vkCmdEndRenderPass2KHR(commandBuffer->command_buffer, pSubpassEndInfo);
 }
 
-static void WINAPI unix_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
+static void WINAPI wine_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     TRACE("%p, %u, %u, %p, %p\n", commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
     commandBuffer->device->funcs.p_vkCmdEndTransformFeedbackEXT(commandBuffer->command_buffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
 }
 
-static void WINAPI unix_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
+static void WINAPI wine_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
@@ -4638,37 +4638,37 @@ static void WINAPI unix_vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandB
 #endif
 }
 
-void WINAPI unix_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
+void WINAPI wine_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(size), data);
     commandBuffer->device->funcs.p_vkCmdFillBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, size, data);
 }
 
-static void WINAPI unix_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
+static void WINAPI wine_vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pLabelInfo);
     commandBuffer->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(commandBuffer->command_buffer, pLabelInfo);
 }
 
-void WINAPI unix_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
+void WINAPI wine_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     TRACE("%p, %#x\n", commandBuffer, contents);
     commandBuffer->device->funcs.p_vkCmdNextSubpass(commandBuffer->command_buffer, contents);
 }
 
-void WINAPI unix_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
+void WINAPI wine_vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
     commandBuffer->device->funcs.p_vkCmdNextSubpass2(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
 }
 
-static void WINAPI unix_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
+static void WINAPI wine_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     TRACE("%p, %p, %p\n", commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
     commandBuffer->device->funcs.p_vkCmdNextSubpass2KHR(commandBuffer->command_buffer, pSubpassBeginInfo, pSubpassEndInfo);
 }
 
-void WINAPI unix_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+void WINAPI wine_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
@@ -4687,7 +4687,7 @@ void WINAPI unix_vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineS
 #endif
 }
 
-static void WINAPI unix_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
+static void WINAPI wine_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR *pDependencyInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDependencyInfoKHR_host pDependencyInfo_host;
@@ -4703,7 +4703,7 @@ static void WINAPI unix_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
 #endif
 }
 
-static void WINAPI unix_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
+static void WINAPI wine_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkGeneratedCommandsInfoNV_host pGeneratedCommandsInfo_host;
@@ -4719,13 +4719,13 @@ static void WINAPI unix_vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer comma
 #endif
 }
 
-void WINAPI unix_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
+void WINAPI wine_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 {
     TRACE("%p, 0x%s, %#x, %u, %u, %p\n", commandBuffer, wine_dbgstr_longlong(layout), stageFlags, offset, size, pValues);
     commandBuffer->device->funcs.p_vkCmdPushConstants(commandBuffer->command_buffer, layout, stageFlags, offset, size, pValues);
 }
 
-static void WINAPI unix_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
+static void WINAPI wine_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkWriteDescriptorSet_host *pDescriptorWrites_host;
@@ -4741,37 +4741,37 @@ static void WINAPI unix_vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer,
 #endif
 }
 
-static void WINAPI unix_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
+static void WINAPI wine_vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, %u, %p\n", commandBuffer, wine_dbgstr_longlong(descriptorUpdateTemplate), wine_dbgstr_longlong(layout), set, pData);
     commandBuffer->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer->command_buffer, descriptorUpdateTemplate, layout, set, pData);
 }
 
-void WINAPI unix_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI wine_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
     commandBuffer->device->funcs.p_vkCmdResetEvent(commandBuffer->command_buffer, event, stageMask);
 }
 
-static void WINAPI unix_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
+static void WINAPI wine_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask)
 {
     TRACE("%p, 0x%s, 0x%s\n", commandBuffer, wine_dbgstr_longlong(event), wine_dbgstr_longlong(stageMask));
     commandBuffer->device->funcs.p_vkCmdResetEvent2KHR(commandBuffer->command_buffer, event, stageMask);
 }
 
-void WINAPI unix_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI wine_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     TRACE("%p, 0x%s, %u, %u\n", commandBuffer, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
     commandBuffer->device->funcs.p_vkCmdResetQueryPool(commandBuffer->command_buffer, queryPool, firstQuery, queryCount);
 }
 
-void WINAPI unix_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
+void WINAPI wine_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 {
     TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", commandBuffer, wine_dbgstr_longlong(srcImage), srcImageLayout, wine_dbgstr_longlong(dstImage), dstImageLayout, regionCount, pRegions);
     commandBuffer->device->funcs.p_vkCmdResolveImage(commandBuffer->command_buffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
 }
 
-static void WINAPI unix_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
+static void WINAPI wine_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR *pResolveImageInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResolveImageInfo2KHR_host pResolveImageInfo_host;
@@ -4786,103 +4786,103 @@ static void WINAPI unix_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, con
 #endif
 }
 
-void WINAPI unix_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
+void WINAPI wine_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     TRACE("%p, %p\n", commandBuffer, blendConstants);
     commandBuffer->device->funcs.p_vkCmdSetBlendConstants(commandBuffer->command_buffer, blendConstants);
 }
 
-static void WINAPI unix_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
+static void WINAPI wine_vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
 {
     TRACE("%p, %p\n", commandBuffer, pCheckpointMarker);
     commandBuffer->device->funcs.p_vkCmdSetCheckpointNV(commandBuffer->command_buffer, pCheckpointMarker);
 }
 
-static void WINAPI unix_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
+static void WINAPI wine_vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
 {
     TRACE("%p, %#x, %u, %p\n", commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
     commandBuffer->device->funcs.p_vkCmdSetCoarseSampleOrderNV(commandBuffer->command_buffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
 }
 
-static void WINAPI unix_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
+static void WINAPI wine_vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
 {
     TRACE("%p, %u, %p\n", commandBuffer, attachmentCount, pColorWriteEnables);
     commandBuffer->device->funcs.p_vkCmdSetColorWriteEnableEXT(commandBuffer->command_buffer, attachmentCount, pColorWriteEnables);
 }
 
-static void WINAPI unix_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
+static void WINAPI wine_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 {
     TRACE("%p, %#x\n", commandBuffer, cullMode);
     commandBuffer->device->funcs.p_vkCmdSetCullModeEXT(commandBuffer->command_buffer, cullMode);
 }
 
-void WINAPI unix_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
+void WINAPI wine_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
     TRACE("%p, %f, %f, %f\n", commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
     commandBuffer->device->funcs.p_vkCmdSetDepthBias(commandBuffer->command_buffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
 }
 
-static void WINAPI unix_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
+static void WINAPI wine_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
 {
     TRACE("%p, %u\n", commandBuffer, depthBiasEnable);
     commandBuffer->device->funcs.p_vkCmdSetDepthBiasEnableEXT(commandBuffer->command_buffer, depthBiasEnable);
 }
 
-void WINAPI unix_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
+void WINAPI wine_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
     TRACE("%p, %f, %f\n", commandBuffer, minDepthBounds, maxDepthBounds);
     commandBuffer->device->funcs.p_vkCmdSetDepthBounds(commandBuffer->command_buffer, minDepthBounds, maxDepthBounds);
 }
 
-static void WINAPI unix_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
+static void WINAPI wine_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
 {
     TRACE("%p, %u\n", commandBuffer, depthBoundsTestEnable);
     commandBuffer->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer->command_buffer, depthBoundsTestEnable);
 }
 
-static void WINAPI unix_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
+static void WINAPI wine_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 {
     TRACE("%p, %#x\n", commandBuffer, depthCompareOp);
     commandBuffer->device->funcs.p_vkCmdSetDepthCompareOpEXT(commandBuffer->command_buffer, depthCompareOp);
 }
 
-static void WINAPI unix_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
+static void WINAPI wine_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
 {
     TRACE("%p, %u\n", commandBuffer, depthTestEnable);
     commandBuffer->device->funcs.p_vkCmdSetDepthTestEnableEXT(commandBuffer->command_buffer, depthTestEnable);
 }
 
-static void WINAPI unix_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
+static void WINAPI wine_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
 {
     TRACE("%p, %u\n", commandBuffer, depthWriteEnable);
     commandBuffer->device->funcs.p_vkCmdSetDepthWriteEnableEXT(commandBuffer->command_buffer, depthWriteEnable);
 }
 
-void WINAPI unix_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+void WINAPI wine_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     TRACE("%p, %u\n", commandBuffer, deviceMask);
     commandBuffer->device->funcs.p_vkCmdSetDeviceMask(commandBuffer->command_buffer, deviceMask);
 }
 
-static void WINAPI unix_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
+static void WINAPI wine_vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     TRACE("%p, %u\n", commandBuffer, deviceMask);
     commandBuffer->device->funcs.p_vkCmdSetDeviceMaskKHR(commandBuffer->command_buffer, deviceMask);
 }
 
-static void WINAPI unix_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
+static void WINAPI wine_vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
     commandBuffer->device->funcs.p_vkCmdSetDiscardRectangleEXT(commandBuffer->command_buffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
 }
 
-void WINAPI unix_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
+void WINAPI wine_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     TRACE("%p, 0x%s, %#x\n", commandBuffer, wine_dbgstr_longlong(event), stageMask);
     commandBuffer->device->funcs.p_vkCmdSetEvent(commandBuffer->command_buffer, event, stageMask);
 }
 
-static void WINAPI unix_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
+static void WINAPI wine_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR *pDependencyInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDependencyInfoKHR_host pDependencyInfo_host;
@@ -4898,55 +4898,55 @@ static void WINAPI unix_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent
 #endif
 }
 
-static void WINAPI unix_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
+static void WINAPI wine_vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
     commandBuffer->device->funcs.p_vkCmdSetExclusiveScissorNV(commandBuffer->command_buffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
 }
 
-static void WINAPI unix_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
+static void WINAPI wine_vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     TRACE("%p, %#x, %p\n", commandBuffer, shadingRate, combinerOps);
     commandBuffer->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(commandBuffer->command_buffer, shadingRate, combinerOps);
 }
 
-static void WINAPI unix_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
+static void WINAPI wine_vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     TRACE("%p, %p, %p\n", commandBuffer, pFragmentSize, combinerOps);
     commandBuffer->device->funcs.p_vkCmdSetFragmentShadingRateKHR(commandBuffer->command_buffer, pFragmentSize, combinerOps);
 }
 
-static void WINAPI unix_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
+static void WINAPI wine_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
 {
     TRACE("%p, %#x\n", commandBuffer, frontFace);
     commandBuffer->device->funcs.p_vkCmdSetFrontFaceEXT(commandBuffer->command_buffer, frontFace);
 }
 
-static void WINAPI unix_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
+static void WINAPI wine_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 {
     TRACE("%p, %u, %u\n", commandBuffer, lineStippleFactor, lineStipplePattern);
     commandBuffer->device->funcs.p_vkCmdSetLineStippleEXT(commandBuffer->command_buffer, lineStippleFactor, lineStipplePattern);
 }
 
-void WINAPI unix_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
+void WINAPI wine_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     TRACE("%p, %f\n", commandBuffer, lineWidth);
     commandBuffer->device->funcs.p_vkCmdSetLineWidth(commandBuffer->command_buffer, lineWidth);
 }
 
-static void WINAPI unix_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
+static void WINAPI wine_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
 {
     TRACE("%p, %#x\n", commandBuffer, logicOp);
     commandBuffer->device->funcs.p_vkCmdSetLogicOpEXT(commandBuffer->command_buffer, logicOp);
 }
 
-static void WINAPI unix_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
+static void WINAPI wine_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
 {
     TRACE("%p, %u\n", commandBuffer, patchControlPoints);
     commandBuffer->device->funcs.p_vkCmdSetPatchControlPointsEXT(commandBuffer->command_buffer, patchControlPoints);
 }
 
-static VkResult WINAPI unix_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
+static VkResult WINAPI wine_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -4963,7 +4963,7 @@ static VkResult WINAPI unix_vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer comma
 #endif
 }
 
-static VkResult WINAPI unix_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
+static VkResult WINAPI wine_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -4980,115 +4980,115 @@ static VkResult WINAPI unix_vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer com
 #endif
 }
 
-static VkResult WINAPI unix_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
+static VkResult WINAPI wine_vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pMarkerInfo);
     return commandBuffer->device->funcs.p_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer->command_buffer, pMarkerInfo);
 }
 
-static void WINAPI unix_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
+static void WINAPI wine_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
 {
     TRACE("%p, %u\n", commandBuffer, primitiveRestartEnable);
     commandBuffer->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(commandBuffer->command_buffer, primitiveRestartEnable);
 }
 
-static void WINAPI unix_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
+static void WINAPI wine_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
 {
     TRACE("%p, %#x\n", commandBuffer, primitiveTopology);
     commandBuffer->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(commandBuffer->command_buffer, primitiveTopology);
 }
 
-static void WINAPI unix_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
+static void WINAPI wine_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
 {
     TRACE("%p, %u\n", commandBuffer, rasterizerDiscardEnable);
     commandBuffer->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(commandBuffer->command_buffer, rasterizerDiscardEnable);
 }
 
-static void WINAPI unix_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
+static void WINAPI wine_vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
 {
     TRACE("%p, %u\n", commandBuffer, pipelineStackSize);
     commandBuffer->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer->command_buffer, pipelineStackSize);
 }
 
-static void WINAPI unix_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
+static void WINAPI wine_vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
 {
     TRACE("%p, %p\n", commandBuffer, pSampleLocationsInfo);
     commandBuffer->device->funcs.p_vkCmdSetSampleLocationsEXT(commandBuffer->command_buffer, pSampleLocationsInfo);
 }
 
-void WINAPI unix_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
+void WINAPI wine_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstScissor, scissorCount, pScissors);
     commandBuffer->device->funcs.p_vkCmdSetScissor(commandBuffer->command_buffer, firstScissor, scissorCount, pScissors);
 }
 
-static void WINAPI unix_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
+static void WINAPI wine_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     TRACE("%p, %u, %p\n", commandBuffer, scissorCount, pScissors);
     commandBuffer->device->funcs.p_vkCmdSetScissorWithCountEXT(commandBuffer->command_buffer, scissorCount, pScissors);
 }
 
-void WINAPI unix_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
+void WINAPI wine_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, compareMask);
     commandBuffer->device->funcs.p_vkCmdSetStencilCompareMask(commandBuffer->command_buffer, faceMask, compareMask);
 }
 
-static void WINAPI unix_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
+static void WINAPI wine_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
 {
     TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
     commandBuffer->device->funcs.p_vkCmdSetStencilOpEXT(commandBuffer->command_buffer, faceMask, failOp, passOp, depthFailOp, compareOp);
 }
 
-void WINAPI unix_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
+void WINAPI wine_vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, reference);
     commandBuffer->device->funcs.p_vkCmdSetStencilReference(commandBuffer->command_buffer, faceMask, reference);
 }
 
-static void WINAPI unix_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
+static void WINAPI wine_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
 {
     TRACE("%p, %u\n", commandBuffer, stencilTestEnable);
     commandBuffer->device->funcs.p_vkCmdSetStencilTestEnableEXT(commandBuffer->command_buffer, stencilTestEnable);
 }
 
-void WINAPI unix_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
+void WINAPI wine_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
     TRACE("%p, %#x, %u\n", commandBuffer, faceMask, writeMask);
     commandBuffer->device->funcs.p_vkCmdSetStencilWriteMask(commandBuffer->command_buffer, faceMask, writeMask);
 }
 
-static void WINAPI unix_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
+static void WINAPI wine_vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
 {
     TRACE("%p, %u, %p, %u, %p\n", commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
     commandBuffer->device->funcs.p_vkCmdSetVertexInputEXT(commandBuffer->command_buffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
 }
 
-void WINAPI unix_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
+void WINAPI wine_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewports);
     commandBuffer->device->funcs.p_vkCmdSetViewport(commandBuffer->command_buffer, firstViewport, viewportCount, pViewports);
 }
 
-static void WINAPI unix_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
+static void WINAPI wine_vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
     commandBuffer->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(commandBuffer->command_buffer, firstViewport, viewportCount, pShadingRatePalettes);
 }
 
-static void WINAPI unix_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
+static void WINAPI wine_vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
 {
     TRACE("%p, %u, %u, %p\n", commandBuffer, firstViewport, viewportCount, pViewportWScalings);
     commandBuffer->device->funcs.p_vkCmdSetViewportWScalingNV(commandBuffer->command_buffer, firstViewport, viewportCount, pViewportWScalings);
 }
 
-static void WINAPI unix_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
+static void WINAPI wine_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
 {
     TRACE("%p, %u, %p\n", commandBuffer, viewportCount, pViewports);
     commandBuffer->device->funcs.p_vkCmdSetViewportWithCountEXT(commandBuffer->command_buffer, viewportCount, pViewports);
 }
 
-static void WINAPI unix_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
+static void WINAPI wine_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkStridedDeviceAddressRegionKHR_host pRaygenShaderBindingTable_host;
@@ -5109,7 +5109,7 @@ static void WINAPI unix_vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer,
 #endif
 }
 
-static void WINAPI unix_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
+static void WINAPI wine_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkStridedDeviceAddressRegionKHR_host pRaygenShaderBindingTable_host;
@@ -5130,19 +5130,19 @@ static void WINAPI unix_vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const V
 #endif
 }
 
-static void WINAPI unix_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
+static void WINAPI wine_vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
 {
     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", commandBuffer, wine_dbgstr_longlong(raygenShaderBindingTableBuffer), wine_dbgstr_longlong(raygenShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingTableBuffer), wine_dbgstr_longlong(missShaderBindingOffset), wine_dbgstr_longlong(missShaderBindingStride), wine_dbgstr_longlong(hitShaderBindingTableBuffer), wine_dbgstr_longlong(hitShaderBindingOffset), wine_dbgstr_longlong(hitShaderBindingStride), wine_dbgstr_longlong(callableShaderBindingTableBuffer), wine_dbgstr_longlong(callableShaderBindingOffset), wine_dbgstr_longlong(callableShaderBindingStride), width, height, depth);
     commandBuffer->device->funcs.p_vkCmdTraceRaysNV(commandBuffer->command_buffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
 }
 
-void WINAPI unix_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
+void WINAPI wine_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", commandBuffer, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), wine_dbgstr_longlong(dataSize), pData);
     commandBuffer->device->funcs.p_vkCmdUpdateBuffer(commandBuffer->command_buffer, dstBuffer, dstOffset, dataSize, pData);
 }
 
-void WINAPI unix_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
+void WINAPI wine_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryBarrier_host *pBufferMemoryBarriers_host;
@@ -5161,7 +5161,7 @@ void WINAPI unix_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCo
 #endif
 }
 
-static void WINAPI unix_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
+static void WINAPI wine_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfoKHR *pDependencyInfos)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDependencyInfoKHR_host *pDependencyInfos_host;
@@ -5177,49 +5177,49 @@ static void WINAPI unix_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint3
 #endif
 }
 
-static void WINAPI unix_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
+static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 }
 
-static void WINAPI unix_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
+static void WINAPI wine_vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     TRACE("%p, %u, %p, %#x, 0x%s, %u\n", commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(queryPool), firstQuery);
     commandBuffer->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer->command_buffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
 }
 
-static void WINAPI unix_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
+static void WINAPI wine_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(stage), wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
     commandBuffer->device->funcs.p_vkCmdWriteBufferMarker2AMD(commandBuffer->command_buffer, stage, dstBuffer, dstOffset, marker);
 }
 
-static void WINAPI unix_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
+static void WINAPI wine_vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     TRACE("%p, %#x, 0x%s, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(dstBuffer), wine_dbgstr_longlong(dstOffset), marker);
     commandBuffer->device->funcs.p_vkCmdWriteBufferMarkerAMD(commandBuffer->command_buffer, pipelineStage, dstBuffer, dstOffset, marker);
 }
 
-void WINAPI unix_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
+void WINAPI wine_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 {
     TRACE("%p, %#x, 0x%s, %u\n", commandBuffer, pipelineStage, wine_dbgstr_longlong(queryPool), query);
     commandBuffer->device->funcs.p_vkCmdWriteTimestamp(commandBuffer->command_buffer, pipelineStage, queryPool, query);
 }
 
-static void WINAPI unix_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
+static void WINAPI wine_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query)
 {
     TRACE("%p, 0x%s, 0x%s, %u\n", commandBuffer, wine_dbgstr_longlong(stage), wine_dbgstr_longlong(queryPool), query);
     commandBuffer->device->funcs.p_vkCmdWriteTimestamp2KHR(commandBuffer->command_buffer, stage, queryPool, query);
 }
 
-static VkResult WINAPI unix_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
+static VkResult WINAPI wine_vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
 {
     TRACE("%p, 0x%s, %u\n", device, wine_dbgstr_longlong(pipeline), shader);
     return device->funcs.p_vkCompileDeferredNV(device->device, pipeline, shader);
 }
 
-static VkResult WINAPI unix_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
+static VkResult WINAPI wine_vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5236,7 +5236,7 @@ static VkResult WINAPI unix_vkCopyAccelerationStructureKHR(VkDevice device, VkDe
 #endif
 }
 
-static VkResult WINAPI unix_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
+static VkResult WINAPI wine_vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5253,7 +5253,7 @@ static VkResult WINAPI unix_vkCopyAccelerationStructureToMemoryKHR(VkDevice devi
 #endif
 }
 
-static VkResult WINAPI unix_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
+static VkResult WINAPI wine_vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5270,7 +5270,7 @@ static VkResult WINAPI unix_vkCopyMemoryToAccelerationStructureKHR(VkDevice devi
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
+static VkResult WINAPI wine_vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5287,7 +5287,7 @@ static VkResult WINAPI unix_vkCreateAccelerationStructureKHR(VkDevice device, co
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
+static VkResult WINAPI wine_vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5304,7 +5304,7 @@ static VkResult WINAPI unix_vkCreateAccelerationStructureNV(VkDevice device, con
 #endif
 }
 
-VkResult WINAPI unix_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
+VkResult WINAPI wine_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5321,7 +5321,7 @@ VkResult WINAPI unix_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *p
 #endif
 }
 
-VkResult WINAPI unix_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
+VkResult WINAPI wine_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5338,7 +5338,7 @@ VkResult WINAPI unix_vkCreateBufferView(VkDevice device, const VkBufferViewCreat
 #endif
 }
 
-VkResult WINAPI unix_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5356,25 +5356,25 @@ VkResult WINAPI unix_vkCreateComputePipelines(VkDevice device, VkPipelineCache p
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
+static VkResult WINAPI wine_vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
 {
     TRACE("%p, %p, %p\n", device, pAllocator, pDeferredOperation);
     return device->funcs.p_vkCreateDeferredOperationKHR(device->device, NULL, pDeferredOperation);
 }
 
-VkResult WINAPI unix_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
+VkResult WINAPI wine_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pDescriptorPool);
     return device->funcs.p_vkCreateDescriptorPool(device->device, pCreateInfo, NULL, pDescriptorPool);
 }
 
-VkResult WINAPI unix_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
+VkResult WINAPI wine_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSetLayout);
     return device->funcs.p_vkCreateDescriptorSetLayout(device->device, pCreateInfo, NULL, pSetLayout);
 }
 
-VkResult WINAPI unix_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
+VkResult WINAPI wine_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5391,7 +5391,7 @@ VkResult WINAPI unix_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkD
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
+static VkResult WINAPI wine_vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5408,19 +5408,19 @@ static VkResult WINAPI unix_vkCreateDescriptorUpdateTemplateKHR(VkDevice device,
 #endif
 }
 
-VkResult WINAPI unix_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
+VkResult WINAPI wine_vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pEvent);
     return device->funcs.p_vkCreateEvent(device->device, pCreateInfo, NULL, pEvent);
 }
 
-VkResult WINAPI unix_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
+VkResult WINAPI wine_vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pFence);
     return device->funcs.p_vkCreateFence(device->device, pCreateInfo, NULL, pFence);
 }
 
-VkResult WINAPI unix_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
+VkResult WINAPI wine_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5437,7 +5437,7 @@ VkResult WINAPI unix_vkCreateFramebuffer(VkDevice device, const VkFramebufferCre
 #endif
 }
 
-VkResult WINAPI unix_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+VkResult WINAPI wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5455,13 +5455,13 @@ VkResult WINAPI unix_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache
 #endif
 }
 
-VkResult WINAPI unix_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
+VkResult WINAPI wine_vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pImage);
     return device->funcs.p_vkCreateImage(device->device, pCreateInfo, NULL, pImage);
 }
 
-VkResult WINAPI unix_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
+VkResult WINAPI wine_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5478,7 +5478,7 @@ VkResult WINAPI unix_vkCreateImageView(VkDevice device, const VkImageViewCreateI
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
+static VkResult WINAPI wine_vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5496,31 +5496,31 @@ static VkResult WINAPI unix_vkCreateIndirectCommandsLayoutNV(VkDevice device, co
 #endif
 }
 
-VkResult WINAPI unix_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
+VkResult WINAPI wine_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineCache);
     return device->funcs.p_vkCreatePipelineCache(device->device, pCreateInfo, NULL, pPipelineCache);
 }
 
-VkResult WINAPI unix_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
+VkResult WINAPI wine_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPipelineLayout);
     return device->funcs.p_vkCreatePipelineLayout(device->device, pCreateInfo, NULL, pPipelineLayout);
 }
 
-static VkResult WINAPI unix_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
+static VkResult WINAPI wine_vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlotEXT *pPrivateDataSlot)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pPrivateDataSlot);
     return device->funcs.p_vkCreatePrivateDataSlotEXT(device->device, pCreateInfo, NULL, pPrivateDataSlot);
 }
 
-VkResult WINAPI unix_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
+VkResult WINAPI wine_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pQueryPool);
     return device->funcs.p_vkCreateQueryPool(device->device, pCreateInfo, NULL, pQueryPool);
 }
 
-static VkResult WINAPI unix_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+static VkResult WINAPI wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5538,7 +5538,7 @@ static VkResult WINAPI unix_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDe
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
+static VkResult WINAPI wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5556,49 +5556,49 @@ static VkResult WINAPI unix_vkCreateRayTracingPipelinesNV(VkDevice device, VkPip
 #endif
 }
 
-VkResult WINAPI unix_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI wine_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
     return device->funcs.p_vkCreateRenderPass(device->device, pCreateInfo, NULL, pRenderPass);
 }
 
-VkResult WINAPI unix_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+VkResult WINAPI wine_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
     return device->funcs.p_vkCreateRenderPass2(device->device, pCreateInfo, NULL, pRenderPass);
 }
 
-static VkResult WINAPI unix_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
+static VkResult WINAPI wine_vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pRenderPass);
     return device->funcs.p_vkCreateRenderPass2KHR(device->device, pCreateInfo, NULL, pRenderPass);
 }
 
-VkResult WINAPI unix_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
+VkResult WINAPI wine_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSampler);
     return device->funcs.p_vkCreateSampler(device->device, pCreateInfo, NULL, pSampler);
 }
 
-VkResult WINAPI unix_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
+VkResult WINAPI wine_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
     return device->funcs.p_vkCreateSamplerYcbcrConversion(device->device, pCreateInfo, NULL, pYcbcrConversion);
 }
 
-static VkResult WINAPI unix_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
+static VkResult WINAPI wine_vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pYcbcrConversion);
     return device->funcs.p_vkCreateSamplerYcbcrConversionKHR(device->device, pCreateInfo, NULL, pYcbcrConversion);
 }
 
-VkResult WINAPI unix_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
+VkResult WINAPI wine_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pSemaphore);
     return device->funcs.p_vkCreateSemaphore(device->device, pCreateInfo, NULL, pSemaphore);
 }
 
-VkResult WINAPI unix_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
+VkResult WINAPI wine_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pShaderModule);
     return device->funcs.p_vkCreateShaderModule(device->device, pCreateInfo, NULL, pShaderModule);
@@ -5618,7 +5618,7 @@ VkResult thunk_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfo
 #endif
 }
 
-static VkResult WINAPI unix_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
+static VkResult WINAPI wine_vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
 {
     TRACE("%p, %p, %p, %p\n", device, pCreateInfo, pAllocator, pValidationCache);
     return device->funcs.p_vkCreateValidationCacheEXT(device->device, pCreateInfo, NULL, pValidationCache);
@@ -5652,199 +5652,199 @@ VkResult thunk_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarker
 #endif
 }
 
-static VkResult WINAPI unix_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
+static VkResult WINAPI wine_vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
     return device->funcs.p_vkDeferredOperationJoinKHR(device->device, operation);
 }
 
-static void WINAPI unix_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
     device->funcs.p_vkDestroyAccelerationStructureKHR(device->device, accelerationStructure, NULL);
 }
 
-static void WINAPI unix_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), pAllocator);
     device->funcs.p_vkDestroyAccelerationStructureNV(device->device, accelerationStructure, NULL);
 }
 
-void WINAPI unix_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(buffer), pAllocator);
     device->funcs.p_vkDestroyBuffer(device->device, buffer, NULL);
 }
 
-void WINAPI unix_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(bufferView), pAllocator);
     device->funcs.p_vkDestroyBufferView(device->device, bufferView, NULL);
 }
 
-static void WINAPI unix_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(operation), pAllocator);
     device->funcs.p_vkDestroyDeferredOperationKHR(device->device, operation, NULL);
 }
 
-void WINAPI unix_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorPool), pAllocator);
     device->funcs.p_vkDestroyDescriptorPool(device->device, descriptorPool, NULL);
 }
 
-void WINAPI unix_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSetLayout), pAllocator);
     device->funcs.p_vkDestroyDescriptorSetLayout(device->device, descriptorSetLayout, NULL);
 }
 
-void WINAPI unix_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
     device->funcs.p_vkDestroyDescriptorUpdateTemplate(device->device, descriptorUpdateTemplate, NULL);
 }
 
-static void WINAPI unix_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorUpdateTemplate), pAllocator);
     device->funcs.p_vkDestroyDescriptorUpdateTemplateKHR(device->device, descriptorUpdateTemplate, NULL);
 }
 
-void WINAPI unix_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(event), pAllocator);
     device->funcs.p_vkDestroyEvent(device->device, event, NULL);
 }
 
-void WINAPI unix_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(fence), pAllocator);
     device->funcs.p_vkDestroyFence(device->device, fence, NULL);
 }
 
-void WINAPI unix_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(framebuffer), pAllocator);
     device->funcs.p_vkDestroyFramebuffer(device->device, framebuffer, NULL);
 }
 
-void WINAPI unix_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(image), pAllocator);
     device->funcs.p_vkDestroyImage(device->device, image, NULL);
 }
 
-void WINAPI unix_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(imageView), pAllocator);
     device->funcs.p_vkDestroyImageView(device->device, imageView, NULL);
 }
 
-static void WINAPI unix_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(indirectCommandsLayout), pAllocator);
     device->funcs.p_vkDestroyIndirectCommandsLayoutNV(device->device, indirectCommandsLayout, NULL);
 }
 
-void WINAPI unix_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), pAllocator);
     device->funcs.p_vkDestroyPipeline(device->device, pipeline, NULL);
 }
 
-void WINAPI unix_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineCache), pAllocator);
     device->funcs.p_vkDestroyPipelineCache(device->device, pipelineCache, NULL);
 }
 
-void WINAPI unix_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(pipelineLayout), pAllocator);
     device->funcs.p_vkDestroyPipelineLayout(device->device, pipelineLayout, NULL);
 }
 
-static void WINAPI unix_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(privateDataSlot), pAllocator);
     device->funcs.p_vkDestroyPrivateDataSlotEXT(device->device, privateDataSlot, NULL);
 }
 
-void WINAPI unix_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(queryPool), pAllocator);
     device->funcs.p_vkDestroyQueryPool(device->device, queryPool, NULL);
 }
 
-void WINAPI unix_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pAllocator);
     device->funcs.p_vkDestroyRenderPass(device->device, renderPass, NULL);
 }
 
-void WINAPI unix_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(sampler), pAllocator);
     device->funcs.p_vkDestroySampler(device->device, sampler, NULL);
 }
 
-void WINAPI unix_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
     device->funcs.p_vkDestroySamplerYcbcrConversion(device->device, ycbcrConversion, NULL);
 }
 
-static void WINAPI unix_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(ycbcrConversion), pAllocator);
     device->funcs.p_vkDestroySamplerYcbcrConversionKHR(device->device, ycbcrConversion, NULL);
 }
 
-void WINAPI unix_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pAllocator);
     device->funcs.p_vkDestroySemaphore(device->device, semaphore, NULL);
 }
 
-void WINAPI unix_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(shaderModule), pAllocator);
     device->funcs.p_vkDestroyShaderModule(device->device, shaderModule, NULL);
 }
 
-void WINAPI unix_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(swapchain), pAllocator);
     device->funcs.p_vkDestroySwapchainKHR(device->device, swapchain, NULL);
 }
 
-static void WINAPI unix_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
+static void WINAPI wine_vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(validationCache), pAllocator);
     device->funcs.p_vkDestroyValidationCacheEXT(device->device, validationCache, NULL);
 }
 
-VkResult WINAPI unix_vkDeviceWaitIdle(VkDevice device)
+VkResult WINAPI wine_vkDeviceWaitIdle(VkDevice device)
 {
     TRACE("%p\n", device);
     return device->funcs.p_vkDeviceWaitIdle(device->device);
 }
 
-VkResult WINAPI unix_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
+VkResult WINAPI wine_vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     TRACE("%p\n", commandBuffer);
     return commandBuffer->device->funcs.p_vkEndCommandBuffer(commandBuffer->command_buffer);
 }
 
-static VkResult WINAPI unix_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
+static VkResult WINAPI wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
 {
     TRACE("%p, %u, %p, %p, %p\n", physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
     return physicalDevice->instance->funcs.p_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice->phys_dev, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions);
 }
 
-VkResult WINAPI unix_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI wine_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -5862,19 +5862,19 @@ VkResult WINAPI unix_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryR
 #endif
 }
 
-VkResult WINAPI unix_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
+VkResult WINAPI wine_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
 {
     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(descriptorPool), descriptorSetCount, pDescriptorSets);
     return device->funcs.p_vkFreeDescriptorSets(device->device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 
-void WINAPI unix_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
+void WINAPI wine_vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pAllocator);
     device->funcs.p_vkFreeMemory(device->device, memory, NULL);
 }
 
-static void WINAPI unix_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
+static void WINAPI wine_vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkAccelerationStructureBuildGeometryInfoKHR_host pBuildInfo_host;
@@ -5891,7 +5891,7 @@ static void WINAPI unix_vkGetAccelerationStructureBuildSizesKHR(VkDevice device,
 #endif
 }
 
-static VkDeviceAddress WINAPI unix_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
+static VkDeviceAddress WINAPI wine_vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDeviceAddress result;
@@ -5908,13 +5908,13 @@ static VkDeviceAddress WINAPI unix_vkGetAccelerationStructureDeviceAddressKHR(Vk
 #endif
 }
 
-static VkResult WINAPI unix_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
+static VkResult WINAPI wine_vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(accelerationStructure), wine_dbgstr_longlong(dataSize), pData);
     return device->funcs.p_vkGetAccelerationStructureHandleNV(device->device, accelerationStructure, dataSize, pData);
 }
 
-static void WINAPI unix_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
+static void WINAPI wine_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkAccelerationStructureMemoryRequirementsInfoNV_host pInfo_host;
@@ -5932,7 +5932,7 @@ static void WINAPI unix_vkGetAccelerationStructureMemoryRequirementsNV(VkDevice
 #endif
 }
 
-VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDeviceAddress result;
@@ -5949,7 +5949,7 @@ VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddress(VkDevice device, const VkBu
 #endif
 }
 
-static VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDeviceAddress result;
@@ -5966,7 +5966,7 @@ static VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddressEXT(VkDevice device,
 #endif
 }
 
-static VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+static VkDeviceAddress WINAPI wine_vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkDeviceAddress result;
@@ -5983,7 +5983,7 @@ static VkDeviceAddress WINAPI unix_vkGetBufferDeviceAddressKHR(VkDevice device,
 #endif
 }
 
-void WINAPI unix_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI wine_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkMemoryRequirements_host pMemoryRequirements_host;
@@ -5998,7 +5998,7 @@ void WINAPI unix_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
 #endif
 }
 
-void WINAPI unix_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI wine_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryRequirementsInfo2_host pInfo_host;
@@ -6016,7 +6016,7 @@ void WINAPI unix_vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferM
 #endif
 }
 
-static void WINAPI unix_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+static void WINAPI wine_vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkBufferMemoryRequirementsInfo2_host pInfo_host;
@@ -6034,7 +6034,7 @@ static void WINAPI unix_vkGetBufferMemoryRequirements2KHR(VkDevice device, const
 #endif
 }
 
-uint64_t WINAPI unix_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     uint64_t result;
@@ -6051,7 +6051,7 @@ uint64_t WINAPI unix_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBu
 #endif
 }
 
-static uint64_t WINAPI unix_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
+static uint64_t WINAPI wine_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     uint64_t result;
@@ -6068,67 +6068,67 @@ static uint64_t WINAPI unix_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
 #endif
 }
 
-static uint32_t WINAPI unix_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
+static uint32_t WINAPI wine_vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
     return device->funcs.p_vkGetDeferredOperationMaxConcurrencyKHR(device->device, operation);
 }
 
-static VkResult WINAPI unix_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
+static VkResult WINAPI wine_vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(operation));
     return device->funcs.p_vkGetDeferredOperationResultKHR(device->device, operation);
 }
 
-void WINAPI unix_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
+void WINAPI wine_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
     device->funcs.p_vkGetDescriptorSetLayoutSupport(device->device, pCreateInfo, pSupport);
 }
 
-static void WINAPI unix_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
+static void WINAPI wine_vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     TRACE("%p, %p, %p\n", device, pCreateInfo, pSupport);
     device->funcs.p_vkGetDescriptorSetLayoutSupportKHR(device->device, pCreateInfo, pSupport);
 }
 
-static void WINAPI unix_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
+static void WINAPI wine_vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
 {
     TRACE("%p, %p, %p\n", device, pVersionInfo, pCompatibility);
     device->funcs.p_vkGetDeviceAccelerationStructureCompatibilityKHR(device->device, pVersionInfo, pCompatibility);
 }
 
-void WINAPI unix_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
+void WINAPI wine_vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
     device->funcs.p_vkGetDeviceGroupPeerMemoryFeatures(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
 
-static void WINAPI unix_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
+static void WINAPI wine_vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     TRACE("%p, %u, %u, %u, %p\n", device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
     device->funcs.p_vkGetDeviceGroupPeerMemoryFeaturesKHR(device->device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
 
-VkResult WINAPI unix_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
+VkResult WINAPI wine_vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
 {
     TRACE("%p, %p\n", device, pDeviceGroupPresentCapabilities);
     return device->funcs.p_vkGetDeviceGroupPresentCapabilitiesKHR(device->device, pDeviceGroupPresentCapabilities);
 }
 
-VkResult WINAPI unix_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
+VkResult WINAPI wine_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(surface), pModes);
     return device->funcs.p_vkGetDeviceGroupSurfacePresentModesKHR(device->device, wine_surface_from_handle(surface)->driver_surface, pModes);
 }
 
-void WINAPI unix_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
+void WINAPI wine_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(memory), pCommittedMemoryInBytes);
     device->funcs.p_vkGetDeviceMemoryCommitment(device->device, memory, pCommittedMemoryInBytes);
 }
 
-uint64_t WINAPI unix_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     uint64_t result;
@@ -6145,7 +6145,7 @@ uint64_t WINAPI unix_vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, cons
 #endif
 }
 
-static uint64_t WINAPI unix_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
+static uint64_t WINAPI wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     uint64_t result;
@@ -6162,19 +6162,19 @@ static uint64_t WINAPI unix_vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice de
 #endif
 }
 
-VkResult WINAPI unix_vkGetEventStatus(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkGetEventStatus(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkGetEventStatus(device->device, event);
 }
 
-VkResult WINAPI unix_vkGetFenceStatus(VkDevice device, VkFence fence)
+VkResult WINAPI wine_vkGetFenceStatus(VkDevice device, VkFence fence)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(fence));
     return device->funcs.p_vkGetFenceStatus(device->device, fence);
 }
 
-static void WINAPI unix_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+static void WINAPI wine_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkGeneratedCommandsMemoryRequirementsInfoNV_host pInfo_host;
@@ -6192,7 +6192,7 @@ static void WINAPI unix_vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice devi
 #endif
 }
 
-void WINAPI unix_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
+void WINAPI wine_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkMemoryRequirements_host pMemoryRequirements_host;
@@ -6207,7 +6207,7 @@ void WINAPI unix_vkGetImageMemoryRequirements(VkDevice device, VkImage image, Vk
 #endif
 }
 
-void WINAPI unix_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+void WINAPI wine_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkImageMemoryRequirementsInfo2_host pInfo_host;
@@ -6225,7 +6225,7 @@ void WINAPI unix_vkGetImageMemoryRequirements2(VkDevice device, const VkImageMem
 #endif
 }
 
-static void WINAPI unix_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
+static void WINAPI wine_vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkImageMemoryRequirementsInfo2_host pInfo_host;
@@ -6243,13 +6243,13 @@ static void WINAPI unix_vkGetImageMemoryRequirements2KHR(VkDevice device, const
 #endif
 }
 
-void WINAPI unix_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
+void WINAPI wine_vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(image), pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     device->funcs.p_vkGetImageSparseMemoryRequirements(device->device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-void WINAPI unix_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+void WINAPI wine_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
@@ -6264,7 +6264,7 @@ void WINAPI unix_vkGetImageSparseMemoryRequirements2(VkDevice device, const VkIm
 #endif
 }
 
-static void WINAPI unix_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
+static void WINAPI wine_vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkImageSparseMemoryRequirementsInfo2_host pInfo_host;
@@ -6279,7 +6279,7 @@ static void WINAPI unix_vkGetImageSparseMemoryRequirements2KHR(VkDevice device,
 #endif
 }
 
-void WINAPI unix_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
+void WINAPI wine_vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkSubresourceLayout_host pLayout_host;
@@ -6294,67 +6294,67 @@ void WINAPI unix_vkGetImageSubresourceLayout(VkDevice device, VkImage image, con
 #endif
 }
 
-static VkResult WINAPI unix_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
+static VkResult WINAPI wine_vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
 {
     TRACE("%p, %#x, %p, %p\n", device, handleType, pHostPointer, pMemoryHostPointerProperties);
     return device->funcs.p_vkGetMemoryHostPointerPropertiesEXT(device->device, handleType, pHostPointer, pMemoryHostPointerProperties);
 }
 
-static VkResult WINAPI unix_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
+static VkResult WINAPI wine_vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
 {
     TRACE("%p, %#x, %p\n", device, parameter, pValue);
     return device->funcs.p_vkGetPerformanceParameterINTEL(device->device, parameter, pValue);
 }
 
-static VkResult WINAPI unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
+static VkResult WINAPI wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice->phys_dev, pPropertyCount, pProperties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
+void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
 {
     TRACE("%p, %p\n", physicalDevice, pFeatures);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
+void WINAPI wine_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     TRACE("%p, %p\n", physicalDevice, pFeatures);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2(physicalDevice->phys_dev, pFeatures);
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
+static void WINAPI wine_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     TRACE("%p, %p\n", physicalDevice, pFeatures);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures2KHR(physicalDevice->phys_dev, pFeatures);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
+void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
 {
     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
+void WINAPI wine_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2(physicalDevice->phys_dev, format, pFormatProperties);
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
+static void WINAPI wine_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     TRACE("%p, %#x, %p\n", physicalDevice, format, pFormatProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice->phys_dev, format, pFormatProperties);
 }
 
-static VkResult WINAPI unix_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
+static VkResult WINAPI wine_vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice->phys_dev, pFragmentShadingRateCount, pFragmentShadingRates);
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6401,7 +6401,7 @@ VkResult thunk_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phy
 #endif
 }
 
-void WINAPI unix_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
+void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
@@ -6416,7 +6416,7 @@ void WINAPI unix_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDe
 #endif
 }
 
-void WINAPI unix_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
+void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
@@ -6432,7 +6432,7 @@ void WINAPI unix_vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalD
 #endif
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
+static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceMemoryProperties2_host pMemoryProperties_host;
@@ -6448,19 +6448,19 @@ static void WINAPI unix_vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice
 #endif
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
+static void WINAPI wine_vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
 {
     TRACE("%p, %#x, %p\n", physicalDevice, samples, pMultisampleProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice->phys_dev, samples, pMultisampleProperties);
 }
 
-VkResult WINAPI unix_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
+VkResult WINAPI wine_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
 {
     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pRectCount, pRects);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pRectCount, pRects);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceProperties_host pProperties_host;
@@ -6475,7 +6475,7 @@ void WINAPI unix_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
 #endif
 }
 
-void WINAPI unix_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceProperties2_host pProperties_host;
@@ -6491,7 +6491,7 @@ void WINAPI unix_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
 #endif
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
+static void WINAPI wine_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkPhysicalDeviceProperties2_host pProperties_host;
@@ -6507,49 +6507,49 @@ static void WINAPI unix_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physi
 #endif
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
+static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pPerformanceQueryCreateInfo, pNumPasses);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice->phys_dev, pPerformanceQueryCreateInfo, pNumPasses);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
+void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
+void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
+static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
 {
     TRACE("%p, %#x, %#x, %#x, %#x, %#x, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
 }
 
-void WINAPI unix_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
+void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
 }
 
-static void WINAPI unix_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
+static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     TRACE("%p, %p, %p, %p\n", physicalDevice, pFormatInfo, pPropertyCount, pProperties);
     physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice->phys_dev, pFormatInfo, pPropertyCount, pProperties);
 }
 
-static VkResult WINAPI unix_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
+static VkResult WINAPI wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pCombinationCount, pCombinations);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice->phys_dev, pCombinationCount, pCombinations);
@@ -6588,43 +6588,43 @@ VkResult thunk_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDe
 #endif
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
 {
     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pSurfaceFormatCount, pSurfaceFormats);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
 {
     TRACE("%p, 0x%s, %p, %p\n", physicalDevice, wine_dbgstr_longlong(surface), pPresentModeCount, pPresentModes);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice->phys_dev, wine_surface_from_handle(surface)->driver_surface, pPresentModeCount, pPresentModes);
 }
 
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
 {
     TRACE("%p, %u, 0x%s, %p\n", physicalDevice, queueFamilyIndex, wine_dbgstr_longlong(surface), pSupported);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice->phys_dev, queueFamilyIndex, wine_surface_from_handle(surface)->driver_surface, pSupported);
 }
 
-static VkResult WINAPI unix_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
+static VkResult WINAPI wine_vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolPropertiesEXT *pToolProperties)
 {
     TRACE("%p, %p, %p\n", physicalDevice, pToolCount, pToolProperties);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice->phys_dev, pToolCount, pToolProperties);
 }
 
-VkBool32 WINAPI unix_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
+VkBool32 WINAPI wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
 {
     TRACE("%p, %u\n", physicalDevice, queueFamilyIndex);
     return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice->phys_dev, queueFamilyIndex);
 }
 
-VkResult WINAPI unix_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
+VkResult WINAPI wine_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(pipelineCache), pDataSize, pData);
     return device->funcs.p_vkGetPipelineCacheData(device->device, pipelineCache, pDataSize, pData);
 }
 
-static VkResult WINAPI unix_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
+static VkResult WINAPI wine_vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6641,7 +6641,7 @@ static VkResult WINAPI unix_vkGetPipelineExecutableInternalRepresentationsKHR(Vk
 #endif
 }
 
-static VkResult WINAPI unix_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
+static VkResult WINAPI wine_vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6658,7 +6658,7 @@ static VkResult WINAPI unix_vkGetPipelineExecutablePropertiesKHR(VkDevice device
 #endif
 }
 
-static VkResult WINAPI unix_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
+static VkResult WINAPI wine_vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6675,91 +6675,91 @@ static VkResult WINAPI unix_vkGetPipelineExecutableStatisticsKHR(VkDevice device
 #endif
 }
 
-VkResult WINAPI unix_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
+VkResult WINAPI wine_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p, 0x%s, %#x\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride), flags);
     return device->funcs.p_vkGetQueryPoolResults(device->device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
 }
 
-static void WINAPI unix_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
+static void WINAPI wine_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
 {
     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
     queue->device->funcs.p_vkGetQueueCheckpointData2NV(queue->queue, pCheckpointDataCount, pCheckpointData);
 }
 
-static void WINAPI unix_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
+static void WINAPI wine_vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
 {
     TRACE("%p, %p, %p\n", queue, pCheckpointDataCount, pCheckpointData);
     queue->device->funcs.p_vkGetQueueCheckpointDataNV(queue->queue, pCheckpointDataCount, pCheckpointData);
 }
 
-static VkResult WINAPI unix_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+static VkResult WINAPI wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
     return device->funcs.p_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-static VkResult WINAPI unix_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
     return device->funcs.p_vkGetRayTracingShaderGroupHandlesKHR(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-static VkResult WINAPI unix_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
+static VkResult WINAPI wine_vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     TRACE("%p, 0x%s, %u, %u, 0x%s, %p\n", device, wine_dbgstr_longlong(pipeline), firstGroup, groupCount, wine_dbgstr_longlong(dataSize), pData);
     return device->funcs.p_vkGetRayTracingShaderGroupHandlesNV(device->device, pipeline, firstGroup, groupCount, dataSize, pData);
 }
 
-static VkDeviceSize WINAPI unix_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
+static VkDeviceSize WINAPI wine_vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
 {
     TRACE("%p, 0x%s, %u, %#x\n", device, wine_dbgstr_longlong(pipeline), group, groupShader);
     return device->funcs.p_vkGetRayTracingShaderGroupStackSizeKHR(device->device, pipeline, group, groupShader);
 }
 
-void WINAPI unix_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
+void WINAPI wine_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(renderPass), pGranularity);
     device->funcs.p_vkGetRenderAreaGranularity(device->device, renderPass, pGranularity);
 }
 
-VkResult WINAPI unix_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
+VkResult WINAPI wine_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
     return device->funcs.p_vkGetSemaphoreCounterValue(device->device, semaphore, pValue);
 }
 
-static VkResult WINAPI unix_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
+static VkResult WINAPI wine_vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(semaphore), pValue);
     return device->funcs.p_vkGetSemaphoreCounterValueKHR(device->device, semaphore, pValue);
 }
 
-static VkResult WINAPI unix_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
+static VkResult WINAPI wine_vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
 {
     TRACE("%p, 0x%s, %#x, %#x, %p, %p\n", device, wine_dbgstr_longlong(pipeline), shaderStage, infoType, pInfoSize, pInfo);
     return device->funcs.p_vkGetShaderInfoAMD(device->device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
 }
 
-VkResult WINAPI unix_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
+VkResult WINAPI wine_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(swapchain), pSwapchainImageCount, pSwapchainImages);
     return device->funcs.p_vkGetSwapchainImagesKHR(device->device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }
 
-static VkResult WINAPI unix_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
+static VkResult WINAPI wine_vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
 {
     TRACE("%p, 0x%s, %p, %p\n", device, wine_dbgstr_longlong(validationCache), pDataSize, pData);
     return device->funcs.p_vkGetValidationCacheDataEXT(device->device, validationCache, pDataSize, pData);
 }
 
-static VkResult WINAPI unix_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
+static VkResult WINAPI wine_vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
 {
     TRACE("%p, %p\n", device, pInitializeInfo);
     return device->funcs.p_vkInitializePerformanceApiINTEL(device->device, pInitializeInfo);
 }
 
-VkResult WINAPI unix_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
+VkResult WINAPI wine_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6777,31 +6777,31 @@ VkResult WINAPI unix_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t me
 #endif
 }
 
-VkResult WINAPI unix_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
+VkResult WINAPI wine_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
 {
     TRACE("%p, 0x%s, 0x%s, 0x%s, %#x, %p\n", device, wine_dbgstr_longlong(memory), wine_dbgstr_longlong(offset), wine_dbgstr_longlong(size), flags, ppData);
     return device->funcs.p_vkMapMemory(device->device, memory, offset, size, flags, ppData);
 }
 
-VkResult WINAPI unix_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
+VkResult WINAPI wine_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
 {
     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
     return device->funcs.p_vkMergePipelineCaches(device->device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-static VkResult WINAPI unix_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
+static VkResult WINAPI wine_vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
 {
     TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(dstCache), srcCacheCount, pSrcCaches);
     return device->funcs.p_vkMergeValidationCachesEXT(device->device, dstCache, srcCacheCount, pSrcCaches);
 }
 
-static void WINAPI unix_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
+static void WINAPI wine_vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     TRACE("%p, %p\n", queue, pLabelInfo);
     queue->device->funcs.p_vkQueueBeginDebugUtilsLabelEXT(queue->queue, pLabelInfo);
 }
 
-VkResult WINAPI unix_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
+VkResult WINAPI wine_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6819,31 +6819,31 @@ VkResult WINAPI unix_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, co
 #endif
 }
 
-static void WINAPI unix_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
+static void WINAPI wine_vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
 {
     TRACE("%p\n", queue);
     queue->device->funcs.p_vkQueueEndDebugUtilsLabelEXT(queue->queue);
 }
 
-static void WINAPI unix_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
+static void WINAPI wine_vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     TRACE("%p, %p\n", queue, pLabelInfo);
     queue->device->funcs.p_vkQueueInsertDebugUtilsLabelEXT(queue->queue, pLabelInfo);
 }
 
-VkResult WINAPI unix_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
+VkResult WINAPI wine_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
 {
     TRACE("%p, %p\n", queue, pPresentInfo);
     return queue->device->funcs.p_vkQueuePresentKHR(queue->queue, pPresentInfo);
 }
 
-static VkResult WINAPI unix_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
+static VkResult WINAPI wine_vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
 {
     TRACE("%p, 0x%s\n", queue, wine_dbgstr_longlong(configuration));
     return queue->device->funcs.p_vkQueueSetPerformanceConfigurationINTEL(queue->queue, configuration);
 }
 
-static VkResult WINAPI unix_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
+static VkResult WINAPI wine_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR *pSubmits, VkFence fence)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6861,61 +6861,61 @@ static VkResult WINAPI unix_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCoun
 #endif
 }
 
-VkResult WINAPI unix_vkQueueWaitIdle(VkQueue queue)
+VkResult WINAPI wine_vkQueueWaitIdle(VkQueue queue)
 {
     TRACE("%p\n", queue);
     return queue->device->funcs.p_vkQueueWaitIdle(queue->queue);
 }
 
-static VkResult WINAPI unix_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
+static VkResult WINAPI wine_vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(configuration));
     return device->funcs.p_vkReleasePerformanceConfigurationINTEL(device->device, configuration);
 }
 
-static void WINAPI unix_vkReleaseProfilingLockKHR(VkDevice device)
+static void WINAPI wine_vkReleaseProfilingLockKHR(VkDevice device)
 {
     TRACE("%p\n", device);
     device->funcs.p_vkReleaseProfilingLockKHR(device->device);
 }
 
-VkResult WINAPI unix_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
+VkResult WINAPI wine_vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
     TRACE("%p, %#x\n", commandBuffer, flags);
     return commandBuffer->device->funcs.p_vkResetCommandBuffer(commandBuffer->command_buffer, flags);
 }
 
-VkResult WINAPI unix_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+VkResult WINAPI wine_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
     return device->funcs.p_vkResetCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
 }
 
-VkResult WINAPI unix_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+VkResult WINAPI wine_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(descriptorPool), flags);
     return device->funcs.p_vkResetDescriptorPool(device->device, descriptorPool, flags);
 }
 
-VkResult WINAPI unix_vkResetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkResetEvent(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkResetEvent(device->device, event);
 }
 
-VkResult WINAPI unix_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
+VkResult WINAPI wine_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
 {
     TRACE("%p, %u, %p\n", device, fenceCount, pFences);
     return device->funcs.p_vkResetFences(device->device, fenceCount, pFences);
 }
 
-void WINAPI unix_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+void WINAPI wine_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
     device->funcs.p_vkResetQueryPool(device->device, queryPool, firstQuery, queryCount);
 }
 
-static void WINAPI unix_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+static void WINAPI wine_vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     TRACE("%p, 0x%s, %u, %u\n", device, wine_dbgstr_longlong(queryPool), firstQuery, queryCount);
     device->funcs.p_vkResetQueryPoolEXT(device->device, queryPool, firstQuery, queryCount);
@@ -6949,13 +6949,13 @@ VkResult thunk_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsOb
 #endif
 }
 
-VkResult WINAPI unix_vkSetEvent(VkDevice device, VkEvent event)
+VkResult WINAPI wine_vkSetEvent(VkDevice device, VkEvent event)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(event));
     return device->funcs.p_vkSetEvent(device->device, event);
 }
 
-VkResult WINAPI unix_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
+VkResult WINAPI wine_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -6972,7 +6972,7 @@ VkResult WINAPI unix_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalI
 #endif
 }
 
-static VkResult WINAPI unix_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
+static VkResult WINAPI wine_vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkResult result;
@@ -7002,43 +7002,43 @@ void thunk_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessage
 #endif
 }
 
-void WINAPI unix_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+void WINAPI wine_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
     device->funcs.p_vkTrimCommandPool(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
 }
 
-static void WINAPI unix_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+static void WINAPI wine_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     TRACE("%p, 0x%s, %#x\n", device, wine_dbgstr_longlong(commandPool), flags);
     device->funcs.p_vkTrimCommandPoolKHR(device->device, wine_cmd_pool_from_handle(commandPool)->command_pool, flags);
 }
 
-static void WINAPI unix_vkUninitializePerformanceApiINTEL(VkDevice device)
+static void WINAPI wine_vkUninitializePerformanceApiINTEL(VkDevice device)
 {
     TRACE("%p\n", device);
     device->funcs.p_vkUninitializePerformanceApiINTEL(device->device);
 }
 
-void WINAPI unix_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
+void WINAPI wine_vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
 {
     TRACE("%p, 0x%s\n", device, wine_dbgstr_longlong(memory));
     device->funcs.p_vkUnmapMemory(device->device, memory);
 }
 
-void WINAPI unix_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
+void WINAPI wine_vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
     device->funcs.p_vkUpdateDescriptorSetWithTemplate(device->device, descriptorSet, descriptorUpdateTemplate, pData);
 }
 
-static void WINAPI unix_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
+static void WINAPI wine_vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     TRACE("%p, 0x%s, 0x%s, %p\n", device, wine_dbgstr_longlong(descriptorSet), wine_dbgstr_longlong(descriptorUpdateTemplate), pData);
     device->funcs.p_vkUpdateDescriptorSetWithTemplateKHR(device->device, descriptorSet, descriptorUpdateTemplate, pData);
 }
 
-void WINAPI unix_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
+void WINAPI wine_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
 {
 #if defined(USE_STRUCT_CONVERSION)
     VkWriteDescriptorSet_host *pDescriptorWrites_host;
@@ -7057,25 +7057,25 @@ void WINAPI unix_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWrit
 #endif
 }
 
-VkResult WINAPI unix_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
+VkResult WINAPI wine_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
 {
     TRACE("%p, %u, %p, %u, 0x%s\n", device, fenceCount, pFences, waitAll, wine_dbgstr_longlong(timeout));
     return device->funcs.p_vkWaitForFences(device->device, fenceCount, pFences, waitAll, timeout);
 }
 
-VkResult WINAPI unix_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
+VkResult WINAPI wine_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
     return device->funcs.p_vkWaitSemaphores(device->device, pWaitInfo, timeout);
 }
 
-static VkResult WINAPI unix_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
+static VkResult WINAPI wine_vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     TRACE("%p, %p, 0x%s\n", device, pWaitInfo, wine_dbgstr_longlong(timeout));
     return device->funcs.p_vkWaitSemaphoresKHR(device->device, pWaitInfo, timeout);
 }
 
-static VkResult WINAPI unix_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
+static VkResult WINAPI wine_vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
 {
     TRACE("%p, %u, %p, %#x, 0x%s, %p, 0x%s\n", device, accelerationStructureCount, pAccelerationStructures, queryType, wine_dbgstr_longlong(dataSize), pData, wine_dbgstr_longlong(stride));
     return device->funcs.p_vkWriteAccelerationStructuresPropertiesKHR(device->device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
@@ -7339,396 +7339,396 @@ uint64_t wine_vk_unwrap_handle(VkObjectType type, uint64_t handle)
 
 const struct unix_funcs loader_funcs =
 {
-    &unix_vkAcquireNextImage2KHR,
-    &unix_vkAcquireNextImageKHR,
-    &unix_vkAcquirePerformanceConfigurationINTEL,
-    &unix_vkAcquireProfilingLockKHR,
-    &unix_vkAllocateCommandBuffers,
-    &unix_vkAllocateDescriptorSets,
-    &unix_vkAllocateMemory,
-    &unix_vkBeginCommandBuffer,
-    &unix_vkBindAccelerationStructureMemoryNV,
-    &unix_vkBindBufferMemory,
-    &unix_vkBindBufferMemory2,
-    &unix_vkBindBufferMemory2KHR,
-    &unix_vkBindImageMemory,
-    &unix_vkBindImageMemory2,
-    &unix_vkBindImageMemory2KHR,
-    &unix_vkBuildAccelerationStructuresKHR,
-    &unix_vkCmdBeginConditionalRenderingEXT,
-    &unix_vkCmdBeginDebugUtilsLabelEXT,
-    &unix_vkCmdBeginQuery,
-    &unix_vkCmdBeginQueryIndexedEXT,
-    &unix_vkCmdBeginRenderPass,
-    &unix_vkCmdBeginRenderPass2,
-    &unix_vkCmdBeginRenderPass2KHR,
-    &unix_vkCmdBeginTransformFeedbackEXT,
-    &unix_vkCmdBindDescriptorSets,
-    &unix_vkCmdBindIndexBuffer,
-    &unix_vkCmdBindPipeline,
-    &unix_vkCmdBindPipelineShaderGroupNV,
-    &unix_vkCmdBindShadingRateImageNV,
-    &unix_vkCmdBindTransformFeedbackBuffersEXT,
-    &unix_vkCmdBindVertexBuffers,
-    &unix_vkCmdBindVertexBuffers2EXT,
-    &unix_vkCmdBlitImage,
-    &unix_vkCmdBlitImage2KHR,
-    &unix_vkCmdBuildAccelerationStructureNV,
-    &unix_vkCmdBuildAccelerationStructuresIndirectKHR,
-    &unix_vkCmdBuildAccelerationStructuresKHR,
-    &unix_vkCmdClearAttachments,
-    &unix_vkCmdClearColorImage,
-    &unix_vkCmdClearDepthStencilImage,
-    &unix_vkCmdCopyAccelerationStructureKHR,
-    &unix_vkCmdCopyAccelerationStructureNV,
-    &unix_vkCmdCopyAccelerationStructureToMemoryKHR,
-    &unix_vkCmdCopyBuffer,
-    &unix_vkCmdCopyBuffer2KHR,
-    &unix_vkCmdCopyBufferToImage,
-    &unix_vkCmdCopyBufferToImage2KHR,
-    &unix_vkCmdCopyImage,
-    &unix_vkCmdCopyImage2KHR,
-    &unix_vkCmdCopyImageToBuffer,
-    &unix_vkCmdCopyImageToBuffer2KHR,
-    &unix_vkCmdCopyMemoryToAccelerationStructureKHR,
-    &unix_vkCmdCopyQueryPoolResults,
-    &unix_vkCmdDebugMarkerBeginEXT,
-    &unix_vkCmdDebugMarkerEndEXT,
-    &unix_vkCmdDebugMarkerInsertEXT,
-    &unix_vkCmdDispatch,
-    &unix_vkCmdDispatchBase,
-    &unix_vkCmdDispatchBaseKHR,
-    &unix_vkCmdDispatchIndirect,
-    &unix_vkCmdDraw,
-    &unix_vkCmdDrawIndexed,
-    &unix_vkCmdDrawIndexedIndirect,
-    &unix_vkCmdDrawIndexedIndirectCount,
-    &unix_vkCmdDrawIndexedIndirectCountAMD,
-    &unix_vkCmdDrawIndexedIndirectCountKHR,
-    &unix_vkCmdDrawIndirect,
-    &unix_vkCmdDrawIndirectByteCountEXT,
-    &unix_vkCmdDrawIndirectCount,
-    &unix_vkCmdDrawIndirectCountAMD,
-    &unix_vkCmdDrawIndirectCountKHR,
-    &unix_vkCmdDrawMeshTasksIndirectCountNV,
-    &unix_vkCmdDrawMeshTasksIndirectNV,
-    &unix_vkCmdDrawMeshTasksNV,
-    &unix_vkCmdEndConditionalRenderingEXT,
-    &unix_vkCmdEndDebugUtilsLabelEXT,
-    &unix_vkCmdEndQuery,
-    &unix_vkCmdEndQueryIndexedEXT,
-    &unix_vkCmdEndRenderPass,
-    &unix_vkCmdEndRenderPass2,
-    &unix_vkCmdEndRenderPass2KHR,
-    &unix_vkCmdEndTransformFeedbackEXT,
-    &unix_vkCmdExecuteCommands,
-    &unix_vkCmdExecuteGeneratedCommandsNV,
-    &unix_vkCmdFillBuffer,
-    &unix_vkCmdInsertDebugUtilsLabelEXT,
-    &unix_vkCmdNextSubpass,
-    &unix_vkCmdNextSubpass2,
-    &unix_vkCmdNextSubpass2KHR,
-    &unix_vkCmdPipelineBarrier,
-    &unix_vkCmdPipelineBarrier2KHR,
-    &unix_vkCmdPreprocessGeneratedCommandsNV,
-    &unix_vkCmdPushConstants,
-    &unix_vkCmdPushDescriptorSetKHR,
-    &unix_vkCmdPushDescriptorSetWithTemplateKHR,
-    &unix_vkCmdResetEvent,
-    &unix_vkCmdResetEvent2KHR,
-    &unix_vkCmdResetQueryPool,
-    &unix_vkCmdResolveImage,
-    &unix_vkCmdResolveImage2KHR,
-    &unix_vkCmdSetBlendConstants,
-    &unix_vkCmdSetCheckpointNV,
-    &unix_vkCmdSetCoarseSampleOrderNV,
-    &unix_vkCmdSetColorWriteEnableEXT,
-    &unix_vkCmdSetCullModeEXT,
-    &unix_vkCmdSetDepthBias,
-    &unix_vkCmdSetDepthBiasEnableEXT,
-    &unix_vkCmdSetDepthBounds,
-    &unix_vkCmdSetDepthBoundsTestEnableEXT,
-    &unix_vkCmdSetDepthCompareOpEXT,
-    &unix_vkCmdSetDepthTestEnableEXT,
-    &unix_vkCmdSetDepthWriteEnableEXT,
-    &unix_vkCmdSetDeviceMask,
-    &unix_vkCmdSetDeviceMaskKHR,
-    &unix_vkCmdSetDiscardRectangleEXT,
-    &unix_vkCmdSetEvent,
-    &unix_vkCmdSetEvent2KHR,
-    &unix_vkCmdSetExclusiveScissorNV,
-    &unix_vkCmdSetFragmentShadingRateEnumNV,
-    &unix_vkCmdSetFragmentShadingRateKHR,
-    &unix_vkCmdSetFrontFaceEXT,
-    &unix_vkCmdSetLineStippleEXT,
-    &unix_vkCmdSetLineWidth,
-    &unix_vkCmdSetLogicOpEXT,
-    &unix_vkCmdSetPatchControlPointsEXT,
-    &unix_vkCmdSetPerformanceMarkerINTEL,
-    &unix_vkCmdSetPerformanceOverrideINTEL,
-    &unix_vkCmdSetPerformanceStreamMarkerINTEL,
-    &unix_vkCmdSetPrimitiveRestartEnableEXT,
-    &unix_vkCmdSetPrimitiveTopologyEXT,
-    &unix_vkCmdSetRasterizerDiscardEnableEXT,
-    &unix_vkCmdSetRayTracingPipelineStackSizeKHR,
-    &unix_vkCmdSetSampleLocationsEXT,
-    &unix_vkCmdSetScissor,
-    &unix_vkCmdSetScissorWithCountEXT,
-    &unix_vkCmdSetStencilCompareMask,
-    &unix_vkCmdSetStencilOpEXT,
-    &unix_vkCmdSetStencilReference,
-    &unix_vkCmdSetStencilTestEnableEXT,
-    &unix_vkCmdSetStencilWriteMask,
-    &unix_vkCmdSetVertexInputEXT,
-    &unix_vkCmdSetViewport,
-    &unix_vkCmdSetViewportShadingRatePaletteNV,
-    &unix_vkCmdSetViewportWScalingNV,
-    &unix_vkCmdSetViewportWithCountEXT,
-    &unix_vkCmdTraceRaysIndirectKHR,
-    &unix_vkCmdTraceRaysKHR,
-    &unix_vkCmdTraceRaysNV,
-    &unix_vkCmdUpdateBuffer,
-    &unix_vkCmdWaitEvents,
-    &unix_vkCmdWaitEvents2KHR,
-    &unix_vkCmdWriteAccelerationStructuresPropertiesKHR,
-    &unix_vkCmdWriteAccelerationStructuresPropertiesNV,
-    &unix_vkCmdWriteBufferMarker2AMD,
-    &unix_vkCmdWriteBufferMarkerAMD,
-    &unix_vkCmdWriteTimestamp,
-    &unix_vkCmdWriteTimestamp2KHR,
-    &unix_vkCompileDeferredNV,
-    &unix_vkCopyAccelerationStructureKHR,
-    &unix_vkCopyAccelerationStructureToMemoryKHR,
-    &unix_vkCopyMemoryToAccelerationStructureKHR,
-    &unix_vkCreateAccelerationStructureKHR,
-    &unix_vkCreateAccelerationStructureNV,
-    &unix_vkCreateBuffer,
-    &unix_vkCreateBufferView,
-    &unix_vkCreateCommandPool,
-    &unix_vkCreateComputePipelines,
-    &unix_vkCreateDebugReportCallbackEXT,
-    &unix_vkCreateDebugUtilsMessengerEXT,
-    &unix_vkCreateDeferredOperationKHR,
-    &unix_vkCreateDescriptorPool,
-    &unix_vkCreateDescriptorSetLayout,
-    &unix_vkCreateDescriptorUpdateTemplate,
-    &unix_vkCreateDescriptorUpdateTemplateKHR,
-    &unix_vkCreateDevice,
-    &unix_vkCreateEvent,
-    &unix_vkCreateFence,
-    &unix_vkCreateFramebuffer,
-    &unix_vkCreateGraphicsPipelines,
-    &unix_vkCreateImage,
-    &unix_vkCreateImageView,
-    &unix_vkCreateIndirectCommandsLayoutNV,
-    &unix_vkCreateInstance,
-    &unix_vkCreatePipelineCache,
-    &unix_vkCreatePipelineLayout,
-    &unix_vkCreatePrivateDataSlotEXT,
-    &unix_vkCreateQueryPool,
-    &unix_vkCreateRayTracingPipelinesKHR,
-    &unix_vkCreateRayTracingPipelinesNV,
-    &unix_vkCreateRenderPass,
-    &unix_vkCreateRenderPass2,
-    &unix_vkCreateRenderPass2KHR,
-    &unix_vkCreateSampler,
-    &unix_vkCreateSamplerYcbcrConversion,
-    &unix_vkCreateSamplerYcbcrConversionKHR,
-    &unix_vkCreateSemaphore,
-    &unix_vkCreateShaderModule,
-    &unix_vkCreateSwapchainKHR,
-    &unix_vkCreateValidationCacheEXT,
-    &unix_vkCreateWin32SurfaceKHR,
-    &unix_vkDebugMarkerSetObjectNameEXT,
-    &unix_vkDebugMarkerSetObjectTagEXT,
-    &unix_vkDebugReportMessageEXT,
-    &unix_vkDeferredOperationJoinKHR,
-    &unix_vkDestroyAccelerationStructureKHR,
-    &unix_vkDestroyAccelerationStructureNV,
-    &unix_vkDestroyBuffer,
-    &unix_vkDestroyBufferView,
-    &unix_vkDestroyCommandPool,
-    &unix_vkDestroyDebugReportCallbackEXT,
-    &unix_vkDestroyDebugUtilsMessengerEXT,
-    &unix_vkDestroyDeferredOperationKHR,
-    &unix_vkDestroyDescriptorPool,
-    &unix_vkDestroyDescriptorSetLayout,
-    &unix_vkDestroyDescriptorUpdateTemplate,
-    &unix_vkDestroyDescriptorUpdateTemplateKHR,
-    &unix_vkDestroyDevice,
-    &unix_vkDestroyEvent,
-    &unix_vkDestroyFence,
-    &unix_vkDestroyFramebuffer,
-    &unix_vkDestroyImage,
-    &unix_vkDestroyImageView,
-    &unix_vkDestroyIndirectCommandsLayoutNV,
-    &unix_vkDestroyInstance,
-    &unix_vkDestroyPipeline,
-    &unix_vkDestroyPipelineCache,
-    &unix_vkDestroyPipelineLayout,
-    &unix_vkDestroyPrivateDataSlotEXT,
-    &unix_vkDestroyQueryPool,
-    &unix_vkDestroyRenderPass,
-    &unix_vkDestroySampler,
-    &unix_vkDestroySamplerYcbcrConversion,
-    &unix_vkDestroySamplerYcbcrConversionKHR,
-    &unix_vkDestroySemaphore,
-    &unix_vkDestroyShaderModule,
-    &unix_vkDestroySurfaceKHR,
-    &unix_vkDestroySwapchainKHR,
-    &unix_vkDestroyValidationCacheEXT,
-    &unix_vkDeviceWaitIdle,
-    &unix_vkEndCommandBuffer,
-    &unix_vkEnumerateDeviceExtensionProperties,
-    &unix_vkEnumerateDeviceLayerProperties,
-    &unix_vkEnumerateInstanceExtensionProperties,
-    &unix_vkEnumerateInstanceVersion,
-    &unix_vkEnumeratePhysicalDeviceGroups,
-    &unix_vkEnumeratePhysicalDeviceGroupsKHR,
-    &unix_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
-    &unix_vkEnumeratePhysicalDevices,
-    &unix_vkFlushMappedMemoryRanges,
-    &unix_vkFreeCommandBuffers,
-    &unix_vkFreeDescriptorSets,
-    &unix_vkFreeMemory,
-    &unix_vkGetAccelerationStructureBuildSizesKHR,
-    &unix_vkGetAccelerationStructureDeviceAddressKHR,
-    &unix_vkGetAccelerationStructureHandleNV,
-    &unix_vkGetAccelerationStructureMemoryRequirementsNV,
-    &unix_vkGetBufferDeviceAddress,
-    &unix_vkGetBufferDeviceAddressEXT,
-    &unix_vkGetBufferDeviceAddressKHR,
-    &unix_vkGetBufferMemoryRequirements,
-    &unix_vkGetBufferMemoryRequirements2,
-    &unix_vkGetBufferMemoryRequirements2KHR,
-    &unix_vkGetBufferOpaqueCaptureAddress,
-    &unix_vkGetBufferOpaqueCaptureAddressKHR,
-    &unix_vkGetCalibratedTimestampsEXT,
-    &unix_vkGetDeferredOperationMaxConcurrencyKHR,
-    &unix_vkGetDeferredOperationResultKHR,
-    &unix_vkGetDescriptorSetLayoutSupport,
-    &unix_vkGetDescriptorSetLayoutSupportKHR,
-    &unix_vkGetDeviceAccelerationStructureCompatibilityKHR,
-    &unix_vkGetDeviceGroupPeerMemoryFeatures,
-    &unix_vkGetDeviceGroupPeerMemoryFeaturesKHR,
-    &unix_vkGetDeviceGroupPresentCapabilitiesKHR,
-    &unix_vkGetDeviceGroupSurfacePresentModesKHR,
-    &unix_vkGetDeviceMemoryCommitment,
-    &unix_vkGetDeviceMemoryOpaqueCaptureAddress,
-    &unix_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
-    &unix_vkGetDeviceQueue,
-    &unix_vkGetDeviceQueue2,
-    &unix_vkGetEventStatus,
-    &unix_vkGetFenceStatus,
-    &unix_vkGetGeneratedCommandsMemoryRequirementsNV,
-    &unix_vkGetImageMemoryRequirements,
-    &unix_vkGetImageMemoryRequirements2,
-    &unix_vkGetImageMemoryRequirements2KHR,
-    &unix_vkGetImageSparseMemoryRequirements,
-    &unix_vkGetImageSparseMemoryRequirements2,
-    &unix_vkGetImageSparseMemoryRequirements2KHR,
-    &unix_vkGetImageSubresourceLayout,
-    &unix_vkGetMemoryHostPointerPropertiesEXT,
-    &unix_vkGetPerformanceParameterINTEL,
-    &unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
-    &unix_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
-    &unix_vkGetPhysicalDeviceExternalBufferProperties,
-    &unix_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
-    &unix_vkGetPhysicalDeviceExternalFenceProperties,
-    &unix_vkGetPhysicalDeviceExternalFencePropertiesKHR,
-    &unix_vkGetPhysicalDeviceExternalSemaphoreProperties,
-    &unix_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
-    &unix_vkGetPhysicalDeviceFeatures,
-    &unix_vkGetPhysicalDeviceFeatures2,
-    &unix_vkGetPhysicalDeviceFeatures2KHR,
-    &unix_vkGetPhysicalDeviceFormatProperties,
-    &unix_vkGetPhysicalDeviceFormatProperties2,
-    &unix_vkGetPhysicalDeviceFormatProperties2KHR,
-    &unix_vkGetPhysicalDeviceFragmentShadingRatesKHR,
-    &unix_vkGetPhysicalDeviceImageFormatProperties,
-    &unix_vkGetPhysicalDeviceImageFormatProperties2,
-    &unix_vkGetPhysicalDeviceImageFormatProperties2KHR,
-    &unix_vkGetPhysicalDeviceMemoryProperties,
-    &unix_vkGetPhysicalDeviceMemoryProperties2,
-    &unix_vkGetPhysicalDeviceMemoryProperties2KHR,
-    &unix_vkGetPhysicalDeviceMultisamplePropertiesEXT,
-    &unix_vkGetPhysicalDevicePresentRectanglesKHR,
-    &unix_vkGetPhysicalDeviceProperties,
-    &unix_vkGetPhysicalDeviceProperties2,
-    &unix_vkGetPhysicalDeviceProperties2KHR,
-    &unix_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
-    &unix_vkGetPhysicalDeviceQueueFamilyProperties,
-    &unix_vkGetPhysicalDeviceQueueFamilyProperties2,
-    &unix_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
-    &unix_vkGetPhysicalDeviceSparseImageFormatProperties,
-    &unix_vkGetPhysicalDeviceSparseImageFormatProperties2,
-    &unix_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
-    &unix_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
-    &unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
-    &unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
-    &unix_vkGetPhysicalDeviceSurfaceFormats2KHR,
-    &unix_vkGetPhysicalDeviceSurfaceFormatsKHR,
-    &unix_vkGetPhysicalDeviceSurfacePresentModesKHR,
-    &unix_vkGetPhysicalDeviceSurfaceSupportKHR,
-    &unix_vkGetPhysicalDeviceToolPropertiesEXT,
-    &unix_vkGetPhysicalDeviceWin32PresentationSupportKHR,
-    &unix_vkGetPipelineCacheData,
-    &unix_vkGetPipelineExecutableInternalRepresentationsKHR,
-    &unix_vkGetPipelineExecutablePropertiesKHR,
-    &unix_vkGetPipelineExecutableStatisticsKHR,
-    &unix_vkGetPrivateDataEXT,
-    &unix_vkGetQueryPoolResults,
-    &unix_vkGetQueueCheckpointData2NV,
-    &unix_vkGetQueueCheckpointDataNV,
-    &unix_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
-    &unix_vkGetRayTracingShaderGroupHandlesKHR,
-    &unix_vkGetRayTracingShaderGroupHandlesNV,
-    &unix_vkGetRayTracingShaderGroupStackSizeKHR,
-    &unix_vkGetRenderAreaGranularity,
-    &unix_vkGetSemaphoreCounterValue,
-    &unix_vkGetSemaphoreCounterValueKHR,
-    &unix_vkGetShaderInfoAMD,
-    &unix_vkGetSwapchainImagesKHR,
-    &unix_vkGetValidationCacheDataEXT,
-    &unix_vkInitializePerformanceApiINTEL,
-    &unix_vkInvalidateMappedMemoryRanges,
-    &unix_vkMapMemory,
-    &unix_vkMergePipelineCaches,
-    &unix_vkMergeValidationCachesEXT,
-    &unix_vkQueueBeginDebugUtilsLabelEXT,
-    &unix_vkQueueBindSparse,
-    &unix_vkQueueEndDebugUtilsLabelEXT,
-    &unix_vkQueueInsertDebugUtilsLabelEXT,
-    &unix_vkQueuePresentKHR,
-    &unix_vkQueueSetPerformanceConfigurationINTEL,
-    &unix_vkQueueSubmit,
-    &unix_vkQueueSubmit2KHR,
-    &unix_vkQueueWaitIdle,
-    &unix_vkReleasePerformanceConfigurationINTEL,
-    &unix_vkReleaseProfilingLockKHR,
-    &unix_vkResetCommandBuffer,
-    &unix_vkResetCommandPool,
-    &unix_vkResetDescriptorPool,
-    &unix_vkResetEvent,
-    &unix_vkResetFences,
-    &unix_vkResetQueryPool,
-    &unix_vkResetQueryPoolEXT,
-    &unix_vkSetDebugUtilsObjectNameEXT,
-    &unix_vkSetDebugUtilsObjectTagEXT,
-    &unix_vkSetEvent,
-    &unix_vkSetPrivateDataEXT,
-    &unix_vkSignalSemaphore,
-    &unix_vkSignalSemaphoreKHR,
-    &unix_vkSubmitDebugUtilsMessageEXT,
-    &unix_vkTrimCommandPool,
-    &unix_vkTrimCommandPoolKHR,
-    &unix_vkUninitializePerformanceApiINTEL,
-    &unix_vkUnmapMemory,
-    &unix_vkUpdateDescriptorSetWithTemplate,
-    &unix_vkUpdateDescriptorSetWithTemplateKHR,
-    &unix_vkUpdateDescriptorSets,
-    &unix_vkWaitForFences,
-    &unix_vkWaitSemaphores,
-    &unix_vkWaitSemaphoresKHR,
-    &unix_vkWriteAccelerationStructuresPropertiesKHR,
+    &wine_vkAcquireNextImage2KHR,
+    &wine_vkAcquireNextImageKHR,
+    &wine_vkAcquirePerformanceConfigurationINTEL,
+    &wine_vkAcquireProfilingLockKHR,
+    &wine_vkAllocateCommandBuffers,
+    &wine_vkAllocateDescriptorSets,
+    &wine_vkAllocateMemory,
+    &wine_vkBeginCommandBuffer,
+    &wine_vkBindAccelerationStructureMemoryNV,
+    &wine_vkBindBufferMemory,
+    &wine_vkBindBufferMemory2,
+    &wine_vkBindBufferMemory2KHR,
+    &wine_vkBindImageMemory,
+    &wine_vkBindImageMemory2,
+    &wine_vkBindImageMemory2KHR,
+    &wine_vkBuildAccelerationStructuresKHR,
+    &wine_vkCmdBeginConditionalRenderingEXT,
+    &wine_vkCmdBeginDebugUtilsLabelEXT,
+    &wine_vkCmdBeginQuery,
+    &wine_vkCmdBeginQueryIndexedEXT,
+    &wine_vkCmdBeginRenderPass,
+    &wine_vkCmdBeginRenderPass2,
+    &wine_vkCmdBeginRenderPass2KHR,
+    &wine_vkCmdBeginTransformFeedbackEXT,
+    &wine_vkCmdBindDescriptorSets,
+    &wine_vkCmdBindIndexBuffer,
+    &wine_vkCmdBindPipeline,
+    &wine_vkCmdBindPipelineShaderGroupNV,
+    &wine_vkCmdBindShadingRateImageNV,
+    &wine_vkCmdBindTransformFeedbackBuffersEXT,
+    &wine_vkCmdBindVertexBuffers,
+    &wine_vkCmdBindVertexBuffers2EXT,
+    &wine_vkCmdBlitImage,
+    &wine_vkCmdBlitImage2KHR,
+    &wine_vkCmdBuildAccelerationStructureNV,
+    &wine_vkCmdBuildAccelerationStructuresIndirectKHR,
+    &wine_vkCmdBuildAccelerationStructuresKHR,
+    &wine_vkCmdClearAttachments,
+    &wine_vkCmdClearColorImage,
+    &wine_vkCmdClearDepthStencilImage,
+    &wine_vkCmdCopyAccelerationStructureKHR,
+    &wine_vkCmdCopyAccelerationStructureNV,
+    &wine_vkCmdCopyAccelerationStructureToMemoryKHR,
+    &wine_vkCmdCopyBuffer,
+    &wine_vkCmdCopyBuffer2KHR,
+    &wine_vkCmdCopyBufferToImage,
+    &wine_vkCmdCopyBufferToImage2KHR,
+    &wine_vkCmdCopyImage,
+    &wine_vkCmdCopyImage2KHR,
+    &wine_vkCmdCopyImageToBuffer,
+    &wine_vkCmdCopyImageToBuffer2KHR,
+    &wine_vkCmdCopyMemoryToAccelerationStructureKHR,
+    &wine_vkCmdCopyQueryPoolResults,
+    &wine_vkCmdDebugMarkerBeginEXT,
+    &wine_vkCmdDebugMarkerEndEXT,
+    &wine_vkCmdDebugMarkerInsertEXT,
+    &wine_vkCmdDispatch,
+    &wine_vkCmdDispatchBase,
+    &wine_vkCmdDispatchBaseKHR,
+    &wine_vkCmdDispatchIndirect,
+    &wine_vkCmdDraw,
+    &wine_vkCmdDrawIndexed,
+    &wine_vkCmdDrawIndexedIndirect,
+    &wine_vkCmdDrawIndexedIndirectCount,
+    &wine_vkCmdDrawIndexedIndirectCountAMD,
+    &wine_vkCmdDrawIndexedIndirectCountKHR,
+    &wine_vkCmdDrawIndirect,
+    &wine_vkCmdDrawIndirectByteCountEXT,
+    &wine_vkCmdDrawIndirectCount,
+    &wine_vkCmdDrawIndirectCountAMD,
+    &wine_vkCmdDrawIndirectCountKHR,
+    &wine_vkCmdDrawMeshTasksIndirectCountNV,
+    &wine_vkCmdDrawMeshTasksIndirectNV,
+    &wine_vkCmdDrawMeshTasksNV,
+    &wine_vkCmdEndConditionalRenderingEXT,
+    &wine_vkCmdEndDebugUtilsLabelEXT,
+    &wine_vkCmdEndQuery,
+    &wine_vkCmdEndQueryIndexedEXT,
+    &wine_vkCmdEndRenderPass,
+    &wine_vkCmdEndRenderPass2,
+    &wine_vkCmdEndRenderPass2KHR,
+    &wine_vkCmdEndTransformFeedbackEXT,
+    &wine_vkCmdExecuteCommands,
+    &wine_vkCmdExecuteGeneratedCommandsNV,
+    &wine_vkCmdFillBuffer,
+    &wine_vkCmdInsertDebugUtilsLabelEXT,
+    &wine_vkCmdNextSubpass,
+    &wine_vkCmdNextSubpass2,
+    &wine_vkCmdNextSubpass2KHR,
+    &wine_vkCmdPipelineBarrier,
+    &wine_vkCmdPipelineBarrier2KHR,
+    &wine_vkCmdPreprocessGeneratedCommandsNV,
+    &wine_vkCmdPushConstants,
+    &wine_vkCmdPushDescriptorSetKHR,
+    &wine_vkCmdPushDescriptorSetWithTemplateKHR,
+    &wine_vkCmdResetEvent,
+    &wine_vkCmdResetEvent2KHR,
+    &wine_vkCmdResetQueryPool,
+    &wine_vkCmdResolveImage,
+    &wine_vkCmdResolveImage2KHR,
+    &wine_vkCmdSetBlendConstants,
+    &wine_vkCmdSetCheckpointNV,
+    &wine_vkCmdSetCoarseSampleOrderNV,
+    &wine_vkCmdSetColorWriteEnableEXT,
+    &wine_vkCmdSetCullModeEXT,
+    &wine_vkCmdSetDepthBias,
+    &wine_vkCmdSetDepthBiasEnableEXT,
+    &wine_vkCmdSetDepthBounds,
+    &wine_vkCmdSetDepthBoundsTestEnableEXT,
+    &wine_vkCmdSetDepthCompareOpEXT,
+    &wine_vkCmdSetDepthTestEnableEXT,
+    &wine_vkCmdSetDepthWriteEnableEXT,
+    &wine_vkCmdSetDeviceMask,
+    &wine_vkCmdSetDeviceMaskKHR,
+    &wine_vkCmdSetDiscardRectangleEXT,
+    &wine_vkCmdSetEvent,
+    &wine_vkCmdSetEvent2KHR,
+    &wine_vkCmdSetExclusiveScissorNV,
+    &wine_vkCmdSetFragmentShadingRateEnumNV,
+    &wine_vkCmdSetFragmentShadingRateKHR,
+    &wine_vkCmdSetFrontFaceEXT,
+    &wine_vkCmdSetLineStippleEXT,
+    &wine_vkCmdSetLineWidth,
+    &wine_vkCmdSetLogicOpEXT,
+    &wine_vkCmdSetPatchControlPointsEXT,
+    &wine_vkCmdSetPerformanceMarkerINTEL,
+    &wine_vkCmdSetPerformanceOverrideINTEL,
+    &wine_vkCmdSetPerformanceStreamMarkerINTEL,
+    &wine_vkCmdSetPrimitiveRestartEnableEXT,
+    &wine_vkCmdSetPrimitiveTopologyEXT,
+    &wine_vkCmdSetRasterizerDiscardEnableEXT,
+    &wine_vkCmdSetRayTracingPipelineStackSizeKHR,
+    &wine_vkCmdSetSampleLocationsEXT,
+    &wine_vkCmdSetScissor,
+    &wine_vkCmdSetScissorWithCountEXT,
+    &wine_vkCmdSetStencilCompareMask,
+    &wine_vkCmdSetStencilOpEXT,
+    &wine_vkCmdSetStencilReference,
+    &wine_vkCmdSetStencilTestEnableEXT,
+    &wine_vkCmdSetStencilWriteMask,
+    &wine_vkCmdSetVertexInputEXT,
+    &wine_vkCmdSetViewport,
+    &wine_vkCmdSetViewportShadingRatePaletteNV,
+    &wine_vkCmdSetViewportWScalingNV,
+    &wine_vkCmdSetViewportWithCountEXT,
+    &wine_vkCmdTraceRaysIndirectKHR,
+    &wine_vkCmdTraceRaysKHR,
+    &wine_vkCmdTraceRaysNV,
+    &wine_vkCmdUpdateBuffer,
+    &wine_vkCmdWaitEvents,
+    &wine_vkCmdWaitEvents2KHR,
+    &wine_vkCmdWriteAccelerationStructuresPropertiesKHR,
+    &wine_vkCmdWriteAccelerationStructuresPropertiesNV,
+    &wine_vkCmdWriteBufferMarker2AMD,
+    &wine_vkCmdWriteBufferMarkerAMD,
+    &wine_vkCmdWriteTimestamp,
+    &wine_vkCmdWriteTimestamp2KHR,
+    &wine_vkCompileDeferredNV,
+    &wine_vkCopyAccelerationStructureKHR,
+    &wine_vkCopyAccelerationStructureToMemoryKHR,
+    &wine_vkCopyMemoryToAccelerationStructureKHR,
+    &wine_vkCreateAccelerationStructureKHR,
+    &wine_vkCreateAccelerationStructureNV,
+    &wine_vkCreateBuffer,
+    &wine_vkCreateBufferView,
+    &wine_vkCreateCommandPool,
+    &wine_vkCreateComputePipelines,
+    &wine_vkCreateDebugReportCallbackEXT,
+    &wine_vkCreateDebugUtilsMessengerEXT,
+    &wine_vkCreateDeferredOperationKHR,
+    &wine_vkCreateDescriptorPool,
+    &wine_vkCreateDescriptorSetLayout,
+    &wine_vkCreateDescriptorUpdateTemplate,
+    &wine_vkCreateDescriptorUpdateTemplateKHR,
+    &wine_vkCreateDevice,
+    &wine_vkCreateEvent,
+    &wine_vkCreateFence,
+    &wine_vkCreateFramebuffer,
+    &wine_vkCreateGraphicsPipelines,
+    &wine_vkCreateImage,
+    &wine_vkCreateImageView,
+    &wine_vkCreateIndirectCommandsLayoutNV,
+    &wine_vkCreateInstance,
+    &wine_vkCreatePipelineCache,
+    &wine_vkCreatePipelineLayout,
+    &wine_vkCreatePrivateDataSlotEXT,
+    &wine_vkCreateQueryPool,
+    &wine_vkCreateRayTracingPipelinesKHR,
+    &wine_vkCreateRayTracingPipelinesNV,
+    &wine_vkCreateRenderPass,
+    &wine_vkCreateRenderPass2,
+    &wine_vkCreateRenderPass2KHR,
+    &wine_vkCreateSampler,
+    &wine_vkCreateSamplerYcbcrConversion,
+    &wine_vkCreateSamplerYcbcrConversionKHR,
+    &wine_vkCreateSemaphore,
+    &wine_vkCreateShaderModule,
+    &wine_vkCreateSwapchainKHR,
+    &wine_vkCreateValidationCacheEXT,
+    &wine_vkCreateWin32SurfaceKHR,
+    &wine_vkDebugMarkerSetObjectNameEXT,
+    &wine_vkDebugMarkerSetObjectTagEXT,
+    &wine_vkDebugReportMessageEXT,
+    &wine_vkDeferredOperationJoinKHR,
+    &wine_vkDestroyAccelerationStructureKHR,
+    &wine_vkDestroyAccelerationStructureNV,
+    &wine_vkDestroyBuffer,
+    &wine_vkDestroyBufferView,
+    &wine_vkDestroyCommandPool,
+    &wine_vkDestroyDebugReportCallbackEXT,
+    &wine_vkDestroyDebugUtilsMessengerEXT,
+    &wine_vkDestroyDeferredOperationKHR,
+    &wine_vkDestroyDescriptorPool,
+    &wine_vkDestroyDescriptorSetLayout,
+    &wine_vkDestroyDescriptorUpdateTemplate,
+    &wine_vkDestroyDescriptorUpdateTemplateKHR,
+    &wine_vkDestroyDevice,
+    &wine_vkDestroyEvent,
+    &wine_vkDestroyFence,
+    &wine_vkDestroyFramebuffer,
+    &wine_vkDestroyImage,
+    &wine_vkDestroyImageView,
+    &wine_vkDestroyIndirectCommandsLayoutNV,
+    &wine_vkDestroyInstance,
+    &wine_vkDestroyPipeline,
+    &wine_vkDestroyPipelineCache,
+    &wine_vkDestroyPipelineLayout,
+    &wine_vkDestroyPrivateDataSlotEXT,
+    &wine_vkDestroyQueryPool,
+    &wine_vkDestroyRenderPass,
+    &wine_vkDestroySampler,
+    &wine_vkDestroySamplerYcbcrConversion,
+    &wine_vkDestroySamplerYcbcrConversionKHR,
+    &wine_vkDestroySemaphore,
+    &wine_vkDestroyShaderModule,
+    &wine_vkDestroySurfaceKHR,
+    &wine_vkDestroySwapchainKHR,
+    &wine_vkDestroyValidationCacheEXT,
+    &wine_vkDeviceWaitIdle,
+    &wine_vkEndCommandBuffer,
+    &wine_vkEnumerateDeviceExtensionProperties,
+    &wine_vkEnumerateDeviceLayerProperties,
+    &wine_vkEnumerateInstanceExtensionProperties,
+    &wine_vkEnumerateInstanceVersion,
+    &wine_vkEnumeratePhysicalDeviceGroups,
+    &wine_vkEnumeratePhysicalDeviceGroupsKHR,
+    &wine_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
+    &wine_vkEnumeratePhysicalDevices,
+    &wine_vkFlushMappedMemoryRanges,
+    &wine_vkFreeCommandBuffers,
+    &wine_vkFreeDescriptorSets,
+    &wine_vkFreeMemory,
+    &wine_vkGetAccelerationStructureBuildSizesKHR,
+    &wine_vkGetAccelerationStructureDeviceAddressKHR,
+    &wine_vkGetAccelerationStructureHandleNV,
+    &wine_vkGetAccelerationStructureMemoryRequirementsNV,
+    &wine_vkGetBufferDeviceAddress,
+    &wine_vkGetBufferDeviceAddressEXT,
+    &wine_vkGetBufferDeviceAddressKHR,
+    &wine_vkGetBufferMemoryRequirements,
+    &wine_vkGetBufferMemoryRequirements2,
+    &wine_vkGetBufferMemoryRequirements2KHR,
+    &wine_vkGetBufferOpaqueCaptureAddress,
+    &wine_vkGetBufferOpaqueCaptureAddressKHR,
+    &wine_vkGetCalibratedTimestampsEXT,
+    &wine_vkGetDeferredOperationMaxConcurrencyKHR,
+    &wine_vkGetDeferredOperationResultKHR,
+    &wine_vkGetDescriptorSetLayoutSupport,
+    &wine_vkGetDescriptorSetLayoutSupportKHR,
+    &wine_vkGetDeviceAccelerationStructureCompatibilityKHR,
+    &wine_vkGetDeviceGroupPeerMemoryFeatures,
+    &wine_vkGetDeviceGroupPeerMemoryFeaturesKHR,
+    &wine_vkGetDeviceGroupPresentCapabilitiesKHR,
+    &wine_vkGetDeviceGroupSurfacePresentModesKHR,
+    &wine_vkGetDeviceMemoryCommitment,
+    &wine_vkGetDeviceMemoryOpaqueCaptureAddress,
+    &wine_vkGetDeviceMemoryOpaqueCaptureAddressKHR,
+    &wine_vkGetDeviceQueue,
+    &wine_vkGetDeviceQueue2,
+    &wine_vkGetEventStatus,
+    &wine_vkGetFenceStatus,
+    &wine_vkGetGeneratedCommandsMemoryRequirementsNV,
+    &wine_vkGetImageMemoryRequirements,
+    &wine_vkGetImageMemoryRequirements2,
+    &wine_vkGetImageMemoryRequirements2KHR,
+    &wine_vkGetImageSparseMemoryRequirements,
+    &wine_vkGetImageSparseMemoryRequirements2,
+    &wine_vkGetImageSparseMemoryRequirements2KHR,
+    &wine_vkGetImageSubresourceLayout,
+    &wine_vkGetMemoryHostPointerPropertiesEXT,
+    &wine_vkGetPerformanceParameterINTEL,
+    &wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
+    &wine_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
+    &wine_vkGetPhysicalDeviceExternalBufferProperties,
+    &wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR,
+    &wine_vkGetPhysicalDeviceExternalFenceProperties,
+    &wine_vkGetPhysicalDeviceExternalFencePropertiesKHR,
+    &wine_vkGetPhysicalDeviceExternalSemaphoreProperties,
+    &wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR,
+    &wine_vkGetPhysicalDeviceFeatures,
+    &wine_vkGetPhysicalDeviceFeatures2,
+    &wine_vkGetPhysicalDeviceFeatures2KHR,
+    &wine_vkGetPhysicalDeviceFormatProperties,
+    &wine_vkGetPhysicalDeviceFormatProperties2,
+    &wine_vkGetPhysicalDeviceFormatProperties2KHR,
+    &wine_vkGetPhysicalDeviceFragmentShadingRatesKHR,
+    &wine_vkGetPhysicalDeviceImageFormatProperties,
+    &wine_vkGetPhysicalDeviceImageFormatProperties2,
+    &wine_vkGetPhysicalDeviceImageFormatProperties2KHR,
+    &wine_vkGetPhysicalDeviceMemoryProperties,
+    &wine_vkGetPhysicalDeviceMemoryProperties2,
+    &wine_vkGetPhysicalDeviceMemoryProperties2KHR,
+    &wine_vkGetPhysicalDeviceMultisamplePropertiesEXT,
+    &wine_vkGetPhysicalDevicePresentRectanglesKHR,
+    &wine_vkGetPhysicalDeviceProperties,
+    &wine_vkGetPhysicalDeviceProperties2,
+    &wine_vkGetPhysicalDeviceProperties2KHR,
+    &wine_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
+    &wine_vkGetPhysicalDeviceQueueFamilyProperties,
+    &wine_vkGetPhysicalDeviceQueueFamilyProperties2,
+    &wine_vkGetPhysicalDeviceQueueFamilyProperties2KHR,
+    &wine_vkGetPhysicalDeviceSparseImageFormatProperties,
+    &wine_vkGetPhysicalDeviceSparseImageFormatProperties2,
+    &wine_vkGetPhysicalDeviceSparseImageFormatProperties2KHR,
+    &wine_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
+    &wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
+    &wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
+    &wine_vkGetPhysicalDeviceSurfaceFormats2KHR,
+    &wine_vkGetPhysicalDeviceSurfaceFormatsKHR,
+    &wine_vkGetPhysicalDeviceSurfacePresentModesKHR,
+    &wine_vkGetPhysicalDeviceSurfaceSupportKHR,
+    &wine_vkGetPhysicalDeviceToolPropertiesEXT,
+    &wine_vkGetPhysicalDeviceWin32PresentationSupportKHR,
+    &wine_vkGetPipelineCacheData,
+    &wine_vkGetPipelineExecutableInternalRepresentationsKHR,
+    &wine_vkGetPipelineExecutablePropertiesKHR,
+    &wine_vkGetPipelineExecutableStatisticsKHR,
+    &wine_vkGetPrivateDataEXT,
+    &wine_vkGetQueryPoolResults,
+    &wine_vkGetQueueCheckpointData2NV,
+    &wine_vkGetQueueCheckpointDataNV,
+    &wine_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
+    &wine_vkGetRayTracingShaderGroupHandlesKHR,
+    &wine_vkGetRayTracingShaderGroupHandlesNV,
+    &wine_vkGetRayTracingShaderGroupStackSizeKHR,
+    &wine_vkGetRenderAreaGranularity,
+    &wine_vkGetSemaphoreCounterValue,
+    &wine_vkGetSemaphoreCounterValueKHR,
+    &wine_vkGetShaderInfoAMD,
+    &wine_vkGetSwapchainImagesKHR,
+    &wine_vkGetValidationCacheDataEXT,
+    &wine_vkInitializePerformanceApiINTEL,
+    &wine_vkInvalidateMappedMemoryRanges,
+    &wine_vkMapMemory,
+    &wine_vkMergePipelineCaches,
+    &wine_vkMergeValidationCachesEXT,
+    &wine_vkQueueBeginDebugUtilsLabelEXT,
+    &wine_vkQueueBindSparse,
+    &wine_vkQueueEndDebugUtilsLabelEXT,
+    &wine_vkQueueInsertDebugUtilsLabelEXT,
+    &wine_vkQueuePresentKHR,
+    &wine_vkQueueSetPerformanceConfigurationINTEL,
+    &wine_vkQueueSubmit,
+    &wine_vkQueueSubmit2KHR,
+    &wine_vkQueueWaitIdle,
+    &wine_vkReleasePerformanceConfigurationINTEL,
+    &wine_vkReleaseProfilingLockKHR,
+    &wine_vkResetCommandBuffer,
+    &wine_vkResetCommandPool,
+    &wine_vkResetDescriptorPool,
+    &wine_vkResetEvent,
+    &wine_vkResetFences,
+    &wine_vkResetQueryPool,
+    &wine_vkResetQueryPoolEXT,
+    &wine_vkSetDebugUtilsObjectNameEXT,
+    &wine_vkSetDebugUtilsObjectTagEXT,
+    &wine_vkSetEvent,
+    &wine_vkSetPrivateDataEXT,
+    &wine_vkSignalSemaphore,
+    &wine_vkSignalSemaphoreKHR,
+    &wine_vkSubmitDebugUtilsMessageEXT,
+    &wine_vkTrimCommandPool,
+    &wine_vkTrimCommandPoolKHR,
+    &wine_vkUninitializePerformanceApiINTEL,
+    &wine_vkUnmapMemory,
+    &wine_vkUpdateDescriptorSetWithTemplate,
+    &wine_vkUpdateDescriptorSetWithTemplateKHR,
+    &wine_vkUpdateDescriptorSets,
+    &wine_vkWaitForFences,
+    &wine_vkWaitSemaphores,
+    &wine_vkWaitSemaphoresKHR,
+    &wine_vkWriteAccelerationStructuresPropertiesKHR,
 };
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index b85bb152d78..2b46486f30c 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -15,56 +15,56 @@
 #define WINE_VK_VERSION VK_API_VERSION_1_2
 
 /* Functions for which we have custom implementations outside of the thunks. */
-VkResult WINAPI unix_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers);
-void WINAPI unix_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
-VkResult WINAPI unix_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool);
-VkResult WINAPI unix_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
-VkResult WINAPI unix_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
-VkResult WINAPI unix_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
-VkResult WINAPI unix_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
-VkResult WINAPI unix_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) DECLSPEC_HIDDEN;
-void WINAPI unix_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage) DECLSPEC_HIDDEN;
-void WINAPI unix_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator);
-void WINAPI unix_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
-void WINAPI unix_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
-void WINAPI unix_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator);
-void WINAPI unix_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
-void WINAPI unix_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator);
-VkResult WINAPI unix_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
-VkResult WINAPI unix_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties);
-VkResult WINAPI unix_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
-VkResult WINAPI unix_vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties);
-VkResult WINAPI unix_vkEnumerateInstanceVersion(uint32_t *pApiVersion);
-VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties);
-VkResult WINAPI unix_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices);
-void WINAPI unix_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
-VkResult WINAPI unix_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) DECLSPEC_HIDDEN;
-PFN_vkVoidFunction WINAPI unix_vkGetDeviceProcAddr(VkDevice device, const char *pName);
-void WINAPI unix_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
-void WINAPI unix_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue);
-PFN_vkVoidFunction WINAPI unix_vkGetInstanceProcAddr(VkInstance instance, const char *pName);
-VkResult WINAPI unix_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) DECLSPEC_HIDDEN;
-void WINAPI unix_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties);
-void WINAPI unix_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) DECLSPEC_HIDDEN;
-void WINAPI unix_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties);
-void WINAPI unix_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) DECLSPEC_HIDDEN;
-void WINAPI unix_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties);
-void WINAPI unix_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties);
-VkResult WINAPI unix_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities);
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
-VkResult WINAPI unix_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats);
-void WINAPI unix_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence);
-VkResult WINAPI unix_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) DECLSPEC_HIDDEN;
-VkResult WINAPI unix_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) DECLSPEC_HIDDEN;
-void WINAPI unix_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers);
+void WINAPI wine_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+VkResult WINAPI wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool);
+VkResult WINAPI wine_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice);
+VkResult WINAPI wine_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance);
+VkResult WINAPI wine_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain);
+VkResult WINAPI wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface);
+VkResult WINAPI wine_vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo) DECLSPEC_HIDDEN;
+void WINAPI wine_vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage) DECLSPEC_HIDDEN;
+void WINAPI wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator);
+void WINAPI wine_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
+void WINAPI wine_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
+void WINAPI wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator);
+void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator);
+void WINAPI wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator);
+VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties);
+VkResult WINAPI wine_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties);
+VkResult WINAPI wine_vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties);
+VkResult WINAPI wine_vkEnumerateInstanceVersion(uint32_t *pApiVersion);
+VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties);
+VkResult WINAPI wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices);
+void WINAPI wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers);
+VkResult WINAPI wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) DECLSPEC_HIDDEN;
+PFN_vkVoidFunction WINAPI wine_vkGetDeviceProcAddr(VkDevice device, const char *pName);
+void WINAPI wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue);
+void WINAPI wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue);
+PFN_vkVoidFunction WINAPI wine_vkGetInstanceProcAddr(VkInstance instance, const char *pName);
+VkResult WINAPI wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) DECLSPEC_HIDDEN;
+void WINAPI wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties);
+void WINAPI wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) DECLSPEC_HIDDEN;
+void WINAPI wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties);
+void WINAPI wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) DECLSPEC_HIDDEN;
+void WINAPI wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties);
+void WINAPI wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties);
+VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities);
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities);
+VkResult WINAPI wine_vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats);
+void WINAPI wine_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t *pData) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence);
+VkResult WINAPI wine_vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo) DECLSPEC_HIDDEN;
+VkResult WINAPI wine_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) DECLSPEC_HIDDEN;
+void WINAPI wine_vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData) DECLSPEC_HIDDEN;
 
 /* Private thunks */
 VkResult thunk_vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) DECLSPEC_HIDDEN;
diff --git a/dlls/winevulkan/winevulkan.spec b/dlls/winevulkan/winevulkan.spec
index cad282b1978..3e55c99fdc0 100644
--- a/dlls/winevulkan/winevulkan.spec
+++ b/dlls/winevulkan/winevulkan.spec
@@ -8,212 +8,212 @@
 # SPDX-License-Identifier: Apache-2.0 OR MIT
 #
 
-@ stdcall -private vk_icdGetInstanceProcAddr(ptr str) wine_vk_icdGetInstanceProcAddr
-@ stdcall -private vk_icdGetPhysicalDeviceProcAddr(ptr str) wine_vk_icdGetPhysicalDeviceProcAddr
-@ stdcall -private vk_icdNegotiateLoaderICDInterfaceVersion(ptr) wine_vk_icdNegotiateLoaderICDInterfaceVersion
-@ stdcall -private wine_vkAcquireNextImage2KHR(ptr ptr ptr)
-@ stdcall -private wine_vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr)
-@ stdcall -private wine_vkAllocateCommandBuffers(ptr ptr ptr)
-@ stdcall -private wine_vkAllocateDescriptorSets(ptr ptr ptr)
-@ stdcall -private wine_vkAllocateMemory(ptr ptr ptr ptr)
-@ stdcall -private wine_vkBeginCommandBuffer(ptr ptr)
-@ stdcall -private wine_vkBindBufferMemory(ptr int64 int64 int64)
-@ stdcall -private wine_vkBindBufferMemory2(ptr long ptr)
-@ stdcall -private wine_vkBindImageMemory(ptr int64 int64 int64)
-@ stdcall -private wine_vkBindImageMemory2(ptr long ptr)
-@ stdcall -private wine_vkCmdBeginQuery(ptr int64 long long)
-@ stdcall -private wine_vkCmdBeginRenderPass(ptr ptr long)
-@ stdcall -private wine_vkCmdBeginRenderPass2(ptr ptr ptr)
-@ stdcall -private wine_vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr)
-@ stdcall -private wine_vkCmdBindIndexBuffer(ptr int64 int64 long)
-@ stdcall -private wine_vkCmdBindPipeline(ptr long int64)
-@ stdcall -private wine_vkCmdBindVertexBuffers(ptr long long ptr ptr)
-@ stdcall -private wine_vkCmdBlitImage(ptr int64 long int64 long long ptr long)
-@ stdcall -private wine_vkCmdClearAttachments(ptr long ptr long ptr)
-@ stdcall -private wine_vkCmdClearColorImage(ptr int64 long ptr long ptr)
-@ stdcall -private wine_vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr)
-@ stdcall -private wine_vkCmdCopyBuffer(ptr int64 int64 long ptr)
-@ stdcall -private wine_vkCmdCopyBufferToImage(ptr int64 int64 long long ptr)
-@ stdcall -private wine_vkCmdCopyImage(ptr int64 long int64 long long ptr)
-@ stdcall -private wine_vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr)
-@ stdcall -private wine_vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long)
-@ stdcall -private wine_vkCmdDispatch(ptr long long long)
-@ stdcall -private wine_vkCmdDispatchBase(ptr long long long long long long)
-@ stdcall -private wine_vkCmdDispatchIndirect(ptr int64 int64)
-@ stdcall -private wine_vkCmdDraw(ptr long long long long)
-@ stdcall -private wine_vkCmdDrawIndexed(ptr long long long long long)
-@ stdcall -private wine_vkCmdDrawIndexedIndirect(ptr int64 int64 long long)
-@ stdcall -private wine_vkCmdDrawIndexedIndirectCount(ptr int64 int64 int64 int64 long long)
-@ stdcall -private wine_vkCmdDrawIndirect(ptr int64 int64 long long)
-@ stdcall -private wine_vkCmdDrawIndirectCount(ptr int64 int64 int64 int64 long long)
-@ stdcall -private wine_vkCmdEndQuery(ptr int64 long)
-@ stdcall -private wine_vkCmdEndRenderPass(ptr)
-@ stdcall -private wine_vkCmdEndRenderPass2(ptr ptr)
-@ stdcall -private wine_vkCmdExecuteCommands(ptr long ptr)
-@ stdcall -private wine_vkCmdFillBuffer(ptr int64 int64 int64 long)
-@ stdcall -private wine_vkCmdNextSubpass(ptr long)
-@ stdcall -private wine_vkCmdNextSubpass2(ptr ptr ptr)
-@ stdcall -private wine_vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr)
-@ stdcall -private wine_vkCmdPushConstants(ptr int64 long long long ptr)
-@ stdcall -private wine_vkCmdResetEvent(ptr int64 long)
-@ stdcall -private wine_vkCmdResetQueryPool(ptr int64 long long)
-@ stdcall -private wine_vkCmdResolveImage(ptr int64 long int64 long long ptr)
-@ stdcall -private wine_vkCmdSetBlendConstants(ptr ptr)
-@ stdcall -private wine_vkCmdSetDepthBias(ptr float float float)
-@ stdcall -private wine_vkCmdSetDepthBounds(ptr float float)
-@ stdcall -private wine_vkCmdSetDeviceMask(ptr long)
-@ stdcall -private wine_vkCmdSetEvent(ptr int64 long)
-@ stdcall -private wine_vkCmdSetLineWidth(ptr float)
-@ stdcall -private wine_vkCmdSetScissor(ptr long long ptr)
-@ stdcall -private wine_vkCmdSetStencilCompareMask(ptr long long)
-@ stdcall -private wine_vkCmdSetStencilReference(ptr long long)
-@ stdcall -private wine_vkCmdSetStencilWriteMask(ptr long long)
-@ stdcall -private wine_vkCmdSetViewport(ptr long long ptr)
-@ stdcall -private wine_vkCmdUpdateBuffer(ptr int64 int64 int64 ptr)
-@ stdcall -private wine_vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr)
-@ stdcall -private wine_vkCmdWriteTimestamp(ptr long int64 long)
-@ stdcall -private wine_vkCreateBuffer(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateBufferView(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateCommandPool(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateComputePipelines(ptr int64 long ptr ptr ptr)
-@ stdcall -private wine_vkCreateDescriptorPool(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateDescriptorSetLayout(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateDevice(ptr ptr ptr ptr)
+@ stdcall -private vk_icdGetInstanceProcAddr(ptr str)
+@ stdcall -private vk_icdGetPhysicalDeviceProcAddr(ptr str)
+@ stdcall -private vk_icdNegotiateLoaderICDInterfaceVersion(ptr)
+@ stdcall vkAcquireNextImage2KHR(ptr ptr ptr)
+@ stdcall vkAcquireNextImageKHR(ptr int64 int64 int64 int64 ptr)
+@ stdcall vkAllocateCommandBuffers(ptr ptr ptr)
+@ stdcall vkAllocateDescriptorSets(ptr ptr ptr)
+@ stdcall vkAllocateMemory(ptr ptr ptr ptr)
+@ stdcall vkBeginCommandBuffer(ptr ptr)
+@ stdcall vkBindBufferMemory(ptr int64 int64 int64)
+@ stdcall vkBindBufferMemory2(ptr long ptr)
+@ stdcall vkBindImageMemory(ptr int64 int64 int64)
+@ stdcall vkBindImageMemory2(ptr long ptr)
+@ stdcall vkCmdBeginQuery(ptr int64 long long)
+@ stdcall vkCmdBeginRenderPass(ptr ptr long)
+@ stdcall vkCmdBeginRenderPass2(ptr ptr ptr)
+@ stdcall vkCmdBindDescriptorSets(ptr long int64 long long ptr long ptr)
+@ stdcall vkCmdBindIndexBuffer(ptr int64 int64 long)
+@ stdcall vkCmdBindPipeline(ptr long int64)
+@ stdcall vkCmdBindVertexBuffers(ptr long long ptr ptr)
+@ stdcall vkCmdBlitImage(ptr int64 long int64 long long ptr long)
+@ stdcall vkCmdClearAttachments(ptr long ptr long ptr)
+@ stdcall vkCmdClearColorImage(ptr int64 long ptr long ptr)
+@ stdcall vkCmdClearDepthStencilImage(ptr int64 long ptr long ptr)
+@ stdcall vkCmdCopyBuffer(ptr int64 int64 long ptr)
+@ stdcall vkCmdCopyBufferToImage(ptr int64 int64 long long ptr)
+@ stdcall vkCmdCopyImage(ptr int64 long int64 long long ptr)
+@ stdcall vkCmdCopyImageToBuffer(ptr int64 long int64 long ptr)
+@ stdcall vkCmdCopyQueryPoolResults(ptr int64 long long int64 int64 int64 long)
+@ stdcall vkCmdDispatch(ptr long long long)
+@ stdcall vkCmdDispatchBase(ptr long long long long long long)
+@ stdcall vkCmdDispatchIndirect(ptr int64 int64)
+@ stdcall vkCmdDraw(ptr long long long long)
+@ stdcall vkCmdDrawIndexed(ptr long long long long long)
+@ stdcall vkCmdDrawIndexedIndirect(ptr int64 int64 long long)
+@ stdcall vkCmdDrawIndexedIndirectCount(ptr int64 int64 int64 int64 long long)
+@ stdcall vkCmdDrawIndirect(ptr int64 int64 long long)
+@ stdcall vkCmdDrawIndirectCount(ptr int64 int64 int64 int64 long long)
+@ stdcall vkCmdEndQuery(ptr int64 long)
+@ stdcall vkCmdEndRenderPass(ptr)
+@ stdcall vkCmdEndRenderPass2(ptr ptr)
+@ stdcall vkCmdExecuteCommands(ptr long ptr)
+@ stdcall vkCmdFillBuffer(ptr int64 int64 int64 long)
+@ stdcall vkCmdNextSubpass(ptr long)
+@ stdcall vkCmdNextSubpass2(ptr ptr ptr)
+@ stdcall vkCmdPipelineBarrier(ptr long long long long ptr long ptr long ptr)
+@ stdcall vkCmdPushConstants(ptr int64 long long long ptr)
+@ stdcall vkCmdResetEvent(ptr int64 long)
+@ stdcall vkCmdResetQueryPool(ptr int64 long long)
+@ stdcall vkCmdResolveImage(ptr int64 long int64 long long ptr)
+@ stdcall vkCmdSetBlendConstants(ptr ptr)
+@ stdcall vkCmdSetDepthBias(ptr float float float)
+@ stdcall vkCmdSetDepthBounds(ptr float float)
+@ stdcall vkCmdSetDeviceMask(ptr long)
+@ stdcall vkCmdSetEvent(ptr int64 long)
+@ stdcall vkCmdSetLineWidth(ptr float)
+@ stdcall vkCmdSetScissor(ptr long long ptr)
+@ stdcall vkCmdSetStencilCompareMask(ptr long long)
+@ stdcall vkCmdSetStencilReference(ptr long long)
+@ stdcall vkCmdSetStencilWriteMask(ptr long long)
+@ stdcall vkCmdSetViewport(ptr long long ptr)
+@ stdcall vkCmdUpdateBuffer(ptr int64 int64 int64 ptr)
+@ stdcall vkCmdWaitEvents(ptr long ptr long long long ptr long ptr long ptr)
+@ stdcall vkCmdWriteTimestamp(ptr long int64 long)
+@ stdcall vkCreateBuffer(ptr ptr ptr ptr)
+@ stdcall vkCreateBufferView(ptr ptr ptr ptr)
+@ stdcall vkCreateCommandPool(ptr ptr ptr ptr)
+@ stdcall vkCreateComputePipelines(ptr int64 long ptr ptr ptr)
+@ stdcall vkCreateDescriptorPool(ptr ptr ptr ptr)
+@ stdcall vkCreateDescriptorSetLayout(ptr ptr ptr ptr)
+@ stdcall vkCreateDescriptorUpdateTemplate(ptr ptr ptr ptr)
+@ stdcall vkCreateDevice(ptr ptr ptr ptr)
 @ stub vkCreateDisplayModeKHR
 @ stub vkCreateDisplayPlaneSurfaceKHR
-@ stdcall -private wine_vkCreateEvent(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateFence(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateFramebuffer(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr)
-@ stdcall -private wine_vkCreateImage(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateImageView(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateInstance(ptr ptr ptr)
-@ stdcall -private wine_vkCreatePipelineCache(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreatePipelineLayout(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateQueryPool(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateRenderPass(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateRenderPass2(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateSampler(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateSemaphore(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateShaderModule(ptr ptr ptr ptr)
+@ stdcall vkCreateEvent(ptr ptr ptr ptr)
+@ stdcall vkCreateFence(ptr ptr ptr ptr)
+@ stdcall vkCreateFramebuffer(ptr ptr ptr ptr)
+@ stdcall vkCreateGraphicsPipelines(ptr int64 long ptr ptr ptr)
+@ stdcall vkCreateImage(ptr ptr ptr ptr)
+@ stdcall vkCreateImageView(ptr ptr ptr ptr)
+@ stdcall vkCreateInstance(ptr ptr ptr)
+@ stdcall vkCreatePipelineCache(ptr ptr ptr ptr)
+@ stdcall vkCreatePipelineLayout(ptr ptr ptr ptr)
+@ stdcall vkCreateQueryPool(ptr ptr ptr ptr)
+@ stdcall vkCreateRenderPass(ptr ptr ptr ptr)
+@ stdcall vkCreateRenderPass2(ptr ptr ptr ptr)
+@ stdcall vkCreateSampler(ptr ptr ptr ptr)
+@ stdcall vkCreateSamplerYcbcrConversion(ptr ptr ptr ptr)
+@ stdcall vkCreateSemaphore(ptr ptr ptr ptr)
+@ stdcall vkCreateShaderModule(ptr ptr ptr ptr)
 @ stub vkCreateSharedSwapchainsKHR
-@ stdcall -private wine_vkCreateSwapchainKHR(ptr ptr ptr ptr)
-@ stdcall -private wine_vkCreateWin32SurfaceKHR(ptr ptr ptr ptr)
-@ stdcall -private wine_vkDestroyBuffer(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyBufferView(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyCommandPool(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyDescriptorPool(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyDescriptorSetLayout(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyDescriptorUpdateTemplate(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyDevice(ptr ptr)
-@ stdcall -private wine_vkDestroyEvent(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyFence(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyFramebuffer(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyImage(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyImageView(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyInstance(ptr ptr)
-@ stdcall -private wine_vkDestroyPipeline(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyPipelineCache(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyPipelineLayout(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyQueryPool(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyRenderPass(ptr int64 ptr)
-@ stdcall -private wine_vkDestroySampler(ptr int64 ptr)
-@ stdcall -private wine_vkDestroySamplerYcbcrConversion(ptr int64 ptr)
-@ stdcall -private wine_vkDestroySemaphore(ptr int64 ptr)
-@ stdcall -private wine_vkDestroyShaderModule(ptr int64 ptr)
-@ stdcall -private wine_vkDestroySurfaceKHR(ptr int64 ptr)
-@ stdcall -private wine_vkDestroySwapchainKHR(ptr int64 ptr)
-@ stdcall -private wine_vkDeviceWaitIdle(ptr)
-@ stdcall -private wine_vkEndCommandBuffer(ptr)
-@ stdcall -private wine_vkEnumerateDeviceExtensionProperties(ptr str ptr ptr)
-@ stdcall -private wine_vkEnumerateDeviceLayerProperties(ptr ptr ptr)
-@ stdcall -private wine_vkEnumerateInstanceExtensionProperties(str ptr ptr)
-@ stdcall -private wine_vkEnumerateInstanceLayerProperties(ptr ptr)
-@ stdcall -private wine_vkEnumerateInstanceVersion(ptr)
-@ stdcall -private wine_vkEnumeratePhysicalDeviceGroups(ptr ptr ptr)
-@ stdcall -private wine_vkEnumeratePhysicalDevices(ptr ptr ptr)
-@ stdcall -private wine_vkFlushMappedMemoryRanges(ptr long ptr)
-@ stdcall -private wine_vkFreeCommandBuffers(ptr int64 long ptr)
-@ stdcall -private wine_vkFreeDescriptorSets(ptr int64 long ptr)
-@ stdcall -private wine_vkFreeMemory(ptr int64 ptr)
-@ stdcall -private wine_vkGetBufferDeviceAddress(ptr ptr)
-@ stdcall -private wine_vkGetBufferMemoryRequirements(ptr int64 ptr)
-@ stdcall -private wine_vkGetBufferMemoryRequirements2(ptr ptr ptr)
-@ stdcall -private wine_vkGetBufferOpaqueCaptureAddress(ptr ptr)
-@ stdcall -private wine_vkGetDescriptorSetLayoutSupport(ptr ptr ptr)
-@ stdcall -private wine_vkGetDeviceGroupPeerMemoryFeatures(ptr long long long ptr)
-@ stdcall -private wine_vkGetDeviceGroupPresentCapabilitiesKHR(ptr ptr)
-@ stdcall -private wine_vkGetDeviceGroupSurfacePresentModesKHR(ptr int64 ptr)
-@ stdcall -private wine_vkGetDeviceMemoryCommitment(ptr int64 ptr)
-@ stdcall -private wine_vkGetDeviceMemoryOpaqueCaptureAddress(ptr ptr)
-@ stdcall -private wine_vkGetDeviceProcAddr(ptr str)
-@ stdcall -private wine_vkGetDeviceQueue(ptr long long ptr)
-@ stdcall -private wine_vkGetDeviceQueue2(ptr ptr ptr)
+@ stdcall vkCreateSwapchainKHR(ptr ptr ptr ptr)
+@ stdcall vkCreateWin32SurfaceKHR(ptr ptr ptr ptr)
+@ stdcall vkDestroyBuffer(ptr int64 ptr)
+@ stdcall vkDestroyBufferView(ptr int64 ptr)
+@ stdcall vkDestroyCommandPool(ptr int64 ptr)
+@ stdcall vkDestroyDescriptorPool(ptr int64 ptr)
+@ stdcall vkDestroyDescriptorSetLayout(ptr int64 ptr)
+@ stdcall vkDestroyDescriptorUpdateTemplate(ptr int64 ptr)
+@ stdcall vkDestroyDevice(ptr ptr)
+@ stdcall vkDestroyEvent(ptr int64 ptr)
+@ stdcall vkDestroyFence(ptr int64 ptr)
+@ stdcall vkDestroyFramebuffer(ptr int64 ptr)
+@ stdcall vkDestroyImage(ptr int64 ptr)
+@ stdcall vkDestroyImageView(ptr int64 ptr)
+@ stdcall vkDestroyInstance(ptr ptr)
+@ stdcall vkDestroyPipeline(ptr int64 ptr)
+@ stdcall vkDestroyPipelineCache(ptr int64 ptr)
+@ stdcall vkDestroyPipelineLayout(ptr int64 ptr)
+@ stdcall vkDestroyQueryPool(ptr int64 ptr)
+@ stdcall vkDestroyRenderPass(ptr int64 ptr)
+@ stdcall vkDestroySampler(ptr int64 ptr)
+@ stdcall vkDestroySamplerYcbcrConversion(ptr int64 ptr)
+@ stdcall vkDestroySemaphore(ptr int64 ptr)
+@ stdcall vkDestroyShaderModule(ptr int64 ptr)
+@ stdcall vkDestroySurfaceKHR(ptr int64 ptr)
+@ stdcall vkDestroySwapchainKHR(ptr int64 ptr)
+@ stdcall vkDeviceWaitIdle(ptr)
+@ stdcall vkEndCommandBuffer(ptr)
+@ stdcall vkEnumerateDeviceExtensionProperties(ptr str ptr ptr)
+@ stdcall vkEnumerateDeviceLayerProperties(ptr ptr ptr)
+@ stdcall vkEnumerateInstanceExtensionProperties(str ptr ptr)
+@ stdcall vkEnumerateInstanceLayerProperties(ptr ptr)
+@ stdcall vkEnumerateInstanceVersion(ptr)
+@ stdcall vkEnumeratePhysicalDeviceGroups(ptr ptr ptr)
+@ stdcall vkEnumeratePhysicalDevices(ptr ptr ptr)
+@ stdcall vkFlushMappedMemoryRanges(ptr long ptr)
+@ stdcall vkFreeCommandBuffers(ptr int64 long ptr)
+@ stdcall vkFreeDescriptorSets(ptr int64 long ptr)
+@ stdcall vkFreeMemory(ptr int64 ptr)
+@ stdcall vkGetBufferDeviceAddress(ptr ptr)
+@ stdcall vkGetBufferMemoryRequirements(ptr int64 ptr)
+@ stdcall vkGetBufferMemoryRequirements2(ptr ptr ptr)
+@ stdcall vkGetBufferOpaqueCaptureAddress(ptr ptr)
+@ stdcall vkGetDescriptorSetLayoutSupport(ptr ptr ptr)
+@ stdcall vkGetDeviceGroupPeerMemoryFeatures(ptr long long long ptr)
+@ stdcall vkGetDeviceGroupPresentCapabilitiesKHR(ptr ptr)
+@ stdcall vkGetDeviceGroupSurfacePresentModesKHR(ptr int64 ptr)
+@ stdcall vkGetDeviceMemoryCommitment(ptr int64 ptr)
+@ stdcall vkGetDeviceMemoryOpaqueCaptureAddress(ptr ptr)
+@ stdcall vkGetDeviceProcAddr(ptr str)
+@ stdcall vkGetDeviceQueue(ptr long long ptr)
+@ stdcall vkGetDeviceQueue2(ptr ptr ptr)
 @ stub vkGetDisplayModePropertiesKHR
 @ stub vkGetDisplayPlaneCapabilitiesKHR
 @ stub vkGetDisplayPlaneSupportedDisplaysKHR
-@ stdcall -private wine_vkGetEventStatus(ptr int64)
-@ stdcall -private wine_vkGetFenceStatus(ptr int64)
-@ stdcall -private wine_vkGetImageMemoryRequirements(ptr int64 ptr)
-@ stdcall -private wine_vkGetImageMemoryRequirements2(ptr ptr ptr)
-@ stdcall -private wine_vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr)
-@ stdcall -private wine_vkGetImageSubresourceLayout(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetInstanceProcAddr(ptr str)
+@ stdcall vkGetEventStatus(ptr int64)
+@ stdcall vkGetFenceStatus(ptr int64)
+@ stdcall vkGetImageMemoryRequirements(ptr int64 ptr)
+@ stdcall vkGetImageMemoryRequirements2(ptr ptr ptr)
+@ stdcall vkGetImageSparseMemoryRequirements(ptr int64 ptr ptr)
+@ stdcall vkGetImageSparseMemoryRequirements2(ptr ptr ptr ptr)
+@ stdcall vkGetImageSubresourceLayout(ptr int64 ptr ptr)
+@ stdcall vkGetInstanceProcAddr(ptr str)
 @ stub vkGetPhysicalDeviceDisplayPlanePropertiesKHR
 @ stub vkGetPhysicalDeviceDisplayPropertiesKHR
-@ stdcall -private wine_vkGetPhysicalDeviceExternalBufferProperties(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceExternalFenceProperties(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceExternalSemaphoreProperties(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceFeatures(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceFeatures2(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceFormatProperties(ptr long ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceFormatProperties2(ptr long ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceMemoryProperties(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceMemoryProperties2(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDevicePresentRectanglesKHR(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceProperties(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceProperties2(ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfaceFormats2KHR(ptr ptr ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr)
-@ stdcall -private wine_vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long)
-@ stdcall -private wine_vkGetPipelineCacheData(ptr int64 ptr ptr)
-@ stdcall -private wine_vkGetQueryPoolResults(ptr int64 long long long ptr int64 long)
-@ stdcall -private wine_vkGetRenderAreaGranularity(ptr int64 ptr)
-@ stdcall -private wine_vkGetSemaphoreCounterValue(ptr int64 ptr)
-@ stdcall -private wine_vkGetSwapchainImagesKHR(ptr int64 ptr ptr)
-@ stdcall -private wine_vkInvalidateMappedMemoryRanges(ptr long ptr)
-@ stdcall -private wine_vkMapMemory(ptr int64 int64 int64 long ptr)
-@ stdcall -private wine_vkMergePipelineCaches(ptr int64 long ptr)
-@ stdcall -private wine_vkQueueBindSparse(ptr long ptr int64)
-@ stdcall -private wine_vkQueuePresentKHR(ptr ptr)
-@ stdcall -private wine_vkQueueSubmit(ptr long ptr int64)
-@ stdcall -private wine_vkQueueWaitIdle(ptr)
-@ stdcall -private wine_vkResetCommandBuffer(ptr long)
-@ stdcall -private wine_vkResetCommandPool(ptr int64 long)
-@ stdcall -private wine_vkResetDescriptorPool(ptr int64 long)
-@ stdcall -private wine_vkResetEvent(ptr int64)
-@ stdcall -private wine_vkResetFences(ptr long ptr)
-@ stdcall -private wine_vkResetQueryPool(ptr int64 long long)
-@ stdcall -private wine_vkSetEvent(ptr int64)
-@ stdcall -private wine_vkSignalSemaphore(ptr ptr)
-@ stdcall -private wine_vkTrimCommandPool(ptr int64 long)
-@ stdcall -private wine_vkUnmapMemory(ptr int64)
-@ stdcall -private wine_vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr)
-@ stdcall -private wine_vkUpdateDescriptorSets(ptr long ptr long ptr)
-@ stdcall -private wine_vkWaitForFences(ptr long ptr long int64)
-@ stdcall -private wine_vkWaitSemaphores(ptr ptr int64)
+@ stdcall vkGetPhysicalDeviceExternalBufferProperties(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceExternalFenceProperties(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceExternalSemaphoreProperties(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceFeatures(ptr ptr)
+@ stdcall vkGetPhysicalDeviceFeatures2(ptr ptr)
+@ stdcall vkGetPhysicalDeviceFormatProperties(ptr long ptr)
+@ stdcall vkGetPhysicalDeviceFormatProperties2(ptr long ptr)
+@ stdcall vkGetPhysicalDeviceImageFormatProperties(ptr long long long long long ptr)
+@ stdcall vkGetPhysicalDeviceImageFormatProperties2(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceMemoryProperties(ptr ptr)
+@ stdcall vkGetPhysicalDeviceMemoryProperties2(ptr ptr)
+@ stdcall vkGetPhysicalDevicePresentRectanglesKHR(ptr int64 ptr ptr)
+@ stdcall vkGetPhysicalDeviceProperties(ptr ptr)
+@ stdcall vkGetPhysicalDeviceProperties2(ptr ptr)
+@ stdcall vkGetPhysicalDeviceQueueFamilyProperties(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceQueueFamilyProperties2(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties(ptr long long long long long ptr ptr)
+@ stdcall vkGetPhysicalDeviceSparseImageFormatProperties2(ptr ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceSurfaceCapabilities2KHR(ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ptr int64 ptr)
+@ stdcall vkGetPhysicalDeviceSurfaceFormats2KHR(ptr ptr ptr ptr)
+@ stdcall vkGetPhysicalDeviceSurfaceFormatsKHR(ptr int64 ptr ptr)
+@ stdcall vkGetPhysicalDeviceSurfacePresentModesKHR(ptr int64 ptr ptr)
+@ stdcall vkGetPhysicalDeviceSurfaceSupportKHR(ptr long int64 ptr)
+@ stdcall vkGetPhysicalDeviceWin32PresentationSupportKHR(ptr long)
+@ stdcall vkGetPipelineCacheData(ptr int64 ptr ptr)
+@ stdcall vkGetQueryPoolResults(ptr int64 long long long ptr int64 long)
+@ stdcall vkGetRenderAreaGranularity(ptr int64 ptr)
+@ stdcall vkGetSemaphoreCounterValue(ptr int64 ptr)
+@ stdcall vkGetSwapchainImagesKHR(ptr int64 ptr ptr)
+@ stdcall vkInvalidateMappedMemoryRanges(ptr long ptr)
+@ stdcall vkMapMemory(ptr int64 int64 int64 long ptr)
+@ stdcall vkMergePipelineCaches(ptr int64 long ptr)
+@ stdcall vkQueueBindSparse(ptr long ptr int64)
+@ stdcall vkQueuePresentKHR(ptr ptr)
+@ stdcall vkQueueSubmit(ptr long ptr int64)
+@ stdcall vkQueueWaitIdle(ptr)
+@ stdcall vkResetCommandBuffer(ptr long)
+@ stdcall vkResetCommandPool(ptr int64 long)
+@ stdcall vkResetDescriptorPool(ptr int64 long)
+@ stdcall vkResetEvent(ptr int64)
+@ stdcall vkResetFences(ptr long ptr)
+@ stdcall vkResetQueryPool(ptr int64 long long)
+@ stdcall vkSetEvent(ptr int64)
+@ stdcall vkSignalSemaphore(ptr ptr)
+@ stdcall vkTrimCommandPool(ptr int64 long)
+@ stdcall vkUnmapMemory(ptr int64)
+@ stdcall vkUpdateDescriptorSetWithTemplate(ptr int64 int64 ptr)
+@ stdcall vkUpdateDescriptorSets(ptr long ptr long ptr)
+@ stdcall vkWaitForFences(ptr long ptr long int64)
+@ stdcall vkWaitSemaphores(ptr ptr int64)
 @ stdcall -private DllRegisterServer()
 @ stdcall -private DllUnregisterServer()