[PATCH 0/3] MR1763: winevulkan: Allow unix side thunks to tail call for performance critical functions.

[Rémi Bernon (＠rbernon)]

I believe this performs similarly, if not better, than how direct calls previously performed. It is possible to make things even better with tail calls on the PE side, but it is going to be a little bit harder, and I'll make another MR later.

FWIW except for vkoverhead benchmark, I still yet to see a real case scenario where it makes a difference, though I think this is straightforward enough.

CC @mbriar

[PATCH 1/3] winevulkan: Skip asserts for some critical functions.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/loader_thunks.c | 896 ++++++++------------------------
 dlls/winevulkan/make_vulkan     |  24 +-
 2 files changed, 245 insertions(+), 675 deletions(-)

diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index 694c65ff213..5ccf1df27e2 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -229,141 +229,116 @@ VkResult WINAPI vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR defe
 void WINAPI vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin)
 {
     struct vkCmdBeginConditionalRenderingEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pConditionalRenderingBegin = pConditionalRenderingBegin;
-    status = UNIX_CALL(vkCmdBeginConditionalRenderingEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginConditionalRenderingEXT, &params);
 }

void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     struct vkCmdBeginDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pLabelInfo = pLabelInfo;
-    status = UNIX_CALL(vkCmdBeginDebugUtilsLabelEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginDebugUtilsLabelEXT, &params);
 }

void WINAPI vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
 {
     struct vkCmdBeginQuery_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.query = query;
     params.flags = flags;
-    status = UNIX_CALL(vkCmdBeginQuery, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginQuery, &params);
 }

void WINAPI vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
 {
     struct vkCmdBeginQueryIndexedEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.query = query;
     params.flags = flags;
     params.index = index;
-    status = UNIX_CALL(vkCmdBeginQueryIndexedEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginQueryIndexedEXT, &params);
 }

void WINAPI vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, VkSubpassContents contents)
 {
     struct vkCmdBeginRenderPass_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRenderPassBegin = pRenderPassBegin;
     params.contents = contents;
-    status = UNIX_CALL(vkCmdBeginRenderPass, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginRenderPass, &params);
 }

void WINAPI vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
     struct vkCmdBeginRenderPass2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRenderPassBegin = pRenderPassBegin;
     params.pSubpassBeginInfo = pSubpassBeginInfo;
-    status = UNIX_CALL(vkCmdBeginRenderPass2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginRenderPass2, &params);
 }

void WINAPI vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin, const VkSubpassBeginInfo *pSubpassBeginInfo)
 {
     struct vkCmdBeginRenderPass2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRenderPassBegin = pRenderPassBegin;
     params.pSubpassBeginInfo = pSubpassBeginInfo;
-    status = UNIX_CALL(vkCmdBeginRenderPass2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginRenderPass2KHR, &params);
 }

void WINAPI vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
 {
     struct vkCmdBeginRendering_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRenderingInfo = pRenderingInfo;
-    status = UNIX_CALL(vkCmdBeginRendering, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginRendering, &params);
 }

void WINAPI vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfo *pRenderingInfo)
 {
     struct vkCmdBeginRenderingKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRenderingInfo = pRenderingInfo;
-    status = UNIX_CALL(vkCmdBeginRenderingKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginRenderingKHR, &params);
 }

void WINAPI vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     struct vkCmdBeginTransformFeedbackEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstCounterBuffer = firstCounterBuffer;
     params.counterBufferCount = counterBufferCount;
     params.pCounterBuffers = pCounterBuffers;
     params.pCounterBufferOffsets = pCounterBufferOffsets;
-    status = UNIX_CALL(vkCmdBeginTransformFeedbackEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBeginTransformFeedbackEXT, &params);
 }

void WINAPI vkCmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
 {
     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.layout = layout;
     params.set = set;
-    status = UNIX_CALL(vkCmdBindDescriptorBufferEmbeddedSamplersEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindDescriptorBufferEmbeddedSamplersEXT, &params);
 }

void WINAPI vkCmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT *pBindingInfos)
 {
     struct vkCmdBindDescriptorBuffersEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.bufferCount = bufferCount;
     params.pBindingInfos = pBindingInfos;
-    status = UNIX_CALL(vkCmdBindDescriptorBuffersEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindDescriptorBuffersEXT, &params);
 }

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)
 {
     struct vkCmdBindDescriptorSets_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.layout = layout;
@@ -372,98 +347,82 @@ void WINAPI vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBin
     params.pDescriptorSets = pDescriptorSets;
     params.dynamicOffsetCount = dynamicOffsetCount;
     params.pDynamicOffsets = pDynamicOffsets;
-    status = UNIX_CALL(vkCmdBindDescriptorSets, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindDescriptorSets, &params);
 }

void WINAPI vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     struct vkCmdBindIndexBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
     params.indexType = indexType;
-    status = UNIX_CALL(vkCmdBindIndexBuffer, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindIndexBuffer, &params);
 }

void WINAPI vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 {
     struct vkCmdBindInvocationMaskHUAWEI_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.imageView = imageView;
     params.imageLayout = imageLayout;
-    status = UNIX_CALL(vkCmdBindInvocationMaskHUAWEI, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindInvocationMaskHUAWEI, &params);
 }

void WINAPI vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
 {
     struct vkCmdBindPipeline_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.pipeline = pipeline;
-    status = UNIX_CALL(vkCmdBindPipeline, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindPipeline, &params);
 }

void WINAPI vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
 {
     struct vkCmdBindPipelineShaderGroupNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.pipeline = pipeline;
     params.groupIndex = groupIndex;
-    status = UNIX_CALL(vkCmdBindPipelineShaderGroupNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindPipelineShaderGroupNV, &params);
 }

void WINAPI vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
 {
     struct vkCmdBindShadingRateImageNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.imageView = imageView;
     params.imageLayout = imageLayout;
-    status = UNIX_CALL(vkCmdBindShadingRateImageNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindShadingRateImageNV, &params);
 }

void WINAPI vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes)
 {
     struct vkCmdBindTransformFeedbackBuffersEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstBinding = firstBinding;
     params.bindingCount = bindingCount;
     params.pBuffers = pBuffers;
     params.pOffsets = pOffsets;
     params.pSizes = pSizes;
-    status = UNIX_CALL(vkCmdBindTransformFeedbackBuffersEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindTransformFeedbackBuffersEXT, &params);
 }

void WINAPI vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets)
 {
     struct vkCmdBindVertexBuffers_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstBinding = firstBinding;
     params.bindingCount = bindingCount;
     params.pBuffers = pBuffers;
     params.pOffsets = pOffsets;
-    status = UNIX_CALL(vkCmdBindVertexBuffers, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindVertexBuffers, &params);
 }

void WINAPI vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 {
     struct vkCmdBindVertexBuffers2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstBinding = firstBinding;
     params.bindingCount = bindingCount;
@@ -471,14 +430,12 @@ void WINAPI vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firs
     params.pOffsets = pOffsets;
     params.pSizes = pSizes;
     params.pStrides = pStrides;
-    status = UNIX_CALL(vkCmdBindVertexBuffers2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindVertexBuffers2, &params);
 }

void WINAPI vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets, const VkDeviceSize *pSizes, const VkDeviceSize *pStrides)
 {
     struct vkCmdBindVertexBuffers2EXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstBinding = firstBinding;
     params.bindingCount = bindingCount;
@@ -486,14 +443,12 @@ void WINAPI vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t f
     params.pOffsets = pOffsets;
     params.pSizes = pSizes;
     params.pStrides = pStrides;
-    status = UNIX_CALL(vkCmdBindVertexBuffers2EXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBindVertexBuffers2EXT, &params);
 }

void WINAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter)
 {
     struct vkCmdBlitImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcImage = srcImage;
     params.srcImageLayout = srcImageLayout;
@@ -502,34 +457,28 @@ void WINAPI vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkIm
     params.regionCount = regionCount;
     params.pRegions = pRegions;
     params.filter = filter;
-    status = UNIX_CALL(vkCmdBlitImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBlitImage, &params);
 }

void WINAPI vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
 {
     struct vkCmdBlitImage2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pBlitImageInfo = pBlitImageInfo;
-    status = UNIX_CALL(vkCmdBlitImage2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBlitImage2, &params);
 }

void WINAPI vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2 *pBlitImageInfo)
 {
     struct vkCmdBlitImage2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pBlitImageInfo = pBlitImageInfo;
-    status = UNIX_CALL(vkCmdBlitImage2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBlitImage2KHR, &params);
 }

void WINAPI vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
 {
     struct vkCmdBuildAccelerationStructureNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
     params.instanceData = instanceData;
@@ -539,191 +488,159 @@ void WINAPI vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, con
     params.src = src;
     params.scratch = scratch;
     params.scratchOffset = scratchOffset;
-    status = UNIX_CALL(vkCmdBuildAccelerationStructureNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBuildAccelerationStructureNV, &params);
 }

void WINAPI vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkDeviceAddress *pIndirectDeviceAddresses, const uint32_t *pIndirectStrides, const uint32_t * const*ppMaxPrimitiveCounts)
 {
     struct vkCmdBuildAccelerationStructuresIndirectKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.infoCount = infoCount;
     params.pInfos = pInfos;
     params.pIndirectDeviceAddresses = pIndirectDeviceAddresses;
     params.pIndirectStrides = pIndirectStrides;
     params.ppMaxPrimitiveCounts = ppMaxPrimitiveCounts;
-    status = UNIX_CALL(vkCmdBuildAccelerationStructuresIndirectKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBuildAccelerationStructuresIndirectKHR, &params);
 }

void WINAPI vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
     struct vkCmdBuildAccelerationStructuresKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.infoCount = infoCount;
     params.pInfos = pInfos;
     params.ppBuildRangeInfos = ppBuildRangeInfos;
-    status = UNIX_CALL(vkCmdBuildAccelerationStructuresKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBuildAccelerationStructuresKHR, &params);
 }

void WINAPI vkCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
 {
     struct vkCmdBuildMicromapsEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.infoCount = infoCount;
     params.pInfos = pInfos;
-    status = UNIX_CALL(vkCmdBuildMicromapsEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdBuildMicromapsEXT, &params);
 }

void WINAPI vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment *pAttachments, uint32_t rectCount, const VkClearRect *pRects)
 {
     struct vkCmdClearAttachments_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.attachmentCount = attachmentCount;
     params.pAttachments = pAttachments;
     params.rectCount = rectCount;
     params.pRects = pRects;
-    status = UNIX_CALL(vkCmdClearAttachments, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdClearAttachments, &params);
 }

void WINAPI vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     struct vkCmdClearColorImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.image = image;
     params.imageLayout = imageLayout;
     params.pColor = pColor;
     params.rangeCount = rangeCount;
     params.pRanges = pRanges;
-    status = UNIX_CALL(vkCmdClearColorImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdClearColorImage, &params);
 }

void WINAPI vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
 {
     struct vkCmdClearDepthStencilImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.image = image;
     params.imageLayout = imageLayout;
     params.pDepthStencil = pDepthStencil;
     params.rangeCount = rangeCount;
     params.pRanges = pRanges;
-    status = UNIX_CALL(vkCmdClearDepthStencilImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdClearDepthStencilImage, &params);
 }

void WINAPI vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
     struct vkCmdCopyAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyAccelerationStructureKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyAccelerationStructureKHR, &params);
 }

void WINAPI vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
 {
     struct vkCmdCopyAccelerationStructureNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.dst = dst;
     params.src = src;
     params.mode = mode;
-    status = UNIX_CALL(vkCmdCopyAccelerationStructureNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyAccelerationStructureNV, &params);
 }

void WINAPI vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
     struct vkCmdCopyAccelerationStructureToMemoryKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyAccelerationStructureToMemoryKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyAccelerationStructureToMemoryKHR, &params);
 }

void WINAPI vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy *pRegions)
 {
     struct vkCmdCopyBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcBuffer = srcBuffer;
     params.dstBuffer = dstBuffer;
     params.regionCount = regionCount;
     params.pRegions = pRegions;
-    status = UNIX_CALL(vkCmdCopyBuffer, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBuffer, &params);
 }

void WINAPI vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
 {
     struct vkCmdCopyBuffer2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyBufferInfo = pCopyBufferInfo;
-    status = UNIX_CALL(vkCmdCopyBuffer2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBuffer2, &params);
 }

void WINAPI vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 *pCopyBufferInfo)
 {
     struct vkCmdCopyBuffer2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyBufferInfo = pCopyBufferInfo;
-    status = UNIX_CALL(vkCmdCopyBuffer2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBuffer2KHR, &params);
 }

void WINAPI vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
     struct vkCmdCopyBufferToImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcBuffer = srcBuffer;
     params.dstImage = dstImage;
     params.dstImageLayout = dstImageLayout;
     params.regionCount = regionCount;
     params.pRegions = pRegions;
-    status = UNIX_CALL(vkCmdCopyBufferToImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBufferToImage, &params);
 }

void WINAPI vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
 {
     struct vkCmdCopyBufferToImage2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyBufferToImageInfo = pCopyBufferToImageInfo;
-    status = UNIX_CALL(vkCmdCopyBufferToImage2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBufferToImage2, &params);
 }

void WINAPI vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 *pCopyBufferToImageInfo)
 {
     struct vkCmdCopyBufferToImage2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyBufferToImageInfo = pCopyBufferToImageInfo;
-    status = UNIX_CALL(vkCmdCopyBufferToImage2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyBufferToImage2KHR, &params);
 }

void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy *pRegions)
 {
     struct vkCmdCopyImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcImage = srcImage;
     params.srcImageLayout = srcImageLayout;
@@ -731,90 +648,74 @@ void WINAPI vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkIm
     params.dstImageLayout = dstImageLayout;
     params.regionCount = regionCount;
     params.pRegions = pRegions;
-    status = UNIX_CALL(vkCmdCopyImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImage, &params);
 }

void WINAPI vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
 {
     struct vkCmdCopyImage2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyImageInfo = pCopyImageInfo;
-    status = UNIX_CALL(vkCmdCopyImage2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImage2, &params);
 }

void WINAPI vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2 *pCopyImageInfo)
 {
     struct vkCmdCopyImage2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyImageInfo = pCopyImageInfo;
-    status = UNIX_CALL(vkCmdCopyImage2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImage2KHR, &params);
 }

void WINAPI vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions)
 {
     struct vkCmdCopyImageToBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcImage = srcImage;
     params.srcImageLayout = srcImageLayout;
     params.dstBuffer = dstBuffer;
     params.regionCount = regionCount;
     params.pRegions = pRegions;
-    status = UNIX_CALL(vkCmdCopyImageToBuffer, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImageToBuffer, &params);
 }

void WINAPI vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
 {
     struct vkCmdCopyImageToBuffer2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyImageToBufferInfo = pCopyImageToBufferInfo;
-    status = UNIX_CALL(vkCmdCopyImageToBuffer2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImageToBuffer2, &params);
 }

void WINAPI vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 *pCopyImageToBufferInfo)
 {
     struct vkCmdCopyImageToBuffer2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCopyImageToBufferInfo = pCopyImageToBufferInfo;
-    status = UNIX_CALL(vkCmdCopyImageToBuffer2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyImageToBuffer2KHR, &params);
 }

void WINAPI vkCmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
 {
     struct vkCmdCopyMemoryIndirectNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.copyBufferAddress = copyBufferAddress;
     params.copyCount = copyCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdCopyMemoryIndirectNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMemoryIndirectNV, &params);
 }

void WINAPI vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
     struct vkCmdCopyMemoryToAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyMemoryToAccelerationStructureKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMemoryToAccelerationStructureKHR, &params);
 }

void WINAPI vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers *pImageSubresources)
 {
     struct vkCmdCopyMemoryToImageIndirectNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.copyBufferAddress = copyBufferAddress;
     params.copyCount = copyCount;
@@ -822,44 +723,36 @@ void WINAPI vkCmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDe
     params.dstImage = dstImage;
     params.dstImageLayout = dstImageLayout;
     params.pImageSubresources = pImageSubresources;
-    status = UNIX_CALL(vkCmdCopyMemoryToImageIndirectNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMemoryToImageIndirectNV, &params);
 }

void WINAPI vkCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT *pInfo)
 {
     struct vkCmdCopyMemoryToMicromapEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyMemoryToMicromapEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMemoryToMicromapEXT, &params);
 }

void WINAPI vkCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT *pInfo)
 {
     struct vkCmdCopyMicromapEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyMicromapEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMicromapEXT, &params);
 }

void WINAPI vkCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT *pInfo)
 {
     struct vkCmdCopyMicromapToMemoryEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCmdCopyMicromapToMemoryEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyMicromapToMemoryEXT, &params);
 }

void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     struct vkCmdCopyQueryPoolResults_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
@@ -868,88 +761,72 @@ void WINAPI vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool
     params.dstOffset = dstOffset;
     params.stride = stride;
     params.flags = flags;
-    status = UNIX_CALL(vkCmdCopyQueryPoolResults, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCopyQueryPoolResults, &params);
 }

void WINAPI vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX *pLaunchInfo)
 {
     struct vkCmdCuLaunchKernelNVX_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pLaunchInfo = pLaunchInfo;
-    status = UNIX_CALL(vkCmdCuLaunchKernelNVX, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdCuLaunchKernelNVX, &params);
 }

void WINAPI vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     struct vkCmdDebugMarkerBeginEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    status = UNIX_CALL(vkCmdDebugMarkerBeginEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDebugMarkerBeginEXT, &params);
 }

void WINAPI vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
 {
     struct vkCmdDebugMarkerEndEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdDebugMarkerEndEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDebugMarkerEndEXT, &params);
 }

void WINAPI vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT *pMarkerInfo)
 {
     struct vkCmdDebugMarkerInsertEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    status = UNIX_CALL(vkCmdDebugMarkerInsertEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDebugMarkerInsertEXT, &params);
 }

void WINAPI vkCmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
 {
     struct vkCmdDecompressMemoryIndirectCountNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.indirectCommandsAddress = indirectCommandsAddress;
     params.indirectCommandsCountAddress = indirectCommandsCountAddress;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDecompressMemoryIndirectCountNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDecompressMemoryIndirectCountNV, &params);
 }

void WINAPI vkCmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV *pDecompressMemoryRegions)
 {
     struct vkCmdDecompressMemoryNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.decompressRegionCount = decompressRegionCount;
     params.pDecompressMemoryRegions = pDecompressMemoryRegions;
-    status = UNIX_CALL(vkCmdDecompressMemoryNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDecompressMemoryNV, &params);
 }

void WINAPI vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     struct vkCmdDispatch_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.groupCountX = groupCountX;
     params.groupCountY = groupCountY;
     params.groupCountZ = groupCountZ;
-    status = UNIX_CALL(vkCmdDispatch, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDispatch, &params);
 }

void WINAPI vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     struct vkCmdDispatchBase_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.baseGroupX = baseGroupX;
     params.baseGroupY = baseGroupY;
@@ -957,14 +834,12 @@ void WINAPI vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX
     params.groupCountX = groupCountX;
     params.groupCountY = groupCountY;
     params.groupCountZ = groupCountZ;
-    status = UNIX_CALL(vkCmdDispatchBase, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDispatchBase, &params);
 }

void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     struct vkCmdDispatchBaseKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.baseGroupX = baseGroupX;
     params.baseGroupY = baseGroupY;
@@ -972,65 +847,55 @@ void WINAPI vkCmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGro
     params.groupCountX = groupCountX;
     params.groupCountY = groupCountY;
     params.groupCountZ = groupCountZ;
-    status = UNIX_CALL(vkCmdDispatchBaseKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDispatchBaseKHR, &params);
 }

void WINAPI vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
 {
     struct vkCmdDispatchIndirect_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
-    status = UNIX_CALL(vkCmdDispatchIndirect, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDispatchIndirect, &params);
 }

void WINAPI vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
 {
     struct vkCmdDraw_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.vertexCount = vertexCount;
     params.instanceCount = instanceCount;
     params.firstVertex = firstVertex;
     params.firstInstance = firstInstance;
-    status = UNIX_CALL(vkCmdDraw, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDraw, &params);
 }

void WINAPI vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
 {
     struct vkCmdDrawIndexed_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.indexCount = indexCount;
     params.instanceCount = instanceCount;
     params.firstIndex = firstIndex;
     params.vertexOffset = vertexOffset;
     params.firstInstance = firstInstance;
-    status = UNIX_CALL(vkCmdDrawIndexed, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndexed, &params);
 }

void WINAPI vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     struct vkCmdDrawIndexedIndirect_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
     params.drawCount = drawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndexedIndirect, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndexedIndirect, &params);
 }

void WINAPI vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndexedIndirectCount_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1038,14 +903,12 @@ void WINAPI vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffe
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndexedIndirectCount, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndexedIndirectCount, &params);
 }

void WINAPI vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndexedIndirectCountAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1053,14 +916,12 @@ void WINAPI vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBu
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndexedIndirectCountAMD, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndexedIndirectCountAMD, &params);
 }

void WINAPI vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndexedIndirectCountKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1068,27 +929,23 @@ void WINAPI vkCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBu
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndexedIndirectCountKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndexedIndirectCountKHR, &params);
 }

void WINAPI vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     struct vkCmdDrawIndirect_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
     params.drawCount = drawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndirect, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndirect, &params);
 }

void WINAPI vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
 {
     struct vkCmdDrawIndirectByteCountEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.instanceCount = instanceCount;
     params.firstInstance = firstInstance;
@@ -1096,14 +953,12 @@ void WINAPI vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_
     params.counterBufferOffset = counterBufferOffset;
     params.counterOffset = counterOffset;
     params.vertexStride = vertexStride;
-    status = UNIX_CALL(vkCmdDrawIndirectByteCountEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndirectByteCountEXT, &params);
 }

void WINAPI vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndirectCount_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1111,14 +966,12 @@ void WINAPI vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffe
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndirectCount, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndirectCount, &params);
 }

void WINAPI vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndirectCountAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1126,14 +979,12 @@ void WINAPI vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer bu
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndirectCountAMD, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndirectCountAMD, &params);
 }

void WINAPI vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawIndirectCountKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1141,26 +992,22 @@ void WINAPI vkCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer bu
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawIndirectCountKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawIndirectCountKHR, &params);
 }

void WINAPI vkCmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
 {
     struct vkCmdDrawMeshTasksEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.groupCountX = groupCountX;
     params.groupCountY = groupCountY;
     params.groupCountZ = groupCountZ;
-    status = UNIX_CALL(vkCmdDrawMeshTasksEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksEXT, &params);
 }

void WINAPI vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawMeshTasksIndirectCountEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1168,14 +1015,12 @@ void WINAPI vkCmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, Vk
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawMeshTasksIndirectCountEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksIndirectCountEXT, &params);
 }

void WINAPI vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
 {
     struct vkCmdDrawMeshTasksIndirectCountNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
@@ -1183,65 +1028,55 @@ void WINAPI vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkB
     params.countBufferOffset = countBufferOffset;
     params.maxDrawCount = maxDrawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawMeshTasksIndirectCountNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksIndirectCountNV, &params);
 }

void WINAPI vkCmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     struct vkCmdDrawMeshTasksIndirectEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
     params.drawCount = drawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawMeshTasksIndirectEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksIndirectEXT, &params);
 }

void WINAPI vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     struct vkCmdDrawMeshTasksIndirectNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.buffer = buffer;
     params.offset = offset;
     params.drawCount = drawCount;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawMeshTasksIndirectNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksIndirectNV, &params);
 }

void WINAPI vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
 {
     struct vkCmdDrawMeshTasksNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.taskCount = taskCount;
     params.firstTask = firstTask;
-    status = UNIX_CALL(vkCmdDrawMeshTasksNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMeshTasksNV, &params);
 }

void WINAPI vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT *pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
 {
     struct vkCmdDrawMultiEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.drawCount = drawCount;
     params.pVertexInfo = pVertexInfo;
     params.instanceCount = instanceCount;
     params.firstInstance = firstInstance;
     params.stride = stride;
-    status = UNIX_CALL(vkCmdDrawMultiEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMultiEXT, &params);
 }

void WINAPI vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT *pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t *pVertexOffset)
 {
     struct vkCmdDrawMultiIndexedEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.drawCount = drawCount;
     params.pIndexInfo = pIndexInfo;
@@ -1249,203 +1084,165 @@ void WINAPI vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t dra
     params.firstInstance = firstInstance;
     params.stride = stride;
     params.pVertexOffset = pVertexOffset;
-    status = UNIX_CALL(vkCmdDrawMultiIndexedEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdDrawMultiIndexedEXT, &params);
 }

void WINAPI vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
 {
     struct vkCmdEndConditionalRenderingEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdEndConditionalRenderingEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndConditionalRenderingEXT, &params);
 }

void WINAPI vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
 {
     struct vkCmdEndDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdEndDebugUtilsLabelEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndDebugUtilsLabelEXT, &params);
 }

void WINAPI vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
 {
     struct vkCmdEndQuery_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.query = query;
-    status = UNIX_CALL(vkCmdEndQuery, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndQuery, &params);
 }

void WINAPI vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
 {
     struct vkCmdEndQueryIndexedEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.query = query;
     params.index = index;
-    status = UNIX_CALL(vkCmdEndQueryIndexedEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndQueryIndexedEXT, &params);
 }

void WINAPI vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
 {
     struct vkCmdEndRenderPass_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdEndRenderPass, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndRenderPass, &params);
 }

void WINAPI vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     struct vkCmdEndRenderPass2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pSubpassEndInfo = pSubpassEndInfo;
-    status = UNIX_CALL(vkCmdEndRenderPass2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndRenderPass2, &params);
 }

void WINAPI vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     struct vkCmdEndRenderPass2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pSubpassEndInfo = pSubpassEndInfo;
-    status = UNIX_CALL(vkCmdEndRenderPass2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndRenderPass2KHR, &params);
 }

void WINAPI vkCmdEndRendering(VkCommandBuffer commandBuffer)
 {
     struct vkCmdEndRendering_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdEndRendering, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndRendering, &params);
 }

void WINAPI vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer)
 {
     struct vkCmdEndRenderingKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdEndRenderingKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndRenderingKHR, &params);
 }

void WINAPI vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer *pCounterBuffers, const VkDeviceSize *pCounterBufferOffsets)
 {
     struct vkCmdEndTransformFeedbackEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstCounterBuffer = firstCounterBuffer;
     params.counterBufferCount = counterBufferCount;
     params.pCounterBuffers = pCounterBuffers;
     params.pCounterBufferOffsets = pCounterBufferOffsets;
-    status = UNIX_CALL(vkCmdEndTransformFeedbackEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdEndTransformFeedbackEXT, &params);
 }

void WINAPI vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
 {
     struct vkCmdExecuteCommands_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.commandBufferCount = commandBufferCount;
     params.pCommandBuffers = pCommandBuffers;
-    status = UNIX_CALL(vkCmdExecuteCommands, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdExecuteCommands, &params);
 }

void WINAPI vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     struct vkCmdExecuteGeneratedCommandsNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.isPreprocessed = isPreprocessed;
     params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
-    status = UNIX_CALL(vkCmdExecuteGeneratedCommandsNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdExecuteGeneratedCommandsNV, &params);
 }

void WINAPI vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
 {
     struct vkCmdFillBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.dstBuffer = dstBuffer;
     params.dstOffset = dstOffset;
     params.size = size;
     params.data = data;
-    status = UNIX_CALL(vkCmdFillBuffer, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdFillBuffer, &params);
 }

void WINAPI vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     struct vkCmdInsertDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pLabelInfo = pLabelInfo;
-    status = UNIX_CALL(vkCmdInsertDebugUtilsLabelEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdInsertDebugUtilsLabelEXT, &params);
 }

void WINAPI vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
 {
     struct vkCmdNextSubpass_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.contents = contents;
-    status = UNIX_CALL(vkCmdNextSubpass, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdNextSubpass, &params);
 }

void WINAPI vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     struct vkCmdNextSubpass2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pSubpassBeginInfo = pSubpassBeginInfo;
     params.pSubpassEndInfo = pSubpassEndInfo;
-    status = UNIX_CALL(vkCmdNextSubpass2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdNextSubpass2, &params);
 }

void WINAPI vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo *pSubpassBeginInfo, const VkSubpassEndInfo *pSubpassEndInfo)
 {
     struct vkCmdNextSubpass2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pSubpassBeginInfo = pSubpassBeginInfo;
     params.pSubpassEndInfo = pSubpassEndInfo;
-    status = UNIX_CALL(vkCmdNextSubpass2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdNextSubpass2KHR, &params);
 }

void WINAPI vkCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV *pExecuteInfo)
 {
     struct vkCmdOpticalFlowExecuteNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.session = session;
     params.pExecuteInfo = pExecuteInfo;
-    status = UNIX_CALL(vkCmdOpticalFlowExecuteNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdOpticalFlowExecuteNV, &params);
 }

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)
 {
     struct vkCmdPipelineBarrier_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcStageMask = srcStageMask;
     params.dstStageMask = dstStageMask;
@@ -1456,130 +1253,108 @@ void WINAPI vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageF
     params.pBufferMemoryBarriers = pBufferMemoryBarriers;
     params.imageMemoryBarrierCount = imageMemoryBarrierCount;
     params.pImageMemoryBarriers = pImageMemoryBarriers;
-    status = UNIX_CALL(vkCmdPipelineBarrier, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPipelineBarrier, &params);
 }

void WINAPI vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
 {
     struct vkCmdPipelineBarrier2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pDependencyInfo = pDependencyInfo;
-    status = UNIX_CALL(vkCmdPipelineBarrier2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPipelineBarrier2, &params);
 }

void WINAPI vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfo *pDependencyInfo)
 {
     struct vkCmdPipelineBarrier2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pDependencyInfo = pDependencyInfo;
-    status = UNIX_CALL(vkCmdPipelineBarrier2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPipelineBarrier2KHR, &params);
 }

void WINAPI vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV *pGeneratedCommandsInfo)
 {
     struct vkCmdPreprocessGeneratedCommandsNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pGeneratedCommandsInfo = pGeneratedCommandsInfo;
-    status = UNIX_CALL(vkCmdPreprocessGeneratedCommandsNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPreprocessGeneratedCommandsNV, &params);
 }

void WINAPI vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void *pValues)
 {
     struct vkCmdPushConstants_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.layout = layout;
     params.stageFlags = stageFlags;
     params.offset = offset;
     params.size = size;
     params.pValues = pValues;
-    status = UNIX_CALL(vkCmdPushConstants, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPushConstants, &params);
 }

void WINAPI vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites)
 {
     struct vkCmdPushDescriptorSetKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.layout = layout;
     params.set = set;
     params.descriptorWriteCount = descriptorWriteCount;
     params.pDescriptorWrites = pDescriptorWrites;
-    status = UNIX_CALL(vkCmdPushDescriptorSetKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPushDescriptorSetKHR, &params);
 }

void WINAPI vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void *pData)
 {
     struct vkCmdPushDescriptorSetWithTemplateKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
     params.layout = layout;
     params.set = set;
     params.pData = pData;
-    status = UNIX_CALL(vkCmdPushDescriptorSetWithTemplateKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdPushDescriptorSetWithTemplateKHR, &params);
 }

void WINAPI vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     struct vkCmdResetEvent_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.stageMask = stageMask;
-    status = UNIX_CALL(vkCmdResetEvent, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResetEvent, &params);
 }

void WINAPI vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
 {
     struct vkCmdResetEvent2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.stageMask = stageMask;
-    status = UNIX_CALL(vkCmdResetEvent2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResetEvent2, &params);
 }

void WINAPI vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
 {
     struct vkCmdResetEvent2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.stageMask = stageMask;
-    status = UNIX_CALL(vkCmdResetEvent2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResetEvent2KHR, &params);
 }

void WINAPI vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     struct vkCmdResetQueryPool_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
     params.queryCount = queryCount;
-    status = UNIX_CALL(vkCmdResetQueryPool, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResetQueryPool, &params);
 }

void WINAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions)
 {
     struct vkCmdResolveImage_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.srcImage = srcImage;
     params.srcImageLayout = srcImageLayout;
@@ -1587,389 +1362,315 @@ void WINAPI vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, V
     params.dstImageLayout = dstImageLayout;
     params.regionCount = regionCount;
     params.pRegions = pRegions;
-    status = UNIX_CALL(vkCmdResolveImage, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResolveImage, &params);
 }

void WINAPI vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
 {
     struct vkCmdResolveImage2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pResolveImageInfo = pResolveImageInfo;
-    status = UNIX_CALL(vkCmdResolveImage2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResolveImage2, &params);
 }

void WINAPI vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2 *pResolveImageInfo)
 {
     struct vkCmdResolveImage2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pResolveImageInfo = pResolveImageInfo;
-    status = UNIX_CALL(vkCmdResolveImage2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdResolveImage2KHR, &params);
 }

void WINAPI vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
 {
     struct vkCmdSetAlphaToCoverageEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.alphaToCoverageEnable = alphaToCoverageEnable;
-    status = UNIX_CALL(vkCmdSetAlphaToCoverageEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetAlphaToCoverageEnableEXT, &params);
 }

void WINAPI vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
 {
     struct vkCmdSetAlphaToOneEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.alphaToOneEnable = alphaToOneEnable;
-    status = UNIX_CALL(vkCmdSetAlphaToOneEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetAlphaToOneEnableEXT, &params);
 }

void WINAPI vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
 {
     struct vkCmdSetBlendConstants_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.blendConstants = blendConstants;
-    status = UNIX_CALL(vkCmdSetBlendConstants, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetBlendConstants, &params);
 }

void WINAPI vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void *pCheckpointMarker)
 {
     struct vkCmdSetCheckpointNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pCheckpointMarker = pCheckpointMarker;
-    status = UNIX_CALL(vkCmdSetCheckpointNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCheckpointNV, &params);
 }

void WINAPI vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV *pCustomSampleOrders)
 {
     struct vkCmdSetCoarseSampleOrderNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.sampleOrderType = sampleOrderType;
     params.customSampleOrderCount = customSampleOrderCount;
     params.pCustomSampleOrders = pCustomSampleOrders;
-    status = UNIX_CALL(vkCmdSetCoarseSampleOrderNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoarseSampleOrderNV, &params);
 }

void WINAPI vkCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT *pColorBlendAdvanced)
 {
     struct vkCmdSetColorBlendAdvancedEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstAttachment = firstAttachment;
     params.attachmentCount = attachmentCount;
     params.pColorBlendAdvanced = pColorBlendAdvanced;
-    status = UNIX_CALL(vkCmdSetColorBlendAdvancedEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetColorBlendAdvancedEXT, &params);
 }

void WINAPI vkCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32 *pColorBlendEnables)
 {
     struct vkCmdSetColorBlendEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstAttachment = firstAttachment;
     params.attachmentCount = attachmentCount;
     params.pColorBlendEnables = pColorBlendEnables;
-    status = UNIX_CALL(vkCmdSetColorBlendEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetColorBlendEnableEXT, &params);
 }

void WINAPI vkCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT *pColorBlendEquations)
 {
     struct vkCmdSetColorBlendEquationEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstAttachment = firstAttachment;
     params.attachmentCount = attachmentCount;
     params.pColorBlendEquations = pColorBlendEquations;
-    status = UNIX_CALL(vkCmdSetColorBlendEquationEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetColorBlendEquationEXT, &params);
 }

void WINAPI vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 *pColorWriteEnables)
 {
     struct vkCmdSetColorWriteEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.attachmentCount = attachmentCount;
     params.pColorWriteEnables = pColorWriteEnables;
-    status = UNIX_CALL(vkCmdSetColorWriteEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetColorWriteEnableEXT, &params);
 }

void WINAPI vkCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags *pColorWriteMasks)
 {
     struct vkCmdSetColorWriteMaskEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstAttachment = firstAttachment;
     params.attachmentCount = attachmentCount;
     params.pColorWriteMasks = pColorWriteMasks;
-    status = UNIX_CALL(vkCmdSetColorWriteMaskEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetColorWriteMaskEXT, &params);
 }

void WINAPI vkCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
 {
     struct vkCmdSetConservativeRasterizationModeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.conservativeRasterizationMode = conservativeRasterizationMode;
-    status = UNIX_CALL(vkCmdSetConservativeRasterizationModeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetConservativeRasterizationModeEXT, &params);
 }

void WINAPI vkCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
 {
     struct vkCmdSetCoverageModulationModeNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageModulationMode = coverageModulationMode;
-    status = UNIX_CALL(vkCmdSetCoverageModulationModeNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageModulationModeNV, &params);
 }

void WINAPI vkCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
 {
     struct vkCmdSetCoverageModulationTableEnableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageModulationTableEnable = coverageModulationTableEnable;
-    status = UNIX_CALL(vkCmdSetCoverageModulationTableEnableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageModulationTableEnableNV, &params);
 }

void WINAPI vkCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float *pCoverageModulationTable)
 {
     struct vkCmdSetCoverageModulationTableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageModulationTableCount = coverageModulationTableCount;
     params.pCoverageModulationTable = pCoverageModulationTable;
-    status = UNIX_CALL(vkCmdSetCoverageModulationTableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageModulationTableNV, &params);
 }

void WINAPI vkCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
 {
     struct vkCmdSetCoverageReductionModeNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageReductionMode = coverageReductionMode;
-    status = UNIX_CALL(vkCmdSetCoverageReductionModeNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageReductionModeNV, &params);
 }

void WINAPI vkCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
 {
     struct vkCmdSetCoverageToColorEnableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageToColorEnable = coverageToColorEnable;
-    status = UNIX_CALL(vkCmdSetCoverageToColorEnableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageToColorEnableNV, &params);
 }

void WINAPI vkCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
 {
     struct vkCmdSetCoverageToColorLocationNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.coverageToColorLocation = coverageToColorLocation;
-    status = UNIX_CALL(vkCmdSetCoverageToColorLocationNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCoverageToColorLocationNV, &params);
 }

void WINAPI vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 {
     struct vkCmdSetCullMode_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.cullMode = cullMode;
-    status = UNIX_CALL(vkCmdSetCullMode, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCullMode, &params);
 }

void WINAPI vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
 {
     struct vkCmdSetCullModeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.cullMode = cullMode;
-    status = UNIX_CALL(vkCmdSetCullModeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetCullModeEXT, &params);
 }

void WINAPI vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
 {
     struct vkCmdSetDepthBias_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthBiasConstantFactor = depthBiasConstantFactor;
     params.depthBiasClamp = depthBiasClamp;
     params.depthBiasSlopeFactor = depthBiasSlopeFactor;
-    status = UNIX_CALL(vkCmdSetDepthBias, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBias, &params);
 }

void WINAPI vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
 {
     struct vkCmdSetDepthBiasEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthBiasEnable = depthBiasEnable;
-    status = UNIX_CALL(vkCmdSetDepthBiasEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBiasEnable, &params);
 }

void WINAPI vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
 {
     struct vkCmdSetDepthBiasEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthBiasEnable = depthBiasEnable;
-    status = UNIX_CALL(vkCmdSetDepthBiasEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBiasEnableEXT, &params);
 }

void WINAPI vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
 {
     struct vkCmdSetDepthBounds_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.minDepthBounds = minDepthBounds;
     params.maxDepthBounds = maxDepthBounds;
-    status = UNIX_CALL(vkCmdSetDepthBounds, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBounds, &params);
 }

void WINAPI vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
 {
     struct vkCmdSetDepthBoundsTestEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthBoundsTestEnable = depthBoundsTestEnable;
-    status = UNIX_CALL(vkCmdSetDepthBoundsTestEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBoundsTestEnable, &params);
 }

void WINAPI vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
 {
     struct vkCmdSetDepthBoundsTestEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthBoundsTestEnable = depthBoundsTestEnable;
-    status = UNIX_CALL(vkCmdSetDepthBoundsTestEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthBoundsTestEnableEXT, &params);
 }

void WINAPI vkCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
 {
     struct vkCmdSetDepthClampEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthClampEnable = depthClampEnable;
-    status = UNIX_CALL(vkCmdSetDepthClampEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthClampEnableEXT, &params);
 }

void WINAPI vkCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
 {
     struct vkCmdSetDepthClipEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthClipEnable = depthClipEnable;
-    status = UNIX_CALL(vkCmdSetDepthClipEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthClipEnableEXT, &params);
 }

void WINAPI vkCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
 {
     struct vkCmdSetDepthClipNegativeOneToOneEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.negativeOneToOne = negativeOneToOne;
-    status = UNIX_CALL(vkCmdSetDepthClipNegativeOneToOneEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthClipNegativeOneToOneEXT, &params);
 }

void WINAPI vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 {
     struct vkCmdSetDepthCompareOp_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthCompareOp = depthCompareOp;
-    status = UNIX_CALL(vkCmdSetDepthCompareOp, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthCompareOp, &params);
 }

void WINAPI vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
 {
     struct vkCmdSetDepthCompareOpEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthCompareOp = depthCompareOp;
-    status = UNIX_CALL(vkCmdSetDepthCompareOpEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthCompareOpEXT, &params);
 }

void WINAPI vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
 {
     struct vkCmdSetDepthTestEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthTestEnable = depthTestEnable;
-    status = UNIX_CALL(vkCmdSetDepthTestEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthTestEnable, &params);
 }

void WINAPI vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
 {
     struct vkCmdSetDepthTestEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthTestEnable = depthTestEnable;
-    status = UNIX_CALL(vkCmdSetDepthTestEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthTestEnableEXT, &params);
 }

void WINAPI vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
 {
     struct vkCmdSetDepthWriteEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthWriteEnable = depthWriteEnable;
-    status = UNIX_CALL(vkCmdSetDepthWriteEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthWriteEnable, &params);
 }

void WINAPI vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
 {
     struct vkCmdSetDepthWriteEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.depthWriteEnable = depthWriteEnable;
-    status = UNIX_CALL(vkCmdSetDepthWriteEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDepthWriteEnableEXT, &params);
 }

void WINAPI vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t *pBufferIndices, const VkDeviceSize *pOffsets)
 {
     struct vkCmdSetDescriptorBufferOffsetsEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineBindPoint = pipelineBindPoint;
     params.layout = layout;
@@ -1977,208 +1678,169 @@ void WINAPI vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, Vk
     params.setCount = setCount;
     params.pBufferIndices = pBufferIndices;
     params.pOffsets = pOffsets;
-    status = UNIX_CALL(vkCmdSetDescriptorBufferOffsetsEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDescriptorBufferOffsetsEXT, &params);
 }

void WINAPI vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     struct vkCmdSetDeviceMask_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.deviceMask = deviceMask;
-    status = UNIX_CALL(vkCmdSetDeviceMask, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDeviceMask, &params);
 }

void WINAPI vkCmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask)
 {
     struct vkCmdSetDeviceMaskKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.deviceMask = deviceMask;
-    status = UNIX_CALL(vkCmdSetDeviceMaskKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDeviceMaskKHR, &params);
 }

void WINAPI vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D *pDiscardRectangles)
 {
     struct vkCmdSetDiscardRectangleEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstDiscardRectangle = firstDiscardRectangle;
     params.discardRectangleCount = discardRectangleCount;
     params.pDiscardRectangles = pDiscardRectangles;
-    status = UNIX_CALL(vkCmdSetDiscardRectangleEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetDiscardRectangleEXT, &params);
 }

void WINAPI vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
 {
     struct vkCmdSetEvent_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.stageMask = stageMask;
-    status = UNIX_CALL(vkCmdSetEvent, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetEvent, &params);
 }

void WINAPI vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
 {
     struct vkCmdSetEvent2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.pDependencyInfo = pDependencyInfo;
-    status = UNIX_CALL(vkCmdSetEvent2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetEvent2, &params);
 }

void WINAPI vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo *pDependencyInfo)
 {
     struct vkCmdSetEvent2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.event = event;
     params.pDependencyInfo = pDependencyInfo;
-    status = UNIX_CALL(vkCmdSetEvent2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetEvent2KHR, &params);
 }

void WINAPI vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D *pExclusiveScissors)
 {
     struct vkCmdSetExclusiveScissorNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstExclusiveScissor = firstExclusiveScissor;
     params.exclusiveScissorCount = exclusiveScissorCount;
     params.pExclusiveScissors = pExclusiveScissors;
-    status = UNIX_CALL(vkCmdSetExclusiveScissorNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetExclusiveScissorNV, &params);
 }

void WINAPI vkCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
 {
     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize;
-    status = UNIX_CALL(vkCmdSetExtraPrimitiveOverestimationSizeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetExtraPrimitiveOverestimationSizeEXT, &params);
 }

void WINAPI vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     struct vkCmdSetFragmentShadingRateEnumNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.shadingRate = shadingRate;
     params.combinerOps = combinerOps;
-    status = UNIX_CALL(vkCmdSetFragmentShadingRateEnumNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetFragmentShadingRateEnumNV, &params);
 }

void WINAPI vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D *pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
 {
     struct vkCmdSetFragmentShadingRateKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pFragmentSize = pFragmentSize;
     params.combinerOps = combinerOps;
-    status = UNIX_CALL(vkCmdSetFragmentShadingRateKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetFragmentShadingRateKHR, &params);
 }

void WINAPI vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
 {
     struct vkCmdSetFrontFace_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.frontFace = frontFace;
-    status = UNIX_CALL(vkCmdSetFrontFace, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetFrontFace, &params);
 }

void WINAPI vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
 {
     struct vkCmdSetFrontFaceEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.frontFace = frontFace;
-    status = UNIX_CALL(vkCmdSetFrontFaceEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetFrontFaceEXT, &params);
 }

void WINAPI vkCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
 {
     struct vkCmdSetLineRasterizationModeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.lineRasterizationMode = lineRasterizationMode;
-    status = UNIX_CALL(vkCmdSetLineRasterizationModeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLineRasterizationModeEXT, &params);
 }

void WINAPI vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
 {
     struct vkCmdSetLineStippleEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.lineStippleFactor = lineStippleFactor;
     params.lineStipplePattern = lineStipplePattern;
-    status = UNIX_CALL(vkCmdSetLineStippleEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLineStippleEXT, &params);
 }

void WINAPI vkCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
 {
     struct vkCmdSetLineStippleEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stippledLineEnable = stippledLineEnable;
-    status = UNIX_CALL(vkCmdSetLineStippleEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLineStippleEnableEXT, &params);
 }

void WINAPI vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
 {
     struct vkCmdSetLineWidth_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.lineWidth = lineWidth;
-    status = UNIX_CALL(vkCmdSetLineWidth, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLineWidth, &params);
 }

void WINAPI vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
 {
     struct vkCmdSetLogicOpEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.logicOp = logicOp;
-    status = UNIX_CALL(vkCmdSetLogicOpEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLogicOpEXT, &params);
 }

void WINAPI vkCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
 {
     struct vkCmdSetLogicOpEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.logicOpEnable = logicOpEnable;
-    status = UNIX_CALL(vkCmdSetLogicOpEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetLogicOpEnableEXT, &params);
 }

void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
 {
     struct vkCmdSetPatchControlPointsEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.patchControlPoints = patchControlPoints;
-    status = UNIX_CALL(vkCmdSetPatchControlPointsEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPatchControlPointsEXT, &params);
 }

VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
@@ -2217,419 +1879,342 @@ VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuff
 void WINAPI vkCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
 {
     struct vkCmdSetPolygonModeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.polygonMode = polygonMode;
-    status = UNIX_CALL(vkCmdSetPolygonModeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPolygonModeEXT, &params);
 }

void WINAPI vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
 {
     struct vkCmdSetPrimitiveRestartEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.primitiveRestartEnable = primitiveRestartEnable;
-    status = UNIX_CALL(vkCmdSetPrimitiveRestartEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPrimitiveRestartEnable, &params);
 }

void WINAPI vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
 {
     struct vkCmdSetPrimitiveRestartEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.primitiveRestartEnable = primitiveRestartEnable;
-    status = UNIX_CALL(vkCmdSetPrimitiveRestartEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPrimitiveRestartEnableEXT, &params);
 }

void WINAPI vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
 {
     struct vkCmdSetPrimitiveTopology_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.primitiveTopology = primitiveTopology;
-    status = UNIX_CALL(vkCmdSetPrimitiveTopology, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPrimitiveTopology, &params);
 }

void WINAPI vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
 {
     struct vkCmdSetPrimitiveTopologyEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.primitiveTopology = primitiveTopology;
-    status = UNIX_CALL(vkCmdSetPrimitiveTopologyEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetPrimitiveTopologyEXT, &params);
 }

void WINAPI vkCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
 {
     struct vkCmdSetProvokingVertexModeEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.provokingVertexMode = provokingVertexMode;
-    status = UNIX_CALL(vkCmdSetProvokingVertexModeEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetProvokingVertexModeEXT, &params);
 }

void WINAPI vkCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
 {
     struct vkCmdSetRasterizationSamplesEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.rasterizationSamples = rasterizationSamples;
-    status = UNIX_CALL(vkCmdSetRasterizationSamplesEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRasterizationSamplesEXT, &params);
 }

void WINAPI vkCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
 {
     struct vkCmdSetRasterizationStreamEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.rasterizationStream = rasterizationStream;
-    status = UNIX_CALL(vkCmdSetRasterizationStreamEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRasterizationStreamEXT, &params);
 }

void WINAPI vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
 {
     struct vkCmdSetRasterizerDiscardEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.rasterizerDiscardEnable = rasterizerDiscardEnable;
-    status = UNIX_CALL(vkCmdSetRasterizerDiscardEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRasterizerDiscardEnable, &params);
 }

void WINAPI vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
 {
     struct vkCmdSetRasterizerDiscardEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.rasterizerDiscardEnable = rasterizerDiscardEnable;
-    status = UNIX_CALL(vkCmdSetRasterizerDiscardEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRasterizerDiscardEnableEXT, &params);
 }

void WINAPI vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
 {
     struct vkCmdSetRayTracingPipelineStackSizeKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineStackSize = pipelineStackSize;
-    status = UNIX_CALL(vkCmdSetRayTracingPipelineStackSizeKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRayTracingPipelineStackSizeKHR, &params);
 }

void WINAPI vkCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
 {
     struct vkCmdSetRepresentativeFragmentTestEnableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.representativeFragmentTestEnable = representativeFragmentTestEnable;
-    status = UNIX_CALL(vkCmdSetRepresentativeFragmentTestEnableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetRepresentativeFragmentTestEnableNV, &params);
 }

void WINAPI vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT *pSampleLocationsInfo)
 {
     struct vkCmdSetSampleLocationsEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pSampleLocationsInfo = pSampleLocationsInfo;
-    status = UNIX_CALL(vkCmdSetSampleLocationsEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetSampleLocationsEXT, &params);
 }

void WINAPI vkCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
 {
     struct vkCmdSetSampleLocationsEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.sampleLocationsEnable = sampleLocationsEnable;
-    status = UNIX_CALL(vkCmdSetSampleLocationsEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetSampleLocationsEnableEXT, &params);
 }

void WINAPI vkCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask *pSampleMask)
 {
     struct vkCmdSetSampleMaskEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.samples = samples;
     params.pSampleMask = pSampleMask;
-    status = UNIX_CALL(vkCmdSetSampleMaskEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetSampleMaskEXT, &params);
 }

void WINAPI vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     struct vkCmdSetScissor_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstScissor = firstScissor;
     params.scissorCount = scissorCount;
     params.pScissors = pScissors;
-    status = UNIX_CALL(vkCmdSetScissor, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetScissor, &params);
 }

void WINAPI vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     struct vkCmdSetScissorWithCount_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.scissorCount = scissorCount;
     params.pScissors = pScissors;
-    status = UNIX_CALL(vkCmdSetScissorWithCount, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetScissorWithCount, &params);
 }

void WINAPI vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D *pScissors)
 {
     struct vkCmdSetScissorWithCountEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.scissorCount = scissorCount;
     params.pScissors = pScissors;
-    status = UNIX_CALL(vkCmdSetScissorWithCountEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetScissorWithCountEXT, &params);
 }

void WINAPI vkCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
 {
     struct vkCmdSetShadingRateImageEnableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.shadingRateImageEnable = shadingRateImageEnable;
-    status = UNIX_CALL(vkCmdSetShadingRateImageEnableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetShadingRateImageEnableNV, &params);
 }

void WINAPI vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
 {
     struct vkCmdSetStencilCompareMask_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.faceMask = faceMask;
     params.compareMask = compareMask;
-    status = UNIX_CALL(vkCmdSetStencilCompareMask, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilCompareMask, &params);
 }

void WINAPI vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
 {
     struct vkCmdSetStencilOp_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.faceMask = faceMask;
     params.failOp = failOp;
     params.passOp = passOp;
     params.depthFailOp = depthFailOp;
     params.compareOp = compareOp;
-    status = UNIX_CALL(vkCmdSetStencilOp, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilOp, &params);
 }

void WINAPI vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
 {
     struct vkCmdSetStencilOpEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.faceMask = faceMask;
     params.failOp = failOp;
     params.passOp = passOp;
     params.depthFailOp = depthFailOp;
     params.compareOp = compareOp;
-    status = UNIX_CALL(vkCmdSetStencilOpEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilOpEXT, &params);
 }

void WINAPI vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
 {
     struct vkCmdSetStencilReference_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.faceMask = faceMask;
     params.reference = reference;
-    status = UNIX_CALL(vkCmdSetStencilReference, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilReference, &params);
 }

void WINAPI vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
 {
     struct vkCmdSetStencilTestEnable_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stencilTestEnable = stencilTestEnable;
-    status = UNIX_CALL(vkCmdSetStencilTestEnable, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilTestEnable, &params);
 }

void WINAPI vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
 {
     struct vkCmdSetStencilTestEnableEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stencilTestEnable = stencilTestEnable;
-    status = UNIX_CALL(vkCmdSetStencilTestEnableEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilTestEnableEXT, &params);
 }

void WINAPI vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
 {
     struct vkCmdSetStencilWriteMask_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.faceMask = faceMask;
     params.writeMask = writeMask;
-    status = UNIX_CALL(vkCmdSetStencilWriteMask, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetStencilWriteMask, &params);
 }

void WINAPI vkCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
 {
     struct vkCmdSetTessellationDomainOriginEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.domainOrigin = domainOrigin;
-    status = UNIX_CALL(vkCmdSetTessellationDomainOriginEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetTessellationDomainOriginEXT, &params);
 }

void WINAPI vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT *pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions)
 {
     struct vkCmdSetVertexInputEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.vertexBindingDescriptionCount = vertexBindingDescriptionCount;
     params.pVertexBindingDescriptions = pVertexBindingDescriptions;
     params.vertexAttributeDescriptionCount = vertexAttributeDescriptionCount;
     params.pVertexAttributeDescriptions = pVertexAttributeDescriptions;
-    status = UNIX_CALL(vkCmdSetVertexInputEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetVertexInputEXT, &params);
 }

void WINAPI vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports)
 {
     struct vkCmdSetViewport_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstViewport = firstViewport;
     params.viewportCount = viewportCount;
     params.pViewports = pViewports;
-    status = UNIX_CALL(vkCmdSetViewport, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewport, &params);
 }

void WINAPI vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV *pShadingRatePalettes)
 {
     struct vkCmdSetViewportShadingRatePaletteNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstViewport = firstViewport;
     params.viewportCount = viewportCount;
     params.pShadingRatePalettes = pShadingRatePalettes;
-    status = UNIX_CALL(vkCmdSetViewportShadingRatePaletteNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportShadingRatePaletteNV, &params);
 }

void WINAPI vkCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV *pViewportSwizzles)
 {
     struct vkCmdSetViewportSwizzleNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstViewport = firstViewport;
     params.viewportCount = viewportCount;
     params.pViewportSwizzles = pViewportSwizzles;
-    status = UNIX_CALL(vkCmdSetViewportSwizzleNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportSwizzleNV, &params);
 }

void WINAPI vkCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
 {
     struct vkCmdSetViewportWScalingEnableNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.viewportWScalingEnable = viewportWScalingEnable;
-    status = UNIX_CALL(vkCmdSetViewportWScalingEnableNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportWScalingEnableNV, &params);
 }

void WINAPI vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV *pViewportWScalings)
 {
     struct vkCmdSetViewportWScalingNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.firstViewport = firstViewport;
     params.viewportCount = viewportCount;
     params.pViewportWScalings = pViewportWScalings;
-    status = UNIX_CALL(vkCmdSetViewportWScalingNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportWScalingNV, &params);
 }

void WINAPI vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
 {
     struct vkCmdSetViewportWithCount_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.viewportCount = viewportCount;
     params.pViewports = pViewports;
-    status = UNIX_CALL(vkCmdSetViewportWithCount, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportWithCount, &params);
 }

void WINAPI vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport *pViewports)
 {
     struct vkCmdSetViewportWithCountEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.viewportCount = viewportCount;
     params.pViewports = pViewports;
-    status = UNIX_CALL(vkCmdSetViewportWithCountEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSetViewportWithCountEXT, &params);
 }

void WINAPI vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
 {
     struct vkCmdSubpassShadingHUAWEI_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkCmdSubpassShadingHUAWEI, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdSubpassShadingHUAWEI, &params);
 }

void WINAPI vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
 {
     struct vkCmdTraceRaysIndirect2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.indirectDeviceAddress = indirectDeviceAddress;
-    status = UNIX_CALL(vkCmdTraceRaysIndirect2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdTraceRaysIndirect2KHR, &params);
 }

void WINAPI vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR *pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR *pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
 {
     struct vkCmdTraceRaysIndirectKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
     params.pMissShaderBindingTable = pMissShaderBindingTable;
     params.pHitShaderBindingTable = pHitShaderBindingTable;
     params.pCallableShaderBindingTable = pCallableShaderBindingTable;
     params.indirectDeviceAddress = indirectDeviceAddress;
-    status = UNIX_CALL(vkCmdTraceRaysIndirectKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdTraceRaysIndirectKHR, &params);
 }

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)
 {
     struct vkCmdTraceRaysKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pRaygenShaderBindingTable = pRaygenShaderBindingTable;
     params.pMissShaderBindingTable = pMissShaderBindingTable;
@@ -2638,14 +2223,12 @@ void WINAPI vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDevi
     params.width = width;
     params.height = height;
     params.depth = depth;
-    status = UNIX_CALL(vkCmdTraceRaysKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdTraceRaysKHR, &params);
 }

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)
 {
     struct vkCmdTraceRaysNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.raygenShaderBindingTableBuffer = raygenShaderBindingTableBuffer;
     params.raygenShaderBindingOffset = raygenShaderBindingOffset;
@@ -2661,27 +2244,23 @@ void WINAPI vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShade
     params.width = width;
     params.height = height;
     params.depth = depth;
-    status = UNIX_CALL(vkCmdTraceRaysNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdTraceRaysNV, &params);
 }

void WINAPI vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData)
 {
     struct vkCmdUpdateBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.dstBuffer = dstBuffer;
     params.dstOffset = dstOffset;
     params.dataSize = dataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkCmdUpdateBuffer, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdUpdateBuffer, &params);
 }

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)
 {
     struct vkCmdWaitEvents_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.eventCount = eventCount;
     params.pEvents = pEvents;
@@ -2693,136 +2272,115 @@ void WINAPI vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
     params.pBufferMemoryBarriers = pBufferMemoryBarriers;
     params.imageMemoryBarrierCount = imageMemoryBarrierCount;
     params.pImageMemoryBarriers = pImageMemoryBarriers;
-    status = UNIX_CALL(vkCmdWaitEvents, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWaitEvents, &params);
 }

void WINAPI vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
 {
     struct vkCmdWaitEvents2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.eventCount = eventCount;
     params.pEvents = pEvents;
     params.pDependencyInfos = pDependencyInfos;
-    status = UNIX_CALL(vkCmdWaitEvents2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWaitEvents2, &params);
 }

void WINAPI vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent *pEvents, const VkDependencyInfo *pDependencyInfos)
 {
     struct vkCmdWaitEvents2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.eventCount = eventCount;
     params.pEvents = pEvents;
     params.pDependencyInfos = pDependencyInfos;
-    status = UNIX_CALL(vkCmdWaitEvents2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWaitEvents2KHR, &params);
 }

void WINAPI vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.accelerationStructureCount = accelerationStructureCount;
     params.pAccelerationStructures = pAccelerationStructures;
     params.queryType = queryType;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
-    status = UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesKHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesKHR, &params);
 }

void WINAPI vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV *pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     struct vkCmdWriteAccelerationStructuresPropertiesNV_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.accelerationStructureCount = accelerationStructureCount;
     params.pAccelerationStructures = pAccelerationStructures;
     params.queryType = queryType;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
-    status = UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesNV, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteAccelerationStructuresPropertiesNV, &params);
 }

void WINAPI vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     struct vkCmdWriteBufferMarker2AMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stage = stage;
     params.dstBuffer = dstBuffer;
     params.dstOffset = dstOffset;
     params.marker = marker;
-    status = UNIX_CALL(vkCmdWriteBufferMarker2AMD, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteBufferMarker2AMD, &params);
 }

void WINAPI vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
 {
     struct vkCmdWriteBufferMarkerAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineStage = pipelineStage;
     params.dstBuffer = dstBuffer;
     params.dstOffset = dstOffset;
     params.marker = marker;
-    status = UNIX_CALL(vkCmdWriteBufferMarkerAMD, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteBufferMarkerAMD, &params);
 }

void WINAPI vkCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
 {
     struct vkCmdWriteMicromapsPropertiesEXT_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.micromapCount = micromapCount;
     params.pMicromaps = pMicromaps;
     params.queryType = queryType;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
-    status = UNIX_CALL(vkCmdWriteMicromapsPropertiesEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteMicromapsPropertiesEXT, &params);
 }

void WINAPI vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
 {
     struct vkCmdWriteTimestamp_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pipelineStage = pipelineStage;
     params.queryPool = queryPool;
     params.query = query;
-    status = UNIX_CALL(vkCmdWriteTimestamp, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteTimestamp, &params);
 }

void WINAPI vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
 {
     struct vkCmdWriteTimestamp2_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stage = stage;
     params.queryPool = queryPool;
     params.query = query;
-    status = UNIX_CALL(vkCmdWriteTimestamp2, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteTimestamp2, &params);
 }

void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
 {
     struct vkCmdWriteTimestamp2KHR_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.stage = stage;
     params.queryPool = queryPool;
     params.query = query;
-    status = UNIX_CALL(vkCmdWriteTimestamp2KHR, &params);
-    assert(!status);
+    UNIX_CALL(vkCmdWriteTimestamp2KHR, &params);
 }

VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
@@ -4225,13 +3783,11 @@ VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOpera
 void WINAPI vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pDescriptorInfo, size_t dataSize, void *pDescriptor)
 {
     struct vkGetDescriptorEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pDescriptorInfo = pDescriptorInfo;
     params.dataSize = dataSize;
     params.pDescriptor = pDescriptor;
-    status = UNIX_CALL(vkGetDescriptorEXT, &params);
-    assert(!status);
+    UNIX_CALL(vkGetDescriptorEXT, &params);
 }

void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
@@ -5981,13 +5537,11 @@ void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
 void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     struct vkUpdateDescriptorSetWithTemplate_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorSet = descriptorSet;
     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
     params.pData = pData;
-    status = UNIX_CALL(vkUpdateDescriptorSetWithTemplate, &params);
-    assert(!status);
+    UNIX_CALL(vkUpdateDescriptorSetWithTemplate, &params);
 }

void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
@@ -6005,14 +5559,12 @@ void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSe
 void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
 {
     struct vkUpdateDescriptorSets_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorWriteCount = descriptorWriteCount;
     params.pDescriptorWrites = pDescriptorWrites;
     params.descriptorCopyCount = descriptorCopyCount;
     params.pDescriptorCopies = pDescriptorCopies;
-    status = UNIX_CALL(vkUpdateDescriptorSets, &params);
-    assert(!status);
+    UNIX_CALL(vkUpdateDescriptorSets, &params);
 }

VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 7a883caceac..cf2711c6d5c 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -150,6 +150,13 @@ ALLOWED_X_EXTENSIONS = [
     "VK_NVX_image_view_handle",
 ]

+# Some frequently called functions skip traces and checks for performance reasons.
+PERF_CRITICAL_FUNCTIONS = [
+    "vkUpdateDescriptorSets",
+    "vkUpdateDescriptorSetWithTemplate",
+    "vkGetDescriptorEXT",
+]
+
 # Functions part of our winevulkan graphics driver interface.
 # DRIVER_VERSION should be bumped on any change to driver interface
 # in FUNCTION_OVERRIDES
@@ -674,6 +681,12 @@ class VkFunction(object):
         # The function needs exposed if at-least one extension isn't both UNSUPPORTED and UNEXPOSED
         return self.is_required() and (not self.extensions or not self.extensions.issubset(UNEXPOSED_EXTENSIONS))

+    def is_perf_critical(self):
+        # vkCmd* functions are frequently called, do not trace for performance
+        if self.name.startswith("vkCmd") and self.type == "void":
+            return True
+        return self.name in PERF_CRITICAL_FUNCTIONS
+
     def pfn(self, prefix="p", call_conv=None):
         """ Create function pointer. """

@@ -733,13 +746,18 @@ class VkFunction(object):

def loader_body(self):
         body = "    struct {0}_params params;\n".format(self.name)
-        body += "    NTSTATUS status;\n"
+        if not self.is_perf_critical():
+            body += "    NTSTATUS status;\n"
         for p in self.params:
             body += "    params.{0} = {0};\n".format(p.name)

# Call the Unix function.
-        body += "    status = UNIX_CALL({0}, &params);\n".format(self.name)
-        body += "    assert(!status);\n"
+        if self.is_perf_critical():
+            body += "    UNIX_CALL({0}, &params);\n".format(self.name)
+        else:
+            body += "    status = UNIX_CALL({0}, &params);\n".format(self.name)
+            body += "    assert(!status);\n"
+
         if self.type != "void":
             body += "    return params.result;\n"
         return body

[PATCH 2/3] winevulkan: Skip traces for some critical functions.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/winevulkan/make_vulkan     |   4 +-
 dlls/winevulkan/vulkan_thunks.c | 896 --------------------------------
 2 files changed, 3 insertions(+), 897 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index cf2711c6d5c..78a75516baa 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -783,7 +783,9 @@ class VkFunction(object):
         if needs_alloc:
             body += "    struct conversion_context ctx;\n"
         body += "\n"
-        body += "    {0}\n".format(self.trace(params_prefix=params_prefix, conv=conv))
+
+        if not self.is_perf_critical():
+            body += "    {0}\n".format(self.trace(params_prefix=params_prefix, conv=conv))

if self.params[0].optional and self.params[0].is_handle():
             if self.type != "void":
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 2352a17a553..9e91f766327 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -25988,8 +25988,6 @@ static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
 {
     struct vkCmdBeginConditionalRenderingEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pConditionalRenderingBegin);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
     return STATUS_SUCCESS;
 }
@@ -26004,8 +26002,6 @@ static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
     } *params = args;
     VkConditionalRenderingBeginInfoEXT pConditionalRenderingBegin_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pConditionalRenderingBegin);
-
     convert_VkConditionalRenderingBeginInfoEXT_win32_to_host((const VkConditionalRenderingBeginInfoEXT32 *)UlongToPtr(params->pConditionalRenderingBegin), &pConditionalRenderingBegin_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pConditionalRenderingBegin_host);
     return STATUS_SUCCESS;
@@ -26016,8 +26012,6 @@ static NTSTATUS thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
     return STATUS_SUCCESS;
 }
@@ -26032,8 +26026,6 @@ static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);
-
     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
     return STATUS_SUCCESS;
@@ -26044,8 +26036,6 @@ static NTSTATUS thunk64_vkCmdBeginQuery(void *args)
 {
     struct vkCmdBeginQuery_params *params = args;

-    TRACE("%p, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags);
     return STATUS_SUCCESS;
 }
@@ -26061,8 +26051,6 @@ static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
         VkQueryControlFlags flags;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags);
     return STATUS_SUCCESS;
 }
@@ -26072,8 +26060,6 @@ static NTSTATUS thunk64_vkCmdBeginQueryIndexedEXT(void *args)
 {
     struct vkCmdBeginQueryIndexedEXT_params *params = args;

-    TRACE("%p, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags, params->index);
     return STATUS_SUCCESS;
 }
@@ -26090,8 +26076,6 @@ static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
         uint32_t index;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %#x, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->flags, params->index);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->flags, params->index);
     return STATUS_SUCCESS;
 }
@@ -26101,8 +26085,6 @@ static NTSTATUS thunk64_vkCmdBeginRenderPass(void *args)
 {
     struct vkCmdBeginRenderPass_params *params = args;

-    TRACE("%p, %p, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
     return STATUS_SUCCESS;
 }
@@ -26119,8 +26101,6 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
     VkRenderPassBeginInfo pRenderPassBegin_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->contents);
-
     init_conversion_context(&ctx);
     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, params->contents);
@@ -26133,8 +26113,6 @@ static NTSTATUS thunk64_vkCmdBeginRenderPass2(void *args)
 {
     struct vkCmdBeginRenderPass2_params *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
     return STATUS_SUCCESS;
 }
@@ -26152,8 +26130,6 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-
     init_conversion_context(&ctx);
     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
@@ -26167,8 +26143,6 @@ static NTSTATUS thunk64_vkCmdBeginRenderPass2KHR(void *args)
 {
     struct vkCmdBeginRenderPass2KHR_params *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
     return STATUS_SUCCESS;
 }
@@ -26186,8 +26160,6 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
     VkSubpassBeginInfo pSubpassBeginInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-
     init_conversion_context(&ctx);
     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
@@ -26201,8 +26173,6 @@ static NTSTATUS thunk64_vkCmdBeginRendering(void *args)
 {
     struct vkCmdBeginRendering_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
     return STATUS_SUCCESS;
 }
@@ -26218,8 +26188,6 @@ static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
     VkRenderingInfo pRenderingInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);
-
     init_conversion_context(&ctx);
     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
@@ -26232,8 +26200,6 @@ static NTSTATUS thunk64_vkCmdBeginRenderingKHR(void *args)
 {
     struct vkCmdBeginRenderingKHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pRenderingInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
     return STATUS_SUCCESS;
 }
@@ -26249,8 +26215,6 @@ static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
     VkRenderingInfo pRenderingInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pRenderingInfo);
-
     init_conversion_context(&ctx);
     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
@@ -26263,8 +26227,6 @@ static NTSTATUS thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
 {
     struct vkCmdBeginTransformFeedbackEXT_params *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
     return STATUS_SUCCESS;
 }
@@ -26281,8 +26243,6 @@ static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
         PTR32 pCounterBufferOffsets;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
     return STATUS_SUCCESS;
 }
@@ -26292,8 +26252,6 @@ static NTSTATUS thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
 {
     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set);
     return STATUS_SUCCESS;
 }
@@ -26309,8 +26267,6 @@ static NTSTATUS thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
         uint32_t set;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set);
     return STATUS_SUCCESS;
 }
@@ -26320,8 +26276,6 @@ static NTSTATUS thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
 {
     struct vkCmdBindDescriptorBuffersEXT_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->bufferCount, params->pBindingInfos);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
     return STATUS_SUCCESS;
 }
@@ -26338,8 +26292,6 @@ static NTSTATUS thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
     const VkDescriptorBufferBindingInfoEXT *pBindingInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->bufferCount, params->pBindingInfos);
-
     init_conversion_context(&ctx);
     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(&ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->bufferCount, pBindingInfos_host);
@@ -26352,8 +26304,6 @@ static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args)
 {
     struct vkCmdBindDescriptorSets_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u, %u, %p, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
     return STATUS_SUCCESS;
 }
@@ -26373,8 +26323,6 @@ static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
         PTR32 pDynamicOffsets;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, (const VkDescriptorSet *)UlongToPtr(params->pDescriptorSets), params->dynamicOffsetCount, (const uint32_t *)UlongToPtr(params->pDynamicOffsets));
     return STATUS_SUCCESS;
 }
@@ -26384,8 +26332,6 @@ static NTSTATUS thunk64_vkCmdBindIndexBuffer(void *args)
 {
     struct vkCmdBindIndexBuffer_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->indexType);
     return STATUS_SUCCESS;
 }
@@ -26401,8 +26347,6 @@ static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
         VkIndexType indexType;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->indexType);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->indexType);
     return STATUS_SUCCESS;
 }
@@ -26412,8 +26356,6 @@ static NTSTATUS thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
 {
     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }
@@ -26428,8 +26370,6 @@ static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
         VkImageLayout imageLayout;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }
@@ -26439,8 +26379,6 @@ static NTSTATUS thunk64_vkCmdBindPipeline(void *args)
 {
     struct vkCmdBindPipeline_params *params = args;

-    TRACE("%p, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
     return STATUS_SUCCESS;
 }
@@ -26455,8 +26393,6 @@ static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
         VkPipeline DECLSPEC_ALIGN(8) pipeline;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline));
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline);
     return STATUS_SUCCESS;
 }
@@ -26466,8 +26402,6 @@ static NTSTATUS thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
 {
     struct vkCmdBindPipelineShaderGroupNV_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
     return STATUS_SUCCESS;
 }
@@ -26483,8 +26417,6 @@ static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
         uint32_t groupIndex;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->pipeline), params->groupIndex);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
     return STATUS_SUCCESS;
 }
@@ -26494,8 +26426,6 @@ static NTSTATUS thunk64_vkCmdBindShadingRateImageNV(void *args)
 {
     struct vkCmdBindShadingRateImageNV_params *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }
@@ -26510,8 +26440,6 @@ static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
         VkImageLayout imageLayout;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->imageView), params->imageLayout);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->imageView, params->imageLayout);
     return STATUS_SUCCESS;
 }
@@ -26521,8 +26449,6 @@ static NTSTATUS thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
 {
     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
     return STATUS_SUCCESS;
 }
@@ -26540,8 +26466,6 @@ static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
         PTR32 pSizes;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes));
     return STATUS_SUCCESS;
 }
@@ -26551,8 +26475,6 @@ static NTSTATUS thunk64_vkCmdBindVertexBuffers(void *args)
 {
     struct vkCmdBindVertexBuffers_params *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
     return STATUS_SUCCESS;
 }
@@ -26569,8 +26491,6 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
         PTR32 pOffsets;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
     return STATUS_SUCCESS;
 }
@@ -26580,8 +26500,6 @@ static NTSTATUS thunk64_vkCmdBindVertexBuffers2(void *args)
 {
     struct vkCmdBindVertexBuffers2_params *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
     return STATUS_SUCCESS;
 }
@@ -26600,8 +26518,6 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
         PTR32 pStrides;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
     return STATUS_SUCCESS;
 }
@@ -26611,8 +26527,6 @@ static NTSTATUS thunk64_vkCmdBindVertexBuffers2EXT(void *args)
 {
     struct vkCmdBindVertexBuffers2EXT_params *params = args;

-    TRACE("%p, %u, %u, %p, %p, %p, %p\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
     return STATUS_SUCCESS;
 }
@@ -26631,8 +26545,6 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
         PTR32 pStrides;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstBinding, params->bindingCount, (const VkBuffer *)UlongToPtr(params->pBuffers), (const VkDeviceSize *)UlongToPtr(params->pOffsets), (const VkDeviceSize *)UlongToPtr(params->pSizes), (const VkDeviceSize *)UlongToPtr(params->pStrides));
     return STATUS_SUCCESS;
 }
@@ -26642,8 +26554,6 @@ static NTSTATUS thunk64_vkCmdBlitImage(void *args)
 {
     struct vkCmdBlitImage_params *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
     return STATUS_SUCCESS;
 }
@@ -26663,8 +26573,6 @@ static NTSTATUS thunk32_vkCmdBlitImage(void *args)
         VkFilter filter;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageBlit *)UlongToPtr(params->pRegions), params->filter);
     return STATUS_SUCCESS;
 }
@@ -26674,8 +26582,6 @@ static NTSTATUS thunk64_vkCmdBlitImage2(void *args)
 {
     struct vkCmdBlitImage2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
     return STATUS_SUCCESS;
 }
@@ -26691,8 +26597,6 @@ static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
     VkBlitImageInfo2 pBlitImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
@@ -26705,8 +26609,6 @@ static NTSTATUS thunk64_vkCmdBlitImage2KHR(void *args)
 {
     struct vkCmdBlitImage2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pBlitImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
     return STATUS_SUCCESS;
 }
@@ -26722,8 +26624,6 @@ static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
     VkBlitImageInfo2 pBlitImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pBlitImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
@@ -26736,8 +26636,6 @@ static NTSTATUS thunk64_vkCmdBuildAccelerationStructureNV(void *args)
 {
     struct vkCmdBuildAccelerationStructureNV_params *params = args;

-    TRACE("%p, %p, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
     return STATUS_SUCCESS;
 }
@@ -26760,8 +26658,6 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
     VkAccelerationStructureInfoNV pInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, 0x%s, 0x%s, %u, 0x%s, 0x%s, 0x%s, 0x%s\n", params->commandBuffer, params->pInfo, wine_dbgstr_longlong(params->instanceData), wine_dbgstr_longlong(params->instanceOffset), params->update, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), wine_dbgstr_longlong(params->scratch), wine_dbgstr_longlong(params->scratchOffset));
-
     init_conversion_context(&ctx);
     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
@@ -26774,8 +26670,6 @@ static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
 {
     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;

-    TRACE("%p, %u, %p, %p, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
     return STATUS_SUCCESS;
 }
@@ -26795,8 +26689,6 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
-
     init_conversion_context(&ctx);
     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkDeviceAddress *)UlongToPtr(params->pIndirectDeviceAddresses), (const uint32_t *)UlongToPtr(params->pIndirectStrides), (const uint32_t * const*)UlongToPtr(params->ppMaxPrimitiveCounts));
@@ -26809,8 +26701,6 @@ static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
 {
     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
     return STATUS_SUCCESS;
 }
@@ -26828,8 +26718,6 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
     const VkAccelerationStructureBuildGeometryInfoKHR *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
-
     init_conversion_context(&ctx);
     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
@@ -26842,8 +26730,6 @@ static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
 {
     struct vkCmdBuildMicromapsEXT_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->infoCount, params->pInfos);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
     return STATUS_SUCCESS;
 }
@@ -26860,8 +26746,6 @@ static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
     const VkMicromapBuildInfoEXT *pInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->infoCount, params->pInfos);
-
     init_conversion_context(&ctx);
     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host);
@@ -26874,8 +26758,6 @@ static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
 {
     struct vkCmdClearAttachments_params *params = args;

-    TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
     return STATUS_SUCCESS;
 }
@@ -26892,8 +26774,6 @@ static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
         PTR32 pRects;
     } *params = args;

-    TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkClearAttachment *)UlongToPtr(params->pAttachments), params->rectCount, (const VkClearRect *)UlongToPtr(params->pRects));
     return STATUS_SUCCESS;
 }
@@ -26903,8 +26783,6 @@ static NTSTATUS thunk64_vkCmdClearColorImage(void *args)
 {
     struct vkCmdClearColorImage_params *params = args;

-    TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
     return STATUS_SUCCESS;
 }
@@ -26922,8 +26800,6 @@ static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
         PTR32 pRanges;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearColorValue *)UlongToPtr(params->pColor), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
     return STATUS_SUCCESS;
 }
@@ -26933,8 +26809,6 @@ static NTSTATUS thunk64_vkCmdClearDepthStencilImage(void *args)
 {
     struct vkCmdClearDepthStencilImage_params *params = args;

-    TRACE("%p, 0x%s, %#x, %p, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
     return STATUS_SUCCESS;
 }
@@ -26952,8 +26826,6 @@ static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
         PTR32 pRanges;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->image), params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->image, params->imageLayout, (const VkClearDepthStencilValue *)UlongToPtr(params->pDepthStencil), params->rangeCount, (const VkImageSubresourceRange *)UlongToPtr(params->pRanges));
     return STATUS_SUCCESS;
 }
@@ -26963,8 +26835,6 @@ static NTSTATUS thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
 {
     struct vkCmdCopyAccelerationStructureKHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -26979,8 +26849,6 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
     } *params = args;
     VkCopyAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyAccelerationStructureInfoKHR_win32_to_host((const VkCopyAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -26991,8 +26859,6 @@ static NTSTATUS thunk64_vkCmdCopyAccelerationStructureNV(void *args)
 {
     struct vkCmdCopyAccelerationStructureNV_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dst, params->src, params->mode);
     return STATUS_SUCCESS;
 }
@@ -27008,8 +26874,6 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
         VkCopyAccelerationStructureModeKHR mode;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dst), wine_dbgstr_longlong(params->src), params->mode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dst, params->src, params->mode);
     return STATUS_SUCCESS;
 }
@@ -27019,8 +26883,6 @@ static NTSTATUS thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -27035,8 +26897,6 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
     } *params = args;
     VkCopyAccelerationStructureToMemoryInfoKHR pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host((const VkCopyAccelerationStructureToMemoryInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -27047,8 +26907,6 @@ static NTSTATUS thunk64_vkCmdCopyBuffer(void *args)
 {
     struct vkCmdCopyBuffer_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, params->pRegions);
     return STATUS_SUCCESS;
 }
@@ -27067,8 +26925,6 @@ static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
     const VkBufferCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
-
     init_conversion_context(&ctx);
     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
@@ -27081,8 +26937,6 @@ static NTSTATUS thunk64_vkCmdCopyBuffer2(void *args)
 {
     struct vkCmdCopyBuffer2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
     return STATUS_SUCCESS;
 }
@@ -27098,8 +26952,6 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
     VkCopyBufferInfo2 pCopyBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
@@ -27112,8 +26964,6 @@ static NTSTATUS thunk64_vkCmdCopyBuffer2KHR(void *args)
 {
     struct vkCmdCopyBuffer2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
     return STATUS_SUCCESS;
 }
@@ -27129,8 +26979,6 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
     VkCopyBufferInfo2 pCopyBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
@@ -27143,8 +26991,6 @@ static NTSTATUS thunk64_vkCmdCopyBufferToImage(void *args)
 {
     struct vkCmdCopyBufferToImage_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
     return STATUS_SUCCESS;
 }
@@ -27164,8 +27010,6 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
     const VkBufferImageCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%#x, 0x%s, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcBuffer), wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     init_conversion_context(&ctx);
     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
@@ -27178,8 +27022,6 @@ static NTSTATUS thunk64_vkCmdCopyBufferToImage2(void *args)
 {
     struct vkCmdCopyBufferToImage2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
     return STATUS_SUCCESS;
 }
@@ -27195,8 +27037,6 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
@@ -27209,8 +27049,6 @@ static NTSTATUS thunk64_vkCmdCopyBufferToImage2KHR(void *args)
 {
     struct vkCmdCopyBufferToImage2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyBufferToImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
     return STATUS_SUCCESS;
 }
@@ -27226,8 +27064,6 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
     VkCopyBufferToImageInfo2 pCopyBufferToImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyBufferToImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
@@ -27240,8 +27076,6 @@ static NTSTATUS thunk64_vkCmdCopyImage(void *args)
 {
     struct vkCmdCopyImage_params *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
     return STATUS_SUCCESS;
 }
@@ -27260,8 +27094,6 @@ static NTSTATUS thunk32_vkCmdCopyImage(void *args)
         PTR32 pRegions;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageCopy *)UlongToPtr(params->pRegions));
     return STATUS_SUCCESS;
 }
@@ -27271,8 +27103,6 @@ static NTSTATUS thunk64_vkCmdCopyImage2(void *args)
 {
     struct vkCmdCopyImage2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
     return STATUS_SUCCESS;
 }
@@ -27288,8 +27118,6 @@ static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
     VkCopyImageInfo2 pCopyImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
@@ -27302,8 +27130,6 @@ static NTSTATUS thunk64_vkCmdCopyImage2KHR(void *args)
 {
     struct vkCmdCopyImage2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
     return STATUS_SUCCESS;
 }
@@ -27319,8 +27145,6 @@ static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
     VkCopyImageInfo2 pCopyImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
@@ -27333,8 +27157,6 @@ static NTSTATUS thunk64_vkCmdCopyImageToBuffer(void *args)
 {
     struct vkCmdCopyImageToBuffer_params *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, params->pRegions);
     return STATUS_SUCCESS;
 }
@@ -27354,8 +27176,6 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
     const VkBufferImageCopy *pRegions_host;
     struct conversion_context ctx;

-    TRACE("%#x, 0x%s, %#x, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstBuffer), params->regionCount, params->pRegions);
-
     init_conversion_context(&ctx);
     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
@@ -27368,8 +27188,6 @@ static NTSTATUS thunk64_vkCmdCopyImageToBuffer2(void *args)
 {
     struct vkCmdCopyImageToBuffer2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
     return STATUS_SUCCESS;
 }
@@ -27385,8 +27203,6 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
@@ -27399,8 +27215,6 @@ static NTSTATUS thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
 {
     struct vkCmdCopyImageToBuffer2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCopyImageToBufferInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
     return STATUS_SUCCESS;
 }
@@ -27416,8 +27230,6 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
     VkCopyImageToBufferInfo2 pCopyImageToBufferInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCopyImageToBufferInfo);
-
     init_conversion_context(&ctx);
     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
@@ -27430,8 +27242,6 @@ static NTSTATUS thunk64_vkCmdCopyMemoryIndirectNV(void *args)
 {
     struct vkCmdCopyMemoryIndirectNV_params *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -27447,8 +27257,6 @@ static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -27458,8 +27266,6 @@ static NTSTATUS thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -27474,8 +27280,6 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
     } *params = args;
     VkCopyMemoryToAccelerationStructureInfoKHR pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host((const VkCopyMemoryToAccelerationStructureInfoKHR32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -27486,8 +27290,6 @@ static NTSTATUS thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
 {
     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, %#x, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, params->pImageSubresources);
     return STATUS_SUCCESS;
 }
@@ -27506,8 +27308,6 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
         PTR32 pImageSubresources;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %u, 0x%s, %#x, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->copyBufferAddress), params->copyCount, params->stride, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->pImageSubresources);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, (const VkImageSubresourceLayers *)UlongToPtr(params->pImageSubresources));
     return STATUS_SUCCESS;
 }
@@ -27517,8 +27317,6 @@ static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
 {
     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -27533,8 +27331,6 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
     } *params = args;
     VkCopyMemoryToMicromapInfoEXT pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host((const VkCopyMemoryToMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -27545,8 +27341,6 @@ static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
 {
     struct vkCmdCopyMicromapEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -27561,8 +27355,6 @@ static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
     } *params = args;
     VkCopyMicromapInfoEXT pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyMicromapInfoEXT_win32_to_host((const VkCopyMicromapInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -27573,8 +27365,6 @@ static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
 {
     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
     return STATUS_SUCCESS;
 }
@@ -27589,8 +27379,6 @@ static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
     } *params = args;
     VkCopyMicromapToMemoryInfoEXT pInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pInfo);
-
     convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host((const VkCopyMicromapToMemoryInfoEXT32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host);
     return STATUS_SUCCESS;
@@ -27601,8 +27389,6 @@ static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
 {
     struct vkCmdCopyQueryPoolResults_params *params = args;

-    TRACE("%p, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
     return STATUS_SUCCESS;
 }
@@ -27622,8 +27408,6 @@ static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
         VkQueryResultFlags flags;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %u, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->stride), params->flags);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
     return STATUS_SUCCESS;
 }
@@ -27633,8 +27417,6 @@ static NTSTATUS thunk64_vkCmdCuLaunchKernelNVX(void *args)
 {
     struct vkCmdCuLaunchKernelNVX_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLaunchInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
     return STATUS_SUCCESS;
 }
@@ -27649,8 +27431,6 @@ static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
     } *params = args;
     VkCuLaunchInfoNVX pLaunchInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pLaunchInfo);
-
     convert_VkCuLaunchInfoNVX_win32_to_host((const VkCuLaunchInfoNVX32 *)UlongToPtr(params->pLaunchInfo), &pLaunchInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLaunchInfo_host);
     return STATUS_SUCCESS;
@@ -27661,8 +27441,6 @@ static NTSTATUS thunk64_vkCmdDebugMarkerBeginEXT(void *args)
 {
     struct vkCmdDebugMarkerBeginEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
     return STATUS_SUCCESS;
 }
@@ -27677,8 +27455,6 @@ static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
     } *params = args;
     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
-
     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
@@ -27689,8 +27465,6 @@ static NTSTATUS thunk64_vkCmdDebugMarkerEndEXT(void *args)
 {
     struct vkCmdDebugMarkerEndEXT_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -27703,8 +27477,6 @@ static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -27714,8 +27486,6 @@ static NTSTATUS thunk64_vkCmdDebugMarkerInsertEXT(void *args)
 {
     struct vkCmdDebugMarkerInsertEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pMarkerInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
     return STATUS_SUCCESS;
 }
@@ -27730,8 +27500,6 @@ static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
     } *params = args;
     VkDebugMarkerMarkerInfoEXT pMarkerInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pMarkerInfo);
-
     convert_VkDebugMarkerMarkerInfoEXT_win32_to_host((const VkDebugMarkerMarkerInfoEXT32 *)UlongToPtr(params->pMarkerInfo), &pMarkerInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pMarkerInfo_host);
     return STATUS_SUCCESS;
@@ -27742,8 +27510,6 @@ static NTSTATUS thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
 {
     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
     return STATUS_SUCCESS;
 }
@@ -27759,8 +27525,6 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectCommandsAddress), wine_dbgstr_longlong(params->indirectCommandsCountAddress), params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
     return STATUS_SUCCESS;
 }
@@ -27770,8 +27534,6 @@ static NTSTATUS thunk64_vkCmdDecompressMemoryNV(void *args)
 {
     struct vkCmdDecompressMemoryNV_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
     return STATUS_SUCCESS;
 }
@@ -27788,8 +27550,6 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
     const VkDecompressMemoryRegionNV *pDecompressMemoryRegions_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
-
     init_conversion_context(&ctx);
     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
@@ -27802,8 +27562,6 @@ static NTSTATUS thunk64_vkCmdDispatch(void *args)
 {
     struct vkCmdDispatch_params *params = args;

-    TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27819,8 +27577,6 @@ static NTSTATUS thunk32_vkCmdDispatch(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27830,8 +27586,6 @@ static NTSTATUS thunk64_vkCmdDispatchBase(void *args)
 {
     struct vkCmdDispatchBase_params *params = args;

-    TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27850,8 +27604,6 @@ static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27861,8 +27613,6 @@ static NTSTATUS thunk64_vkCmdDispatchBaseKHR(void *args)
 {
     struct vkCmdDispatchBaseKHR_params *params = args;

-    TRACE("%p, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27881,8 +27631,6 @@ static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%#x, %u, %u, %u, %u, %u, %u\n", params->commandBuffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -27892,8 +27640,6 @@ static NTSTATUS thunk64_vkCmdDispatchIndirect(void *args)
 {
     struct vkCmdDispatchIndirect_params *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
     return STATUS_SUCCESS;
 }
@@ -27908,8 +27654,6 @@ static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
         VkDeviceSize DECLSPEC_ALIGN(8) offset;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset));
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset);
     return STATUS_SUCCESS;
 }
@@ -27919,8 +27663,6 @@ static NTSTATUS thunk64_vkCmdDraw(void *args)
 {
     struct vkCmdDraw_params *params = args;

-    TRACE("%p, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
     return STATUS_SUCCESS;
 }
@@ -27937,8 +27679,6 @@ static NTSTATUS thunk32_vkCmdDraw(void *args)
         uint32_t firstInstance;
     } *params = args;

-    TRACE("%#x, %u, %u, %u, %u\n", params->commandBuffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
     return STATUS_SUCCESS;
 }
@@ -27948,8 +27688,6 @@ static NTSTATUS thunk64_vkCmdDrawIndexed(void *args)
 {
     struct vkCmdDrawIndexed_params *params = args;

-    TRACE("%p, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
     return STATUS_SUCCESS;
 }
@@ -27967,8 +27705,6 @@ static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
         uint32_t firstInstance;
     } *params = args;

-    TRACE("%#x, %u, %u, %u, %d, %u\n", params->commandBuffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
     return STATUS_SUCCESS;
 }
@@ -27978,8 +27714,6 @@ static NTSTATUS thunk64_vkCmdDrawIndexedIndirect(void *args)
 {
     struct vkCmdDrawIndexedIndirect_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -27996,8 +27730,6 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28007,8 +27739,6 @@ static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCount(void *args)
 {
     struct vkCmdDrawIndexedIndirectCount_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28027,8 +27757,6 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28038,8 +27766,6 @@ static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
 {
     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28058,8 +27784,6 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28069,8 +27793,6 @@ static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
 {
     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28089,8 +27811,6 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28100,8 +27820,6 @@ static NTSTATUS thunk64_vkCmdDrawIndirect(void *args)
 {
     struct vkCmdDrawIndirect_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28118,8 +27836,6 @@ static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28129,8 +27845,6 @@ static NTSTATUS thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
 {
     struct vkCmdDrawIndirectByteCountEXT_params *params = args;

-    TRACE("%p, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
     return STATUS_SUCCESS;
 }
@@ -28149,8 +27863,6 @@ static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
         uint32_t vertexStride;
     } *params = args;

-    TRACE("%#x, %u, %u, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, params->instanceCount, params->firstInstance, wine_dbgstr_longlong(params->counterBuffer), wine_dbgstr_longlong(params->counterBufferOffset), params->counterOffset, params->vertexStride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
     return STATUS_SUCCESS;
 }
@@ -28160,8 +27872,6 @@ static NTSTATUS thunk64_vkCmdDrawIndirectCount(void *args)
 {
     struct vkCmdDrawIndirectCount_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28180,8 +27890,6 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28191,8 +27899,6 @@ static NTSTATUS thunk64_vkCmdDrawIndirectCountAMD(void *args)
 {
     struct vkCmdDrawIndirectCountAMD_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28211,8 +27917,6 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28222,8 +27926,6 @@ static NTSTATUS thunk64_vkCmdDrawIndirectCountKHR(void *args)
 {
     struct vkCmdDrawIndirectCountKHR_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28242,8 +27944,6 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28253,8 +27953,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksEXT(void *args)
 {
     struct vkCmdDrawMeshTasksEXT_params *params = args;

-    TRACE("%p, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -28270,8 +27968,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
         uint32_t groupCountZ;
     } *params = args;

-    TRACE("%#x, %u, %u, %u\n", params->commandBuffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
     return STATUS_SUCCESS;
 }
@@ -28281,8 +27977,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28301,8 +27995,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28312,8 +28004,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28332,8 +28022,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), wine_dbgstr_longlong(params->countBuffer), wine_dbgstr_longlong(params->countBufferOffset), params->maxDrawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28343,8 +28031,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28361,8 +28047,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28372,8 +28056,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28390,8 +28072,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->buffer), wine_dbgstr_longlong(params->offset), params->drawCount, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28401,8 +28081,6 @@ static NTSTATUS thunk64_vkCmdDrawMeshTasksNV(void *args)
 {
     struct vkCmdDrawMeshTasksNV_params *params = args;

-    TRACE("%p, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
     return STATUS_SUCCESS;
 }
@@ -28417,8 +28095,6 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
         uint32_t firstTask;
     } *params = args;

-    TRACE("%#x, %u, %u\n", params->commandBuffer, params->taskCount, params->firstTask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->taskCount, params->firstTask);
     return STATUS_SUCCESS;
 }
@@ -28428,8 +28104,6 @@ static NTSTATUS thunk64_vkCmdDrawMultiEXT(void *args)
 {
     struct vkCmdDrawMultiEXT_params *params = args;

-    TRACE("%p, %u, %p, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28447,8 +28121,6 @@ static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
         uint32_t stride;
     } *params = args;

-    TRACE("%#x, %u, %#x, %u, %u, %u\n", params->commandBuffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawInfoEXT *)UlongToPtr(params->pVertexInfo), params->instanceCount, params->firstInstance, params->stride);
     return STATUS_SUCCESS;
 }
@@ -28458,8 +28130,6 @@ static NTSTATUS thunk64_vkCmdDrawMultiIndexedEXT(void *args)
 {
     struct vkCmdDrawMultiIndexedEXT_params *params = args;

-    TRACE("%p, %u, %p, %u, %u, %u, %p\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
     return STATUS_SUCCESS;
 }
@@ -28478,8 +28148,6 @@ static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
         PTR32 pVertexOffset;
     } *params = args;

-    TRACE("%#x, %u, %#x, %u, %u, %u, %#x\n", params->commandBuffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawIndexedInfoEXT *)UlongToPtr(params->pIndexInfo), params->instanceCount, params->firstInstance, params->stride, (const int32_t *)UlongToPtr(params->pVertexOffset));
     return STATUS_SUCCESS;
 }
@@ -28489,8 +28157,6 @@ static NTSTATUS thunk64_vkCmdEndConditionalRenderingEXT(void *args)
 {
     struct vkCmdEndConditionalRenderingEXT_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28503,8 +28169,6 @@ static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28514,8 +28178,6 @@ static NTSTATUS thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28528,8 +28190,6 @@ static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28539,8 +28199,6 @@ static NTSTATUS thunk64_vkCmdEndQuery(void *args)
 {
     struct vkCmdEndQuery_params *params = args;

-    TRACE("%p, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -28555,8 +28213,6 @@ static NTSTATUS thunk32_vkCmdEndQuery(void *args)
         uint32_t query;
     } *params = args;

-    TRACE("%#x, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -28566,8 +28222,6 @@ static NTSTATUS thunk64_vkCmdEndQueryIndexedEXT(void *args)
 {
     struct vkCmdEndQueryIndexedEXT_params *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->index);
     return STATUS_SUCCESS;
 }
@@ -28583,8 +28237,6 @@ static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
         uint32_t index;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->query, params->index);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->query, params->index);
     return STATUS_SUCCESS;
 }
@@ -28594,8 +28246,6 @@ static NTSTATUS thunk64_vkCmdEndRenderPass(void *args)
 {
     struct vkCmdEndRenderPass_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28608,8 +28258,6 @@ static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28619,8 +28267,6 @@ static NTSTATUS thunk64_vkCmdEndRenderPass2(void *args)
 {
     struct vkCmdEndRenderPass2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
     return STATUS_SUCCESS;
 }
@@ -28636,8 +28282,6 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);
-
     init_conversion_context(&ctx);
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
@@ -28650,8 +28294,6 @@ static NTSTATUS thunk64_vkCmdEndRenderPass2KHR(void *args)
 {
     struct vkCmdEndRenderPass2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSubpassEndInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
     return STATUS_SUCCESS;
 }
@@ -28667,8 +28309,6 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pSubpassEndInfo);
-
     init_conversion_context(&ctx);
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
@@ -28681,8 +28321,6 @@ static NTSTATUS thunk64_vkCmdEndRendering(void *args)
 {
     struct vkCmdEndRendering_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28695,8 +28333,6 @@ static NTSTATUS thunk32_vkCmdEndRendering(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28706,8 +28342,6 @@ static NTSTATUS thunk64_vkCmdEndRenderingKHR(void *args)
 {
     struct vkCmdEndRenderingKHR_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28720,8 +28354,6 @@ static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -28731,8 +28363,6 @@ static NTSTATUS thunk64_vkCmdEndTransformFeedbackEXT(void *args)
 {
     struct vkCmdEndTransformFeedbackEXT_params *params = args;

-    TRACE("%p, %u, %u, %p, %p\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
     return STATUS_SUCCESS;
 }
@@ -28749,8 +28379,6 @@ static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
         PTR32 pCounterBufferOffsets;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x, %#x\n", params->commandBuffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstCounterBuffer, params->counterBufferCount, (const VkBuffer *)UlongToPtr(params->pCounterBuffers), (const VkDeviceSize *)UlongToPtr(params->pCounterBufferOffsets));
     return STATUS_SUCCESS;
 }
@@ -28762,8 +28390,6 @@ static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
     const VkCommandBuffer *pCommandBuffers_host;
     struct conversion_context ctx;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
-
     init_conversion_context(&ctx);
     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
@@ -28783,8 +28409,6 @@ static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
     const VkCommandBuffer *pCommandBuffers_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->commandBufferCount, params->pCommandBuffers);
-
     init_conversion_context(&ctx);
     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->commandBufferCount, pCommandBuffers_host);
@@ -28797,8 +28421,6 @@ static NTSTATUS thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
 {
     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
     return STATUS_SUCCESS;
 }
@@ -28815,8 +28437,6 @@ static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
-
     init_conversion_context(&ctx);
     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
@@ -28829,8 +28449,6 @@ static NTSTATUS thunk64_vkCmdFillBuffer(void *args)
 {
     struct vkCmdFillBuffer_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
     return STATUS_SUCCESS;
 }
@@ -28847,8 +28465,6 @@ static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
         uint32_t data;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->size), params->data);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
     return STATUS_SUCCESS;
 }
@@ -28858,8 +28474,6 @@ static NTSTATUS thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pLabelInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
     return STATUS_SUCCESS;
 }
@@ -28874,8 +28488,6 @@ static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
     } *params = args;
     VkDebugUtilsLabelEXT pLabelInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pLabelInfo);
-
     convert_VkDebugUtilsLabelEXT_win32_to_host((const VkDebugUtilsLabelEXT32 *)UlongToPtr(params->pLabelInfo), &pLabelInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pLabelInfo_host);
     return STATUS_SUCCESS;
@@ -28886,8 +28498,6 @@ static NTSTATUS thunk64_vkCmdNextSubpass(void *args)
 {
     struct vkCmdNextSubpass_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->contents);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
     return STATUS_SUCCESS;
 }
@@ -28901,8 +28511,6 @@ static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
         VkSubpassContents contents;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->contents);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->contents);
     return STATUS_SUCCESS;
 }
@@ -28912,8 +28520,6 @@ static NTSTATUS thunk64_vkCmdNextSubpass2(void *args)
 {
     struct vkCmdNextSubpass2_params *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
     return STATUS_SUCCESS;
 }
@@ -28931,8 +28537,6 @@ static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-
     init_conversion_context(&ctx);
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
@@ -28946,8 +28550,6 @@ static NTSTATUS thunk64_vkCmdNextSubpass2KHR(void *args)
 {
     struct vkCmdNextSubpass2KHR_params *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
     return STATUS_SUCCESS;
 }
@@ -28965,8 +28567,6 @@ static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
     VkSubpassEndInfo pSubpassEndInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-
     init_conversion_context(&ctx);
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
@@ -28980,8 +28580,6 @@ static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
 {
     struct vkCmdOpticalFlowExecuteNV_params *params = args;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
     return STATUS_SUCCESS;
 }
@@ -28997,8 +28595,6 @@ static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
     } *params = args;
     VkOpticalFlowExecuteInfoNV pExecuteInfo_host;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->session), params->pExecuteInfo);
-
     convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->session, &pExecuteInfo_host);
     return STATUS_SUCCESS;
@@ -29009,8 +28605,6 @@ static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
 {
     struct vkCmdPipelineBarrier_params *params = args;

-    TRACE("%p, %#x, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
     return STATUS_SUCCESS;
 }
@@ -29036,8 +28630,6 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-
     init_conversion_context(&ctx);
     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
@@ -29052,8 +28644,6 @@ static NTSTATUS thunk64_vkCmdPipelineBarrier2(void *args)
 {
     struct vkCmdPipelineBarrier2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
     return STATUS_SUCCESS;
 }
@@ -29069,8 +28659,6 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);
-
     init_conversion_context(&ctx);
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
@@ -29083,8 +28671,6 @@ static NTSTATUS thunk64_vkCmdPipelineBarrier2KHR(void *args)
 {
     struct vkCmdPipelineBarrier2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pDependencyInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
     return STATUS_SUCCESS;
 }
@@ -29100,8 +28686,6 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pDependencyInfo);
-
     init_conversion_context(&ctx);
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
@@ -29114,8 +28698,6 @@ static NTSTATUS thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
 {
     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pGeneratedCommandsInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
     return STATUS_SUCCESS;
 }
@@ -29131,8 +28713,6 @@ static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
     VkGeneratedCommandsInfoNV pGeneratedCommandsInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pGeneratedCommandsInfo);
-
     init_conversion_context(&ctx);
     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pGeneratedCommandsInfo_host);
@@ -29145,8 +28725,6 @@ static NTSTATUS thunk64_vkCmdPushConstants(void *args)
 {
     struct vkCmdPushConstants_params *params = args;

-    TRACE("%p, 0x%s, %#x, %u, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->layout, params->stageFlags, params->offset, params->size, params->pValues);
     return STATUS_SUCCESS;
 }
@@ -29164,8 +28742,6 @@ static NTSTATUS thunk32_vkCmdPushConstants(void *args)
         PTR32 pValues;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, %u, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->layout), params->stageFlags, params->offset, params->size, params->pValues);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->layout, params->stageFlags, params->offset, params->size, (const void *)UlongToPtr(params->pValues));
     return STATUS_SUCCESS;
 }
@@ -29175,8 +28751,6 @@ static NTSTATUS thunk64_vkCmdPushDescriptorSetKHR(void *args)
 {
     struct vkCmdPushDescriptorSetKHR_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u, %u, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, params->pDescriptorWrites);
     return STATUS_SUCCESS;
 }
@@ -29196,8 +28770,6 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
     const VkWriteDescriptorSet *pDescriptorWrites_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, 0x%s, %u, %u, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->set, params->descriptorWriteCount, params->pDescriptorWrites);
-
     init_conversion_context(&ctx);
     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
@@ -29210,8 +28782,6 @@ static NTSTATUS thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
 {
     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, params->pData);
     return STATUS_SUCCESS;
 }
@@ -29228,8 +28798,6 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
         PTR32 pData;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->descriptorUpdateTemplate), wine_dbgstr_longlong(params->layout), params->set, params->pData);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }
@@ -29239,8 +28807,6 @@ static NTSTATUS thunk64_vkCmdResetEvent(void *args)
 {
     struct vkCmdResetEvent_params *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29255,8 +28821,6 @@ static NTSTATUS thunk32_vkCmdResetEvent(void *args)
         VkPipelineStageFlags stageMask;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29266,8 +28830,6 @@ static NTSTATUS thunk64_vkCmdResetEvent2(void *args)
 {
     struct vkCmdResetEvent2_params *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29282,8 +28844,6 @@ static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29293,8 +28853,6 @@ static NTSTATUS thunk64_vkCmdResetEvent2KHR(void *args)
 {
     struct vkCmdResetEvent2KHR_params *params = args;

-    TRACE("%p, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29309,8 +28867,6 @@ static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
         VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->event), wine_dbgstr_longlong(params->stageMask));
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -29320,8 +28876,6 @@ static NTSTATUS thunk64_vkCmdResetQueryPool(void *args)
 {
     struct vkCmdResetQueryPool_params *params = args;

-    TRACE("%p, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
     return STATUS_SUCCESS;
 }
@@ -29337,8 +28891,6 @@ static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
         uint32_t queryCount;
     } *params = args;

-    TRACE("%#x, 0x%s, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->queryPool), params->firstQuery, params->queryCount);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
     return STATUS_SUCCESS;
 }
@@ -29348,8 +28900,6 @@ static NTSTATUS thunk64_vkCmdResolveImage(void *args)
 {
     struct vkCmdResolveImage_params *params = args;

-    TRACE("%p, 0x%s, %#x, 0x%s, %#x, %u, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
     return STATUS_SUCCESS;
 }
@@ -29368,8 +28918,6 @@ static NTSTATUS thunk32_vkCmdResolveImage(void *args)
         PTR32 pRegions;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x, 0x%s, %#x, %u, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->srcImage), params->srcImageLayout, wine_dbgstr_longlong(params->dstImage), params->dstImageLayout, params->regionCount, params->pRegions);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, (const VkImageResolve *)UlongToPtr(params->pRegions));
     return STATUS_SUCCESS;
 }
@@ -29379,8 +28927,6 @@ static NTSTATUS thunk64_vkCmdResolveImage2(void *args)
 {
     struct vkCmdResolveImage2_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
     return STATUS_SUCCESS;
 }
@@ -29396,8 +28942,6 @@ static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
     VkResolveImageInfo2 pResolveImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
@@ -29410,8 +28954,6 @@ static NTSTATUS thunk64_vkCmdResolveImage2KHR(void *args)
 {
     struct vkCmdResolveImage2KHR_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pResolveImageInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
     return STATUS_SUCCESS;
 }
@@ -29427,8 +28969,6 @@ static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
     VkResolveImageInfo2 pResolveImageInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pResolveImageInfo);
-
     init_conversion_context(&ctx);
     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
@@ -29441,8 +28981,6 @@ static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
 {
     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
     return STATUS_SUCCESS;
 }
@@ -29456,8 +28994,6 @@ static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
         VkBool32 alphaToCoverageEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->alphaToCoverageEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToCoverageEnable);
     return STATUS_SUCCESS;
 }
@@ -29467,8 +29003,6 @@ static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
 {
     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->alphaToOneEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
     return STATUS_SUCCESS;
 }
@@ -29482,8 +29016,6 @@ static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
         VkBool32 alphaToOneEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->alphaToOneEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToOneEnable);
     return STATUS_SUCCESS;
 }
@@ -29493,8 +29025,6 @@ static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
 {
     struct vkCmdSetBlendConstants_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->blendConstants);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
     return STATUS_SUCCESS;
 }
@@ -29508,8 +29038,6 @@ static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
         PTR32 blendConstants;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->blendConstants);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const float *)UlongToPtr(params->blendConstants));
     return STATUS_SUCCESS;
 }
@@ -29519,8 +29047,6 @@ static NTSTATUS thunk64_vkCmdSetCheckpointNV(void *args)
 {
     struct vkCmdSetCheckpointNV_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pCheckpointMarker);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
     return STATUS_SUCCESS;
 }
@@ -29534,8 +29060,6 @@ static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
         PTR32 pCheckpointMarker;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pCheckpointMarker);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const void *)UlongToPtr(params->pCheckpointMarker));
     return STATUS_SUCCESS;
 }
@@ -29545,8 +29069,6 @@ static NTSTATUS thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
 {
     struct vkCmdSetCoarseSampleOrderNV_params *params = args;

-    TRACE("%p, %#x, %u, %p\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
     return STATUS_SUCCESS;
 }
@@ -29564,8 +29086,6 @@ static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
     const VkCoarseSampleOrderCustomNV *pCustomSampleOrders_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, %u, %#x\n", params->commandBuffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
-
     init_conversion_context(&ctx);
     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleOrderType, params->customSampleOrderCount, pCustomSampleOrders_host);
@@ -29578,8 +29098,6 @@ static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
     return STATUS_SUCCESS;
 }
@@ -29595,8 +29113,6 @@ static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
         PTR32 pColorBlendAdvanced;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendAdvancedEXT *)UlongToPtr(params->pColorBlendAdvanced));
     return STATUS_SUCCESS;
 }
@@ -29606,8 +29122,6 @@ static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
 {
     struct vkCmdSetColorBlendEnableEXT_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
     return STATUS_SUCCESS;
 }
@@ -29623,8 +29137,6 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
         PTR32 pColorBlendEnables;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorBlendEnables));
     return STATUS_SUCCESS;
 }
@@ -29634,8 +29146,6 @@ static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
 {
     struct vkCmdSetColorBlendEquationEXT_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
     return STATUS_SUCCESS;
 }
@@ -29651,8 +29161,6 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
         PTR32 pColorBlendEquations;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendEquationEXT *)UlongToPtr(params->pColorBlendEquations));
     return STATUS_SUCCESS;
 }
@@ -29662,8 +29170,6 @@ static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
 {
     struct vkCmdSetColorWriteEnableEXT_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
     return STATUS_SUCCESS;
 }
@@ -29678,8 +29184,6 @@ static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
         PTR32 pColorWriteEnables;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->attachmentCount, params->pColorWriteEnables);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorWriteEnables));
     return STATUS_SUCCESS;
 }
@@ -29689,8 +29193,6 @@ static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
 {
     struct vkCmdSetColorWriteMaskEXT_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
     return STATUS_SUCCESS;
 }
@@ -29706,8 +29208,6 @@ static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
         PTR32 pColorWriteMasks;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorComponentFlags *)UlongToPtr(params->pColorWriteMasks));
     return STATUS_SUCCESS;
 }
@@ -29717,8 +29217,6 @@ static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
     return STATUS_SUCCESS;
 }
@@ -29732,8 +29230,6 @@ static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
         VkConservativeRasterizationModeEXT conservativeRasterizationMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->conservativeRasterizationMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->conservativeRasterizationMode);
     return STATUS_SUCCESS;
 }
@@ -29743,8 +29239,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
 {
     struct vkCmdSetCoverageModulationModeNV_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->coverageModulationMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
     return STATUS_SUCCESS;
 }
@@ -29758,8 +29252,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
         VkCoverageModulationModeNV coverageModulationMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->coverageModulationMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationMode);
     return STATUS_SUCCESS;
 }
@@ -29769,8 +29261,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
     return STATUS_SUCCESS;
 }
@@ -29784,8 +29274,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
         VkBool32 coverageModulationTableEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->coverageModulationTableEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableEnable);
     return STATUS_SUCCESS;
 }
@@ -29795,8 +29283,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
 {
     struct vkCmdSetCoverageModulationTableNV_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
     return STATUS_SUCCESS;
 }
@@ -29811,8 +29297,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
         PTR32 pCoverageModulationTable;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableCount, (const float *)UlongToPtr(params->pCoverageModulationTable));
     return STATUS_SUCCESS;
 }
@@ -29822,8 +29306,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
 {
     struct vkCmdSetCoverageReductionModeNV_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->coverageReductionMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
     return STATUS_SUCCESS;
 }
@@ -29837,8 +29319,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
         VkCoverageReductionModeNV coverageReductionMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->coverageReductionMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageReductionMode);
     return STATUS_SUCCESS;
 }
@@ -29848,8 +29328,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
 {
     struct vkCmdSetCoverageToColorEnableNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
     return STATUS_SUCCESS;
 }
@@ -29863,8 +29341,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
         VkBool32 coverageToColorEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorEnable);
     return STATUS_SUCCESS;
 }
@@ -29874,8 +29350,6 @@ static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
 {
     struct vkCmdSetCoverageToColorLocationNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->coverageToColorLocation);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
     return STATUS_SUCCESS;
 }
@@ -29889,8 +29363,6 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
         uint32_t coverageToColorLocation;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->coverageToColorLocation);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorLocation);
     return STATUS_SUCCESS;
 }
@@ -29900,8 +29372,6 @@ static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
 {
     struct vkCmdSetCullMode_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }
@@ -29915,8 +29385,6 @@ static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
         VkCullModeFlags cullMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }
@@ -29926,8 +29394,6 @@ static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
 {
     struct vkCmdSetCullModeEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->cullMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }
@@ -29941,8 +29407,6 @@ static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
         VkCullModeFlags cullMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->cullMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
     return STATUS_SUCCESS;
 }
@@ -29952,8 +29416,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
 {
     struct vkCmdSetDepthBias_params *params = args;

-    TRACE("%p, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
     return STATUS_SUCCESS;
 }
@@ -29969,8 +29431,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
         float depthBiasSlopeFactor;
     } *params = args;

-    TRACE("%#x, %f, %f, %f\n", params->commandBuffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
     return STATUS_SUCCESS;
 }
@@ -29980,8 +29440,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
 {
     struct vkCmdSetDepthBiasEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }
@@ -29995,8 +29453,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
         VkBool32 depthBiasEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }
@@ -30006,8 +29462,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
 {
     struct vkCmdSetDepthBiasEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBiasEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }
@@ -30021,8 +29475,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
         VkBool32 depthBiasEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthBiasEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
     return STATUS_SUCCESS;
 }
@@ -30032,8 +29484,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
 {
     struct vkCmdSetDepthBounds_params *params = args;

-    TRACE("%p, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
     return STATUS_SUCCESS;
 }
@@ -30048,8 +29498,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
         float maxDepthBounds;
     } *params = args;

-    TRACE("%#x, %f, %f\n", params->commandBuffer, params->minDepthBounds, params->maxDepthBounds);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->minDepthBounds, params->maxDepthBounds);
     return STATUS_SUCCESS;
 }
@@ -30059,8 +29507,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
 {
     struct vkCmdSetDepthBoundsTestEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30074,8 +29520,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
         VkBool32 depthBoundsTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30085,8 +29529,6 @@ static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
 {
     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30100,8 +29542,6 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
         VkBool32 depthBoundsTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthBoundsTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30111,8 +29551,6 @@ static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
 {
     struct vkCmdSetDepthClampEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthClampEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
     return STATUS_SUCCESS;
 }
@@ -30126,8 +29564,6 @@ static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
         VkBool32 depthClampEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthClampEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClampEnable);
     return STATUS_SUCCESS;
 }
@@ -30137,8 +29573,6 @@ static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
 {
     struct vkCmdSetDepthClipEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthClipEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
     return STATUS_SUCCESS;
 }
@@ -30152,8 +29586,6 @@ static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
         VkBool32 depthClipEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthClipEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClipEnable);
     return STATUS_SUCCESS;
 }
@@ -30163,8 +29595,6 @@ static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
 {
     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->negativeOneToOne);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
     return STATUS_SUCCESS;
 }
@@ -30178,8 +29608,6 @@ static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
         VkBool32 negativeOneToOne;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->negativeOneToOne);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->negativeOneToOne);
     return STATUS_SUCCESS;
 }
@@ -30189,8 +29617,6 @@ static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
 {
     struct vkCmdSetDepthCompareOp_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }
@@ -30204,8 +29630,6 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
         VkCompareOp depthCompareOp;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }
@@ -30215,8 +29639,6 @@ static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
 {
     struct vkCmdSetDepthCompareOpEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->depthCompareOp);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }
@@ -30230,8 +29652,6 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
         VkCompareOp depthCompareOp;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->depthCompareOp);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
     return STATUS_SUCCESS;
 }
@@ -30241,8 +29661,6 @@ static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
 {
     struct vkCmdSetDepthTestEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30256,8 +29674,6 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
         VkBool32 depthTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30267,8 +29683,6 @@ static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
 {
     struct vkCmdSetDepthTestEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30282,8 +29696,6 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
         VkBool32 depthTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
     return STATUS_SUCCESS;
 }
@@ -30293,8 +29705,6 @@ static NTSTATUS thunk64_vkCmdSetDepthWriteEnable(void *args)
 {
     struct vkCmdSetDepthWriteEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }
@@ -30308,8 +29718,6 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
         VkBool32 depthWriteEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }
@@ -30319,8 +29727,6 @@ static NTSTATUS thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
 {
     struct vkCmdSetDepthWriteEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->depthWriteEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }
@@ -30334,8 +29740,6 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
         VkBool32 depthWriteEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->depthWriteEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
     return STATUS_SUCCESS;
 }
@@ -30345,8 +29749,6 @@ static NTSTATUS thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
 {
     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u, %u, %p, %p\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
     return STATUS_SUCCESS;
 }
@@ -30365,8 +29767,6 @@ static NTSTATUS thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
         PTR32 pOffsets;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, %u, %u, %#x, %#x\n", params->commandBuffer, params->pipelineBindPoint, wine_dbgstr_longlong(params->layout), params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, (const uint32_t *)UlongToPtr(params->pBufferIndices), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
     return STATUS_SUCCESS;
 }
@@ -30376,8 +29776,6 @@ static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args)
 {
     struct vkCmdSetDeviceMask_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }
@@ -30391,8 +29789,6 @@ static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
         uint32_t deviceMask;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }
@@ -30402,8 +29798,6 @@ static NTSTATUS thunk64_vkCmdSetDeviceMaskKHR(void *args)
 {
     struct vkCmdSetDeviceMaskKHR_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->deviceMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }
@@ -30417,8 +29811,6 @@ static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
         uint32_t deviceMask;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->deviceMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
     return STATUS_SUCCESS;
 }
@@ -30428,8 +29820,6 @@ static NTSTATUS thunk64_vkCmdSetDiscardRectangleEXT(void *args)
 {
     struct vkCmdSetDiscardRectangleEXT_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
     return STATUS_SUCCESS;
 }
@@ -30445,8 +29835,6 @@ static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
         PTR32 pDiscardRectangles;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, (const VkRect2D *)UlongToPtr(params->pDiscardRectangles));
     return STATUS_SUCCESS;
 }
@@ -30456,8 +29844,6 @@ static NTSTATUS thunk64_vkCmdSetEvent(void *args)
 {
     struct vkCmdSetEvent_params *params = args;

-    TRACE("%p, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -30472,8 +29858,6 @@ static NTSTATUS thunk32_vkCmdSetEvent(void *args)
         VkPipelineStageFlags stageMask;
     } *params = args;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->stageMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
     return STATUS_SUCCESS;
 }
@@ -30483,8 +29867,6 @@ static NTSTATUS thunk64_vkCmdSetEvent2(void *args)
 {
     struct vkCmdSetEvent2_params *params = args;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
     return STATUS_SUCCESS;
 }
@@ -30501,8 +29883,6 @@ static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
-
     init_conversion_context(&ctx);
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
@@ -30515,8 +29895,6 @@ static NTSTATUS thunk64_vkCmdSetEvent2KHR(void *args)
 {
     struct vkCmdSetEvent2KHR_params *params = args;

-    TRACE("%p, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
     return STATUS_SUCCESS;
 }
@@ -30533,8 +29911,6 @@ static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
     VkDependencyInfo pDependencyInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->event), params->pDependencyInfo);
-
     init_conversion_context(&ctx);
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
@@ -30547,8 +29923,6 @@ static NTSTATUS thunk64_vkCmdSetExclusiveScissorNV(void *args)
 {
     struct vkCmdSetExclusiveScissorNV_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
     return STATUS_SUCCESS;
 }
@@ -30564,8 +29938,6 @@ static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
         PTR32 pExclusiveScissors;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, (const VkRect2D *)UlongToPtr(params->pExclusiveScissors));
     return STATUS_SUCCESS;
 }
@@ -30575,8 +29947,6 @@ static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
 {
     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;

-    TRACE("%p, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
     return STATUS_SUCCESS;
 }
@@ -30590,8 +29960,6 @@ static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
         float extraPrimitiveOverestimationSize;
     } *params = args;

-    TRACE("%#x, %f\n", params->commandBuffer, params->extraPrimitiveOverestimationSize);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->extraPrimitiveOverestimationSize);
     return STATUS_SUCCESS;
 }
@@ -30601,8 +29969,6 @@ static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
 {
     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;

-    TRACE("%p, %#x, %p\n", params->commandBuffer, params->shadingRate, params->combinerOps);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
     return STATUS_SUCCESS;
 }
@@ -30617,8 +29983,6 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
         PTR32 combinerOps;
     } *params = args;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->shadingRate, params->combinerOps);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRate, (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
     return STATUS_SUCCESS;
 }
@@ -30628,8 +29992,6 @@ static NTSTATUS thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
 {
     struct vkCmdSetFragmentShadingRateKHR_params *params = args;

-    TRACE("%p, %p, %p\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
     return STATUS_SUCCESS;
 }
@@ -30644,8 +30006,6 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
         PTR32 combinerOps;
     } *params = args;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->pFragmentSize, params->combinerOps);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const VkExtent2D *)UlongToPtr(params->pFragmentSize), (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
     return STATUS_SUCCESS;
 }
@@ -30655,8 +30015,6 @@ static NTSTATUS thunk64_vkCmdSetFrontFace(void *args)
 {
     struct vkCmdSetFrontFace_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }
@@ -30670,8 +30028,6 @@ static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
         VkFrontFace frontFace;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }
@@ -30681,8 +30037,6 @@ static NTSTATUS thunk64_vkCmdSetFrontFaceEXT(void *args)
 {
     struct vkCmdSetFrontFaceEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->frontFace);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }
@@ -30696,8 +30050,6 @@ static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
         VkFrontFace frontFace;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->frontFace);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
     return STATUS_SUCCESS;
 }
@@ -30707,8 +30059,6 @@ static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
 {
     struct vkCmdSetLineRasterizationModeEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->lineRasterizationMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
     return STATUS_SUCCESS;
 }
@@ -30722,8 +30072,6 @@ static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
         VkLineRasterizationModeEXT lineRasterizationMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->lineRasterizationMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineRasterizationMode);
     return STATUS_SUCCESS;
 }
@@ -30733,8 +30081,6 @@ static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
 {
     struct vkCmdSetLineStippleEXT_params *params = args;

-    TRACE("%p, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
     return STATUS_SUCCESS;
 }
@@ -30749,8 +30095,6 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
         uint16_t lineStipplePattern;
     } *params = args;

-    TRACE("%#x, %u, %u\n", params->commandBuffer, params->lineStippleFactor, params->lineStipplePattern);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
     return STATUS_SUCCESS;
 }
@@ -30760,8 +30104,6 @@ static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
 {
     struct vkCmdSetLineStippleEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stippledLineEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
     return STATUS_SUCCESS;
 }
@@ -30775,8 +30117,6 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
         VkBool32 stippledLineEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->stippledLineEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stippledLineEnable);
     return STATUS_SUCCESS;
 }
@@ -30786,8 +30126,6 @@ static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
 {
     struct vkCmdSetLineWidth_params *params = args;

-    TRACE("%p, %f\n", params->commandBuffer, params->lineWidth);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
     return STATUS_SUCCESS;
 }
@@ -30801,8 +30139,6 @@ static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
         float lineWidth;
     } *params = args;

-    TRACE("%#x, %f\n", params->commandBuffer, params->lineWidth);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineWidth);
     return STATUS_SUCCESS;
 }
@@ -30812,8 +30148,6 @@ static NTSTATUS thunk64_vkCmdSetLogicOpEXT(void *args)
 {
     struct vkCmdSetLogicOpEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->logicOp);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
     return STATUS_SUCCESS;
 }
@@ -30827,8 +30161,6 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
         VkLogicOp logicOp;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->logicOp);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOp);
     return STATUS_SUCCESS;
 }
@@ -30838,8 +30170,6 @@ static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
 {
     struct vkCmdSetLogicOpEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->logicOpEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
     return STATUS_SUCCESS;
 }
@@ -30853,8 +30183,6 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
         VkBool32 logicOpEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->logicOpEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOpEnable);
     return STATUS_SUCCESS;
 }
@@ -30864,8 +30192,6 @@ static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
 {
     struct vkCmdSetPatchControlPointsEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->patchControlPoints);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
     return STATUS_SUCCESS;
 }
@@ -30879,8 +30205,6 @@ static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
         uint32_t patchControlPoints;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->patchControlPoints);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->patchControlPoints);
     return STATUS_SUCCESS;
 }
@@ -30977,8 +30301,6 @@ static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
 {
     struct vkCmdSetPolygonModeEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->polygonMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
     return STATUS_SUCCESS;
 }
@@ -30992,8 +30314,6 @@ static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
         VkPolygonMode polygonMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->polygonMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->polygonMode);
     return STATUS_SUCCESS;
 }
@@ -31003,8 +30323,6 @@ static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
 {
     struct vkCmdSetPrimitiveRestartEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }
@@ -31018,8 +30336,6 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
         VkBool32 primitiveRestartEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }
@@ -31029,8 +30345,6 @@ static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
 {
     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->primitiveRestartEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }
@@ -31044,8 +30358,6 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
         VkBool32 primitiveRestartEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->primitiveRestartEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
     return STATUS_SUCCESS;
 }
@@ -31055,8 +30367,6 @@ static NTSTATUS thunk64_vkCmdSetPrimitiveTopology(void *args)
 {
     struct vkCmdSetPrimitiveTopology_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }
@@ -31070,8 +30380,6 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
         VkPrimitiveTopology primitiveTopology;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }
@@ -31081,8 +30389,6 @@ static NTSTATUS thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
 {
     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->primitiveTopology);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }
@@ -31096,8 +30402,6 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
         VkPrimitiveTopology primitiveTopology;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->primitiveTopology);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
     return STATUS_SUCCESS;
 }
@@ -31107,8 +30411,6 @@ static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
 {
     struct vkCmdSetProvokingVertexModeEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->provokingVertexMode);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
     return STATUS_SUCCESS;
 }
@@ -31122,8 +30424,6 @@ static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
         VkProvokingVertexModeEXT provokingVertexMode;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->provokingVertexMode);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->provokingVertexMode);
     return STATUS_SUCCESS;
 }
@@ -31133,8 +30433,6 @@ static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
 {
     struct vkCmdSetRasterizationSamplesEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->rasterizationSamples);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
     return STATUS_SUCCESS;
 }
@@ -31148,8 +30446,6 @@ static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
         VkSampleCountFlagBits rasterizationSamples;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->rasterizationSamples);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationSamples);
     return STATUS_SUCCESS;
 }
@@ -31159,8 +30455,6 @@ static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
 {
     struct vkCmdSetRasterizationStreamEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizationStream);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
     return STATUS_SUCCESS;
 }
@@ -31174,8 +30468,6 @@ static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
         uint32_t rasterizationStream;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizationStream);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationStream);
     return STATUS_SUCCESS;
 }
@@ -31185,8 +30477,6 @@ static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
 {
     struct vkCmdSetRasterizerDiscardEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }
@@ -31200,8 +30490,6 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
         VkBool32 rasterizerDiscardEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }
@@ -31211,8 +30499,6 @@ static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
 {
     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }
@@ -31226,8 +30512,6 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
         VkBool32 rasterizerDiscardEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->rasterizerDiscardEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
     return STATUS_SUCCESS;
 }
@@ -31237,8 +30521,6 @@ static NTSTATUS thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
 {
     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->pipelineStackSize);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
     return STATUS_SUCCESS;
 }
@@ -31252,8 +30534,6 @@ static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
         uint32_t pipelineStackSize;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->pipelineStackSize);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStackSize);
     return STATUS_SUCCESS;
 }
@@ -31263,8 +30543,6 @@ static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
 {
     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31278,8 +30556,6 @@ static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
         VkBool32 representativeFragmentTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->representativeFragmentTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->representativeFragmentTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31289,8 +30565,6 @@ static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
 {
     struct vkCmdSetSampleLocationsEXT_params *params = args;

-    TRACE("%p, %p\n", params->commandBuffer, params->pSampleLocationsInfo);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
     return STATUS_SUCCESS;
 }
@@ -31305,8 +30579,6 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
     } *params = args;
     VkSampleLocationsInfoEXT pSampleLocationsInfo_host;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->pSampleLocationsInfo);
-
     convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSampleLocationsInfo_host);
     return STATUS_SUCCESS;
@@ -31317,8 +30589,6 @@ static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
 {
     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->sampleLocationsEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
     return STATUS_SUCCESS;
 }
@@ -31332,8 +30602,6 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
         VkBool32 sampleLocationsEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->sampleLocationsEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleLocationsEnable);
     return STATUS_SUCCESS;
 }
@@ -31343,8 +30611,6 @@ static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
 {
     struct vkCmdSetSampleMaskEXT_params *params = args;

-    TRACE("%p, %#x, %p\n", params->commandBuffer, params->samples, params->pSampleMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
     return STATUS_SUCCESS;
 }
@@ -31359,8 +30625,6 @@ static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
         PTR32 pSampleMask;
     } *params = args;

-    TRACE("%#x, %#x, %#x\n", params->commandBuffer, params->samples, params->pSampleMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->samples, (const VkSampleMask *)UlongToPtr(params->pSampleMask));
     return STATUS_SUCCESS;
 }
@@ -31370,8 +30634,6 @@ static NTSTATUS thunk64_vkCmdSetScissor(void *args)
 {
     struct vkCmdSetScissor_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstScissor, params->scissorCount, params->pScissors);
     return STATUS_SUCCESS;
 }
@@ -31387,8 +30649,6 @@ static NTSTATUS thunk32_vkCmdSetScissor(void *args)
         PTR32 pScissors;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstScissor, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstScissor, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }
@@ -31398,8 +30658,6 @@ static NTSTATUS thunk64_vkCmdSetScissorWithCount(void *args)
 {
     struct vkCmdSetScissorWithCount_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
     return STATUS_SUCCESS;
 }
@@ -31414,8 +30672,6 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
         PTR32 pScissors;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }
@@ -31425,8 +30681,6 @@ static NTSTATUS thunk64_vkCmdSetScissorWithCountEXT(void *args)
 {
     struct vkCmdSetScissorWithCountEXT_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
     return STATUS_SUCCESS;
 }
@@ -31441,8 +30695,6 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
         PTR32 pScissors;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->scissorCount, params->pScissors);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
     return STATUS_SUCCESS;
 }
@@ -31452,8 +30704,6 @@ static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
 {
     struct vkCmdSetShadingRateImageEnableNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->shadingRateImageEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
     return STATUS_SUCCESS;
 }
@@ -31467,8 +30717,6 @@ static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
         VkBool32 shadingRateImageEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->shadingRateImageEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRateImageEnable);
     return STATUS_SUCCESS;
 }
@@ -31478,8 +30726,6 @@ static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
 {
     struct vkCmdSetStencilCompareMask_params *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
     return STATUS_SUCCESS;
 }
@@ -31494,8 +30740,6 @@ static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
         uint32_t compareMask;
     } *params = args;

-    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->compareMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->compareMask);
     return STATUS_SUCCESS;
 }
@@ -31505,8 +30749,6 @@ static NTSTATUS thunk64_vkCmdSetStencilOp(void *args)
 {
     struct vkCmdSetStencilOp_params *params = args;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }
@@ -31524,8 +30766,6 @@ static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
         VkCompareOp compareOp;
     } *params = args;

-    TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }
@@ -31535,8 +30775,6 @@ static NTSTATUS thunk64_vkCmdSetStencilOpEXT(void *args)
 {
     struct vkCmdSetStencilOpEXT_params *params = args;

-    TRACE("%p, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }
@@ -31554,8 +30792,6 @@ static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
         VkCompareOp compareOp;
     } *params = args;

-    TRACE("%#x, %#x, %#x, %#x, %#x, %#x\n", params->commandBuffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
     return STATUS_SUCCESS;
 }
@@ -31565,8 +30801,6 @@ static NTSTATUS thunk64_vkCmdSetStencilReference(void *args)
 {
     struct vkCmdSetStencilReference_params *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
     return STATUS_SUCCESS;
 }
@@ -31581,8 +30815,6 @@ static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
         uint32_t reference;
     } *params = args;

-    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->reference);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->reference);
     return STATUS_SUCCESS;
 }
@@ -31592,8 +30824,6 @@ static NTSTATUS thunk64_vkCmdSetStencilTestEnable(void *args)
 {
     struct vkCmdSetStencilTestEnable_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31607,8 +30837,6 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
         VkBool32 stencilTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31618,8 +30846,6 @@ static NTSTATUS thunk64_vkCmdSetStencilTestEnableEXT(void *args)
 {
     struct vkCmdSetStencilTestEnableEXT_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->stencilTestEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31633,8 +30859,6 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
         VkBool32 stencilTestEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->stencilTestEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
     return STATUS_SUCCESS;
 }
@@ -31644,8 +30868,6 @@ static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
 {
     struct vkCmdSetStencilWriteMask_params *params = args;

-    TRACE("%p, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
     return STATUS_SUCCESS;
 }
@@ -31660,8 +30882,6 @@ static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
         uint32_t writeMask;
     } *params = args;

-    TRACE("%#x, %#x, %u\n", params->commandBuffer, params->faceMask, params->writeMask);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->writeMask);
     return STATUS_SUCCESS;
 }
@@ -31671,8 +30891,6 @@ static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;

-    TRACE("%p, %#x\n", params->commandBuffer, params->domainOrigin);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
     return STATUS_SUCCESS;
 }
@@ -31686,8 +30904,6 @@ static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
         VkTessellationDomainOrigin domainOrigin;
     } *params = args;

-    TRACE("%#x, %#x\n", params->commandBuffer, params->domainOrigin);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->domainOrigin);
     return STATUS_SUCCESS;
 }
@@ -31697,8 +30913,6 @@ static NTSTATUS thunk64_vkCmdSetVertexInputEXT(void *args)
 {
     struct vkCmdSetVertexInputEXT_params *params = args;

-    TRACE("%p, %u, %p, %u, %p\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
     return STATUS_SUCCESS;
 }
@@ -31718,8 +30932,6 @@ static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
     const VkVertexInputAttributeDescription2EXT *pVertexAttributeDescriptions_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
-
     init_conversion_context(&ctx);
     pVertexBindingDescriptions_host = convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputBindingDescription2EXT32 *)UlongToPtr(params->pVertexBindingDescriptions), params->vertexBindingDescriptionCount);
     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
@@ -31733,8 +30945,6 @@ static NTSTATUS thunk64_vkCmdSetViewport(void *args)
 {
     struct vkCmdSetViewport_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewports);
     return STATUS_SUCCESS;
 }
@@ -31750,8 +30960,6 @@ static NTSTATUS thunk32_vkCmdSetViewport(void *args)
         PTR32 pViewports;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }
@@ -31761,8 +30969,6 @@ static NTSTATUS thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
 {
     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
     return STATUS_SUCCESS;
 }
@@ -31780,8 +30986,6 @@ static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
     const VkShadingRatePaletteNV *pShadingRatePalettes_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
-
     init_conversion_context(&ctx);
     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, pShadingRatePalettes_host);
@@ -31794,8 +30998,6 @@ static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
 {
     struct vkCmdSetViewportSwizzleNV_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
     return STATUS_SUCCESS;
 }
@@ -31811,8 +31013,6 @@ static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
         PTR32 pViewportSwizzles;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportSwizzleNV *)UlongToPtr(params->pViewportSwizzles));
     return STATUS_SUCCESS;
 }
@@ -31822,8 +31022,6 @@ static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
 {
     struct vkCmdSetViewportWScalingEnableNV_params *params = args;

-    TRACE("%p, %u\n", params->commandBuffer, params->viewportWScalingEnable);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
     return STATUS_SUCCESS;
 }
@@ -31837,8 +31035,6 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
         VkBool32 viewportWScalingEnable;
     } *params = args;

-    TRACE("%#x, %u\n", params->commandBuffer, params->viewportWScalingEnable);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportWScalingEnable);
     return STATUS_SUCCESS;
 }
@@ -31848,8 +31044,6 @@ static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
 {
     struct vkCmdSetViewportWScalingNV_params *params = args;

-    TRACE("%p, %u, %u, %p\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
     return STATUS_SUCCESS;
 }
@@ -31865,8 +31059,6 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
         PTR32 pViewportWScalings;
     } *params = args;

-    TRACE("%#x, %u, %u, %#x\n", params->commandBuffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportWScalingNV *)UlongToPtr(params->pViewportWScalings));
     return STATUS_SUCCESS;
 }
@@ -31876,8 +31068,6 @@ static NTSTATUS thunk64_vkCmdSetViewportWithCount(void *args)
 {
     struct vkCmdSetViewportWithCount_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
     return STATUS_SUCCESS;
 }
@@ -31892,8 +31082,6 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
         PTR32 pViewports;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }
@@ -31903,8 +31091,6 @@ static NTSTATUS thunk64_vkCmdSetViewportWithCountEXT(void *args)
 {
     struct vkCmdSetViewportWithCountEXT_params *params = args;

-    TRACE("%p, %u, %p\n", params->commandBuffer, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
     return STATUS_SUCCESS;
 }
@@ -31919,8 +31105,6 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
         PTR32 pViewports;
     } *params = args;

-    TRACE("%#x, %u, %#x\n", params->commandBuffer, params->viewportCount, params->pViewports);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
     return STATUS_SUCCESS;
 }
@@ -31930,8 +31114,6 @@ static NTSTATUS thunk64_vkCmdSubpassShadingHUAWEI(void *args)
 {
     struct vkCmdSubpassShadingHUAWEI_params *params = args;

-    TRACE("%p\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -31944,8 +31126,6 @@ static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
         PTR32 commandBuffer;
     } *params = args;

-    TRACE("%#x\n", params->commandBuffer);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer);
     return STATUS_SUCCESS;
 }
@@ -31955,8 +31135,6 @@ static NTSTATUS thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
 {
     struct vkCmdTraceRaysIndirect2KHR_params *params = args;

-    TRACE("%p, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
     return STATUS_SUCCESS;
 }
@@ -31970,8 +31148,6 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
         VkDeviceAddress DECLSPEC_ALIGN(8) indirectDeviceAddress;
     } *params = args;

-    TRACE("%#x, 0x%s\n", params->commandBuffer, wine_dbgstr_longlong(params->indirectDeviceAddress));
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectDeviceAddress);
     return STATUS_SUCCESS;
 }
@@ -31981,8 +31157,6 @@ static NTSTATUS thunk64_vkCmdTraceRaysIndirectKHR(void *args)
 {
     struct vkCmdTraceRaysIndirectKHR_params *params = args;

-    TRACE("%p, %p, %p, %p, %p, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->indirectDeviceAddress);
     return STATUS_SUCCESS;
 }
@@ -32004,8 +31178,6 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;

-    TRACE("%#x, %#x, %#x, %#x, %#x, 0x%s\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, wine_dbgstr_longlong(params->indirectDeviceAddress));
-
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
@@ -32019,8 +31191,6 @@ static NTSTATUS thunk64_vkCmdTraceRaysKHR(void *args)
 {
     struct vkCmdTraceRaysKHR_params *params = args;

-    TRACE("%p, %p, %p, %p, %p, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
     return STATUS_SUCCESS;
 }
@@ -32044,8 +31214,6 @@ static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
     VkStridedDeviceAddressRegionKHR pHitShaderBindingTable_host;
     VkStridedDeviceAddressRegionKHR pCallableShaderBindingTable_host;

-    TRACE("%#x, %#x, %#x, %#x, %#x, %u, %u, %u\n", params->commandBuffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
-
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pRaygenShaderBindingTable), &pRaygenShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pMissShaderBindingTable), &pMissShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
@@ -32059,8 +31227,6 @@ static NTSTATUS thunk64_vkCmdTraceRaysNV(void *args)
 {
     struct vkCmdTraceRaysNV_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
     return STATUS_SUCCESS;
 }
@@ -32087,8 +31253,6 @@ static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
         uint32_t depth;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, %u, %u, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->raygenShaderBindingTableBuffer), wine_dbgstr_longlong(params->raygenShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingTableBuffer), wine_dbgstr_longlong(params->missShaderBindingOffset), wine_dbgstr_longlong(params->missShaderBindingStride), wine_dbgstr_longlong(params->hitShaderBindingTableBuffer), wine_dbgstr_longlong(params->hitShaderBindingOffset), wine_dbgstr_longlong(params->hitShaderBindingStride), wine_dbgstr_longlong(params->callableShaderBindingTableBuffer), wine_dbgstr_longlong(params->callableShaderBindingOffset), wine_dbgstr_longlong(params->callableShaderBindingStride), params->width, params->height, params->depth);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
     return STATUS_SUCCESS;
 }
@@ -32098,8 +31262,6 @@ static NTSTATUS thunk64_vkCmdUpdateBuffer(void *args)
 {
     struct vkCmdUpdateBuffer_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %p\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, params->pData);
     return STATUS_SUCCESS;
 }
@@ -32116,8 +31278,6 @@ static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
         PTR32 pData;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, %#x\n", params->commandBuffer, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), wine_dbgstr_longlong(params->dataSize), params->pData);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }
@@ -32127,8 +31287,6 @@ static NTSTATUS thunk64_vkCmdWaitEvents(void *args)
 {
     struct vkCmdWaitEvents_params *params = args;

-    TRACE("%p, %u, %p, %#x, %#x, %u, %p, %u, %p, %u, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
     return STATUS_SUCCESS;
 }
@@ -32155,8 +31313,6 @@ static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
     const VkImageMemoryBarrier *pImageMemoryBarriers_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %#x, %#x, %u, %#x, %u, %#x, %u, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-
     init_conversion_context(&ctx);
     pMemoryBarriers_host = convert_VkMemoryBarrier_array_win32_to_host(&ctx, (const VkMemoryBarrier32 *)UlongToPtr(params->pMemoryBarriers), params->memoryBarrierCount);
     pBufferMemoryBarriers_host = convert_VkBufferMemoryBarrier_array_win32_to_host(&ctx, (const VkBufferMemoryBarrier32 *)UlongToPtr(params->pBufferMemoryBarriers), params->bufferMemoryBarrierCount);
@@ -32171,8 +31327,6 @@ static NTSTATUS thunk64_vkCmdWaitEvents2(void *args)
 {
     struct vkCmdWaitEvents2_params *params = args;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
     return STATUS_SUCCESS;
 }
@@ -32190,8 +31344,6 @@ static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
     const VkDependencyInfo *pDependencyInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-
     init_conversion_context(&ctx);
     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
@@ -32204,8 +31356,6 @@ static NTSTATUS thunk64_vkCmdWaitEvents2KHR(void *args)
 {
     struct vkCmdWaitEvents2KHR_params *params = args;

-    TRACE("%p, %u, %p, %p\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
     return STATUS_SUCCESS;
 }
@@ -32223,8 +31373,6 @@ static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
     const VkDependencyInfo *pDependencyInfos_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %#x\n", params->commandBuffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-
     init_conversion_context(&ctx);
     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
@@ -32237,8 +31385,6 @@ static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args
 {
     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32256,8 +31402,6 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32267,8 +31411,6 @@ static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
 {
     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32286,8 +31428,6 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32297,8 +31437,6 @@ static NTSTATUS thunk64_vkCmdWriteBufferMarker2AMD(void *args)
 {
     struct vkCmdWriteBufferMarker2AMD_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }
@@ -32315,8 +31453,6 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
         uint32_t marker;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }
@@ -32326,8 +31462,6 @@ static NTSTATUS thunk64_vkCmdWriteBufferMarkerAMD(void *args)
 {
     struct vkCmdWriteBufferMarkerAMD_params *params = args;

-    TRACE("%p, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }
@@ -32344,8 +31478,6 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
         uint32_t marker;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->dstBuffer), wine_dbgstr_longlong(params->dstOffset), params->marker);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
     return STATUS_SUCCESS;
 }
@@ -32355,8 +31487,6 @@ static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
 {
     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;

-    TRACE("%p, %u, %p, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32374,8 +31504,6 @@ static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
         uint32_t firstQuery;
     } *params = args;

-    TRACE("%#x, %u, %#x, %#x, 0x%s, %u\n", params->commandBuffer, params->micromapCount, params->pMicromaps, params->queryType, wine_dbgstr_longlong(params->queryPool), params->firstQuery);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->queryPool, params->firstQuery);
     return STATUS_SUCCESS;
 }
@@ -32385,8 +31513,6 @@ static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
 {
     struct vkCmdWriteTimestamp_params *params = args;

-    TRACE("%p, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -32402,8 +31528,6 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
         uint32_t query;
     } *params = args;

-    TRACE("%#x, %#x, 0x%s, %u\n", params->commandBuffer, params->pipelineStage, wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -32413,8 +31537,6 @@ static NTSTATUS thunk64_vkCmdWriteTimestamp2(void *args)
 {
     struct vkCmdWriteTimestamp2_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -32430,8 +31552,6 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
         uint32_t query;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -32441,8 +31561,6 @@ static NTSTATUS thunk64_vkCmdWriteTimestamp2KHR(void *args)
 {
     struct vkCmdWriteTimestamp2KHR_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -32458,8 +31576,6 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
         uint32_t query;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %u\n", params->commandBuffer, wine_dbgstr_longlong(params->stage), wine_dbgstr_longlong(params->queryPool), params->query);
-
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->queryPool, params->query);
     return STATUS_SUCCESS;
 }
@@ -36307,8 +35423,6 @@ static NTSTATUS thunk64_vkGetDescriptorEXT(void *args)
 {
     struct vkGetDescriptorEXT_params *params = args;

-    TRACE("%p, %p, 0x%s, %p\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor);
-
     wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
     return STATUS_SUCCESS;
 }
@@ -36326,8 +35440,6 @@ static NTSTATUS thunk32_vkGetDescriptorEXT(void *args)
     VkDescriptorGetInfoEXT pDescriptorInfo_host;
     struct conversion_context ctx;

-    TRACE("%#x, %#x, 0x%s, %#x\n", params->device, params->pDescriptorInfo, wine_dbgstr_longlong(params->dataSize), params->pDescriptor);
-
     init_conversion_context(&ctx);
     convert_VkDescriptorGetInfoEXT_win32_to_host(&ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDescriptorInfo_host, params->dataSize, (void *)UlongToPtr(params->pDescriptor));
@@ -41044,8 +40156,6 @@ static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
 {
     struct vkUpdateDescriptorSetWithTemplate_params *params = args;

-    TRACE("%p, 0x%s, 0x%s, %p\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
-
     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
     return STATUS_SUCCESS;
 }
@@ -41061,8 +40171,6 @@ static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
         PTR32 pData;
     } *params = args;

-    TRACE("%#x, 0x%s, 0x%s, %#x\n", params->device, wine_dbgstr_longlong(params->descriptorSet), wine_dbgstr_longlong(params->descriptorUpdateTemplate), params->pData);
-
     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
     return STATUS_SUCCESS;
 }
@@ -41100,8 +40208,6 @@ static NTSTATUS thunk64_vkUpdateDescriptorSets(void *args)
 {
     struct vkUpdateDescriptorSets_params *params = args;

-    TRACE("%p, %u, %p, %u, %p\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
-
     wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
     return STATUS_SUCCESS;
 }
@@ -41121,8 +40227,6 @@ static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
     const VkCopyDescriptorSet *pDescriptorCopies_host;
     struct conversion_context ctx;

-    TRACE("%#x, %u, %#x, %u, %#x\n", params->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
-
     init_conversion_context(&ctx);
     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);

[PATCH 3/3] winevulkan: Return void for some critical functions.

[Rémi Bernon]

From: Rémi Bernon

Allowing the compiler to generate tail calls for the unix thunks.
---
 dlls/winevulkan/make_vulkan     |   20 +-
 dlls/winevulkan/vulkan_thunks.c | 2240 +++++++++++++------------------
 2 files changed, 911 insertions(+), 1349 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 78a75516baa..801b804745f 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -833,8 +833,9 @@ class VkFunction(object):
         if needs_alloc:
             body += "    free_conversion_context(&ctx);\n"

-        # Finally return the result.
-        body += "    return STATUS_SUCCESS;\n"
+        # Finally return the result. Performance critical functions return void to allow tail calls.
+        if not self.is_perf_critical():
+            body += "    return STATUS_SUCCESS;\n"

return body

@@ -878,7 +879,10 @@ class VkFunction(object):
         thunk = ""
         if not conv:
             thunk += "#ifdef _WIN64\n"
-        thunk += "static NTSTATUS {0}{1}(void *args)\n".format(prefix, self.name)
+        if self.is_perf_critical():
+            thunk += "static void {0}{1}(void *args)\n".format(prefix, self.name)
+        else:
+            thunk += "static NTSTATUS {0}{1}(void *args)\n".format(prefix, self.name)
         thunk += "{\n"
         if conv:
             thunk += "    struct\n"
@@ -2726,7 +2730,10 @@ class VkGenerator(object):
             if vk_func.loader_thunk_type == ThunkType.NONE:
                 continue

-            f.write("    {1}{0},\n".format(vk_func.name, "thunk64_"))
+            if vk_func.is_perf_critical():
+                f.write("    (void *){1}{0},\n".format(vk_func.name, "thunk64_"))
+            else:
+                f.write("    {1}{0},\n".format(vk_func.name, "thunk64_"))
         f.write("};\n")
         f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n\n")

@@ -2747,7 +2754,10 @@ class VkGenerator(object):
             if vk_func.loader_thunk_type == ThunkType.NONE:
                 continue

-            f.write("    {1}{0},\n".format(vk_func.name, "thunk32_"))
+            if vk_func.is_perf_critical():
+                f.write("    (void *){1}{0},\n".format(vk_func.name, "thunk32_"))
+            else:
+                f.write("    {1}{0},\n".format(vk_func.name, "thunk32_"))
         f.write("};\n")
         f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n")

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 9e91f766327..8cf554b6fff 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -25984,16 +25984,15 @@ static NTSTATUS thunk32_vkBuildMicromapsEXT(void *args)
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
+static void thunk64_vkCmdBeginConditionalRenderingEXT(void *args)
 {
     struct vkCmdBeginConditionalRenderingEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pConditionalRenderingBegin);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
+static void thunk32_vkCmdBeginConditionalRenderingEXT(void *args)
 {
     struct
     {
@@ -26004,20 +26003,18 @@ static NTSTATUS thunk32_vkCmdBeginConditionalRenderingEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
+static void thunk64_vkCmdBeginDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdBeginDebugUtilsLabelEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
+static void thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)
 {
     struct
     {
@@ -26028,20 +26025,18 @@ static NTSTATUS thunk32_vkCmdBeginDebugUtilsLabelEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginQuery(void *args)
+static void thunk64_vkCmdBeginQuery(void *args)
 {
     struct vkCmdBeginQuery_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
+static void thunk32_vkCmdBeginQuery(void *args)
 {
     struct
     {
@@ -26052,20 +26047,18 @@ static NTSTATUS thunk32_vkCmdBeginQuery(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginQueryIndexedEXT(void *args)
+static void thunk64_vkCmdBeginQueryIndexedEXT(void *args)
 {
     struct vkCmdBeginQueryIndexedEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->flags, params->index);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
+static void thunk32_vkCmdBeginQueryIndexedEXT(void *args)
 {
     struct
     {
@@ -26077,20 +26070,18 @@ static NTSTATUS thunk32_vkCmdBeginQueryIndexedEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginRenderPass(void *args)
+static void thunk64_vkCmdBeginRenderPass(void *args)
 {
     struct vkCmdBeginRenderPass_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->contents);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
+static void thunk32_vkCmdBeginRenderPass(void *args)
 {
     struct
     {
@@ -26105,20 +26096,18 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass(void *args)
     convert_VkRenderPassBeginInfo_win32_to_host(&ctx, (const VkRenderPassBeginInfo32 *)UlongToPtr(params->pRenderPassBegin), &pRenderPassBegin_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, params->contents);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginRenderPass2(void *args)
+static void thunk64_vkCmdBeginRenderPass2(void *args)
 {
     struct vkCmdBeginRenderPass2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
+static void thunk32_vkCmdBeginRenderPass2(void *args)
 {
     struct
     {
@@ -26135,20 +26124,18 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2(void *args)
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginRenderPass2KHR(void *args)
+static void thunk64_vkCmdBeginRenderPass2KHR(void *args)
 {
     struct vkCmdBeginRenderPass2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderPassBegin, params->pSubpassBeginInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
+static void thunk32_vkCmdBeginRenderPass2KHR(void *args)
 {
     struct
     {
@@ -26165,20 +26152,18 @@ static NTSTATUS thunk32_vkCmdBeginRenderPass2KHR(void *args)
     convert_VkSubpassBeginInfo_win32_to_host((const VkSubpassBeginInfo32 *)UlongToPtr(params->pSubpassBeginInfo), &pSubpassBeginInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderPassBegin_host, &pSubpassBeginInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginRendering(void *args)
+static void thunk64_vkCmdBeginRendering(void *args)
 {
     struct vkCmdBeginRendering_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
+static void thunk32_vkCmdBeginRendering(void *args)
 {
     struct
     {
@@ -26192,20 +26177,18 @@ static NTSTATUS thunk32_vkCmdBeginRendering(void *args)
     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRendering(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginRenderingKHR(void *args)
+static void thunk64_vkCmdBeginRenderingKHR(void *args)
 {
     struct vkCmdBeginRenderingKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRenderingInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
+static void thunk32_vkCmdBeginRenderingKHR(void *args)
 {
     struct
     {
@@ -26219,20 +26202,18 @@ static NTSTATUS thunk32_vkCmdBeginRenderingKHR(void *args)
     convert_VkRenderingInfo_win32_to_host(&ctx, (const VkRenderingInfo32 *)UlongToPtr(params->pRenderingInfo), &pRenderingInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBeginRenderingKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRenderingInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
+static void thunk64_vkCmdBeginTransformFeedbackEXT(void *args)
 {
     struct vkCmdBeginTransformFeedbackEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBeginTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
+static void thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
 {
     struct
     {
@@ -26244,20 +26225,18 @@ static NTSTATUS thunk32_vkCmdBeginTransformFeedbackEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
+static void thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
 {
     struct vkCmdBindDescriptorBufferEmbeddedSamplersEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
+static void thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
 {
     struct
     {
@@ -26268,20 +26247,18 @@ static NTSTATUS thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
+static void thunk64_vkCmdBindDescriptorBuffersEXT(void *args)
 {
     struct vkCmdBindDescriptorBuffersEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->bufferCount, params->pBindingInfos);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
+static void thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
 {
     struct
     {
@@ -26296,20 +26273,18 @@ static NTSTATUS thunk32_vkCmdBindDescriptorBuffersEXT(void *args)
     pBindingInfos_host = convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(&ctx, (const VkDescriptorBufferBindingInfoEXT32 *)UlongToPtr(params->pBindingInfos), params->bufferCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBindDescriptorBuffersEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->bufferCount, pBindingInfos_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindDescriptorSets(void *args)
+static void thunk64_vkCmdBindDescriptorSets(void *args)
 {
     struct vkCmdBindDescriptorSets_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindDescriptorSets(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->descriptorSetCount, params->pDescriptorSets, params->dynamicOffsetCount, params->pDynamicOffsets);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
+static void thunk32_vkCmdBindDescriptorSets(void *args)
 {
     struct
     {
@@ -26324,20 +26299,18 @@ static NTSTATUS thunk32_vkCmdBindDescriptorSets(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindIndexBuffer(void *args)
+static void thunk64_vkCmdBindIndexBuffer(void *args)
 {
     struct vkCmdBindIndexBuffer_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindIndexBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->indexType);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
+static void thunk32_vkCmdBindIndexBuffer(void *args)
 {
     struct
     {
@@ -26348,20 +26321,18 @@ static NTSTATUS thunk32_vkCmdBindIndexBuffer(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
+static void thunk64_vkCmdBindInvocationMaskHUAWEI(void *args)
 {
     struct vkCmdBindInvocationMaskHUAWEI_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindInvocationMaskHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
+static void thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
 {
     struct
     {
@@ -26371,20 +26342,18 @@ static NTSTATUS thunk32_vkCmdBindInvocationMaskHUAWEI(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindPipeline(void *args)
+static void thunk64_vkCmdBindPipeline(void *args)
 {
     struct vkCmdBindPipeline_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipeline(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
+static void thunk32_vkCmdBindPipeline(void *args)
 {
     struct
     {
@@ -26394,20 +26363,18 @@ static NTSTATUS thunk32_vkCmdBindPipeline(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
+static void thunk64_vkCmdBindPipelineShaderGroupNV(void *args)
 {
     struct vkCmdBindPipelineShaderGroupNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindPipelineShaderGroupNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->pipeline, params->groupIndex);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
+static void thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
 {
     struct
     {
@@ -26418,20 +26385,18 @@ static NTSTATUS thunk32_vkCmdBindPipelineShaderGroupNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindShadingRateImageNV(void *args)
+static void thunk64_vkCmdBindShadingRateImageNV(void *args)
 {
     struct vkCmdBindShadingRateImageNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindShadingRateImageNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->imageView, params->imageLayout);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
+static void thunk32_vkCmdBindShadingRateImageNV(void *args)
 {
     struct
     {
@@ -26441,20 +26406,18 @@ static NTSTATUS thunk32_vkCmdBindShadingRateImageNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
+static void thunk64_vkCmdBindTransformFeedbackBuffersEXT(void *args)
 {
     struct vkCmdBindTransformFeedbackBuffersEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindTransformFeedbackBuffersEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
+static void thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
 {
     struct
     {
@@ -26467,20 +26430,18 @@ static NTSTATUS thunk32_vkCmdBindTransformFeedbackBuffersEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindVertexBuffers(void *args)
+static void thunk64_vkCmdBindVertexBuffers(void *args)
 {
     struct vkCmdBindVertexBuffers_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
+static void thunk32_vkCmdBindVertexBuffers(void *args)
 {
     struct
     {
@@ -26492,20 +26453,18 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindVertexBuffers2(void *args)
+static void thunk64_vkCmdBindVertexBuffers2(void *args)
 {
     struct vkCmdBindVertexBuffers2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
+static void thunk32_vkCmdBindVertexBuffers2(void *args)
 {
     struct
     {
@@ -26519,20 +26478,18 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBindVertexBuffers2EXT(void *args)
+static void thunk64_vkCmdBindVertexBuffers2EXT(void *args)
 {
     struct vkCmdBindVertexBuffers2EXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBindVertexBuffers2EXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstBinding, params->bindingCount, params->pBuffers, params->pOffsets, params->pSizes, params->pStrides);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
+static void thunk32_vkCmdBindVertexBuffers2EXT(void *args)
 {
     struct
     {
@@ -26546,20 +26503,18 @@ static NTSTATUS thunk32_vkCmdBindVertexBuffers2EXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBlitImage(void *args)
+static void thunk64_vkCmdBlitImage(void *args)
 {
     struct vkCmdBlitImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions, params->filter);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBlitImage(void *args)
+static void thunk32_vkCmdBlitImage(void *args)
 {
     struct
     {
@@ -26574,20 +26529,18 @@ static NTSTATUS thunk32_vkCmdBlitImage(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBlitImage2(void *args)
+static void thunk64_vkCmdBlitImage2(void *args)
 {
     struct vkCmdBlitImage2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
+static void thunk32_vkCmdBlitImage2(void *args)
 {
     struct
     {
@@ -26601,20 +26554,18 @@ static NTSTATUS thunk32_vkCmdBlitImage2(void *args)
     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBlitImage2KHR(void *args)
+static void thunk64_vkCmdBlitImage2KHR(void *args)
 {
     struct vkCmdBlitImage2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pBlitImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
+static void thunk32_vkCmdBlitImage2KHR(void *args)
 {
     struct
     {
@@ -26628,20 +26579,18 @@ static NTSTATUS thunk32_vkCmdBlitImage2KHR(void *args)
     convert_VkBlitImageInfo2_win32_to_host(&ctx, (const VkBlitImageInfo232 *)UlongToPtr(params->pBlitImageInfo), &pBlitImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBlitImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pBlitImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBuildAccelerationStructureNV(void *args)
+static void thunk64_vkCmdBuildAccelerationStructureNV(void *args)
 {
     struct vkCmdBuildAccelerationStructureNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
+static void thunk32_vkCmdBuildAccelerationStructureNV(void *args)
 {
     struct
     {
@@ -26662,20 +26611,18 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructureNV(void *args)
     convert_VkAccelerationStructureInfoNV_win32_to_host(&ctx, (const VkAccelerationStructureInfoNV32 *)UlongToPtr(params->pInfo), &pInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructureNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pInfo_host, params->instanceData, params->instanceOffset, params->update, params->dst, params->src, params->scratch, params->scratchOffset);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
+static void thunk64_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
 {
     struct vkCmdBuildAccelerationStructuresIndirectKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->pIndirectDeviceAddresses, params->pIndirectStrides, params->ppMaxPrimitiveCounts);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
+static void thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
 {
     struct
     {
@@ -26693,20 +26640,18 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresIndirectKHR(void *args)
     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkDeviceAddress *)UlongToPtr(params->pIndirectDeviceAddresses), (const uint32_t *)UlongToPtr(params->pIndirectStrides), (const uint32_t * const*)UlongToPtr(params->ppMaxPrimitiveCounts));
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
+static void thunk64_vkCmdBuildAccelerationStructuresKHR(void *args)
 {
     struct vkCmdBuildAccelerationStructuresKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos, params->ppBuildRangeInfos);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
+static void thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
 {
     struct
     {
@@ -26722,20 +26667,18 @@ static NTSTATUS thunk32_vkCmdBuildAccelerationStructuresKHR(void *args)
     pInfos_host = convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(&ctx, (const VkAccelerationStructureBuildGeometryInfoKHR32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildAccelerationStructuresKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host, (const VkAccelerationStructureBuildRangeInfoKHR * const*)UlongToPtr(params->ppBuildRangeInfos));
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdBuildMicromapsEXT(void *args)
+static void thunk64_vkCmdBuildMicromapsEXT(void *args)
 {
     struct vkCmdBuildMicromapsEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->infoCount, params->pInfos);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
+static void thunk32_vkCmdBuildMicromapsEXT(void *args)
 {
     struct
     {
@@ -26750,20 +26693,18 @@ static NTSTATUS thunk32_vkCmdBuildMicromapsEXT(void *args)
     pInfos_host = convert_VkMicromapBuildInfoEXT_array_win32_to_host(&ctx, (const VkMicromapBuildInfoEXT32 *)UlongToPtr(params->pInfos), params->infoCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdBuildMicromapsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->infoCount, pInfos_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdClearAttachments(void *args)
+static void thunk64_vkCmdClearAttachments(void *args)
 {
     struct vkCmdClearAttachments_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearAttachments(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pAttachments, params->rectCount, params->pRects);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
+static void thunk32_vkCmdClearAttachments(void *args)
 {
     struct
     {
@@ -26775,20 +26716,18 @@ static NTSTATUS thunk32_vkCmdClearAttachments(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdClearColorImage(void *args)
+static void thunk64_vkCmdClearColorImage(void *args)
 {
     struct vkCmdClearColorImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearColorImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pColor, params->rangeCount, params->pRanges);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
+static void thunk32_vkCmdClearColorImage(void *args)
 {
     struct
     {
@@ -26801,20 +26740,18 @@ static NTSTATUS thunk32_vkCmdClearColorImage(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdClearDepthStencilImage(void *args)
+static void thunk64_vkCmdClearDepthStencilImage(void *args)
 {
     struct vkCmdClearDepthStencilImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdClearDepthStencilImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->image, params->imageLayout, params->pDepthStencil, params->rangeCount, params->pRanges);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
+static void thunk32_vkCmdClearDepthStencilImage(void *args)
 {
     struct
     {
@@ -26827,20 +26764,18 @@ static NTSTATUS thunk32_vkCmdClearDepthStencilImage(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
+static void thunk64_vkCmdCopyAccelerationStructureKHR(void *args)
 {
     struct vkCmdCopyAccelerationStructureKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
+static void thunk32_vkCmdCopyAccelerationStructureKHR(void *args)
 {
     struct
     {
@@ -26851,20 +26786,18 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureKHR(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyAccelerationStructureNV(void *args)
+static void thunk64_vkCmdCopyAccelerationStructureNV(void *args)
 {
     struct vkCmdCopyAccelerationStructureNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dst, params->src, params->mode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
+static void thunk32_vkCmdCopyAccelerationStructureNV(void *args)
 {
     struct
     {
@@ -26875,20 +26808,18 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
+static void thunk64_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct vkCmdCopyAccelerationStructureToMemoryKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyAccelerationStructureToMemoryKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
+static void thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)
 {
     struct
     {
@@ -26899,20 +26830,18 @@ static NTSTATUS thunk32_vkCmdCopyAccelerationStructureToMemoryKHR(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBuffer(void *args)
+static void thunk64_vkCmdCopyBuffer(void *args)
 {
     struct vkCmdCopyBuffer_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, params->pRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
+static void thunk32_vkCmdCopyBuffer(void *args)
 {
     struct
     {
@@ -26929,20 +26858,18 @@ static NTSTATUS thunk32_vkCmdCopyBuffer(void *args)
     pRegions_host = convert_VkBufferCopy_array_win32_to_host(&ctx, (const VkBufferCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstBuffer, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBuffer2(void *args)
+static void thunk64_vkCmdCopyBuffer2(void *args)
 {
     struct vkCmdCopyBuffer2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
+static void thunk32_vkCmdCopyBuffer2(void *args)
 {
     struct
     {
@@ -26956,20 +26883,18 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2(void *args)
     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBuffer2KHR(void *args)
+static void thunk64_vkCmdCopyBuffer2KHR(void *args)
 {
     struct vkCmdCopyBuffer2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
+static void thunk32_vkCmdCopyBuffer2KHR(void *args)
 {
     struct
     {
@@ -26983,20 +26908,18 @@ static NTSTATUS thunk32_vkCmdCopyBuffer2KHR(void *args)
     convert_VkCopyBufferInfo2_win32_to_host(&ctx, (const VkCopyBufferInfo232 *)UlongToPtr(params->pCopyBufferInfo), &pCopyBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBufferToImage(void *args)
+static void thunk64_vkCmdCopyBufferToImage(void *args)
 {
     struct vkCmdCopyBufferToImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
+static void thunk32_vkCmdCopyBufferToImage(void *args)
 {
     struct
     {
@@ -27014,20 +26937,18 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage(void *args)
     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcBuffer, params->dstImage, params->dstImageLayout, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBufferToImage2(void *args)
+static void thunk64_vkCmdCopyBufferToImage2(void *args)
 {
     struct vkCmdCopyBufferToImage2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
+static void thunk32_vkCmdCopyBufferToImage2(void *args)
 {
     struct
     {
@@ -27041,20 +26962,18 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2(void *args)
     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyBufferToImage2KHR(void *args)
+static void thunk64_vkCmdCopyBufferToImage2KHR(void *args)
 {
     struct vkCmdCopyBufferToImage2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyBufferToImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
+static void thunk32_vkCmdCopyBufferToImage2KHR(void *args)
 {
     struct
     {
@@ -27068,20 +26987,18 @@ static NTSTATUS thunk32_vkCmdCopyBufferToImage2KHR(void *args)
     convert_VkCopyBufferToImageInfo2_win32_to_host(&ctx, (const VkCopyBufferToImageInfo232 *)UlongToPtr(params->pCopyBufferToImageInfo), &pCopyBufferToImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyBufferToImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyBufferToImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImage(void *args)
+static void thunk64_vkCmdCopyImage(void *args)
 {
     struct vkCmdCopyImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImage(void *args)
+static void thunk32_vkCmdCopyImage(void *args)
 {
     struct
     {
@@ -27095,20 +27012,18 @@ static NTSTATUS thunk32_vkCmdCopyImage(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImage2(void *args)
+static void thunk64_vkCmdCopyImage2(void *args)
 {
     struct vkCmdCopyImage2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
+static void thunk32_vkCmdCopyImage2(void *args)
 {
     struct
     {
@@ -27122,20 +27037,18 @@ static NTSTATUS thunk32_vkCmdCopyImage2(void *args)
     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImage2KHR(void *args)
+static void thunk64_vkCmdCopyImage2KHR(void *args)
 {
     struct vkCmdCopyImage2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
+static void thunk32_vkCmdCopyImage2KHR(void *args)
 {
     struct
     {
@@ -27149,20 +27062,18 @@ static NTSTATUS thunk32_vkCmdCopyImage2KHR(void *args)
     convert_VkCopyImageInfo2_win32_to_host(&ctx, (const VkCopyImageInfo232 *)UlongToPtr(params->pCopyImageInfo), &pCopyImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImageToBuffer(void *args)
+static void thunk64_vkCmdCopyImageToBuffer(void *args)
 {
     struct vkCmdCopyImageToBuffer_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, params->pRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
+static void thunk32_vkCmdCopyImageToBuffer(void *args)
 {
     struct
     {
@@ -27180,20 +27091,18 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer(void *args)
     pRegions_host = convert_VkBufferImageCopy_array_win32_to_host(&ctx, (const VkBufferImageCopy32 *)UlongToPtr(params->pRegions), params->regionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcImage, params->srcImageLayout, params->dstBuffer, params->regionCount, pRegions_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImageToBuffer2(void *args)
+static void thunk64_vkCmdCopyImageToBuffer2(void *args)
 {
     struct vkCmdCopyImageToBuffer2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
+static void thunk32_vkCmdCopyImageToBuffer2(void *args)
 {
     struct
     {
@@ -27207,20 +27116,18 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2(void *args)
     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
+static void thunk64_vkCmdCopyImageToBuffer2KHR(void *args)
 {
     struct vkCmdCopyImageToBuffer2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCopyImageToBufferInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
+static void thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
 {
     struct
     {
@@ -27234,20 +27141,18 @@ static NTSTATUS thunk32_vkCmdCopyImageToBuffer2KHR(void *args)
     convert_VkCopyImageToBufferInfo2_win32_to_host(&ctx, (const VkCopyImageToBufferInfo232 *)UlongToPtr(params->pCopyImageToBufferInfo), &pCopyImageToBufferInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdCopyImageToBuffer2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pCopyImageToBufferInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMemoryIndirectNV(void *args)
+static void thunk64_vkCmdCopyMemoryIndirectNV(void *args)
 {
     struct vkCmdCopyMemoryIndirectNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
+static void thunk32_vkCmdCopyMemoryIndirectNV(void *args)
 {
     struct
     {
@@ -27258,20 +27163,18 @@ static NTSTATUS thunk32_vkCmdCopyMemoryIndirectNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
+static void thunk64_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct vkCmdCopyMemoryToAccelerationStructureKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToAccelerationStructureKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
+static void thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)
 {
     struct
     {
@@ -27282,20 +27185,18 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToAccelerationStructureKHR(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
+static void thunk64_vkCmdCopyMemoryToImageIndirectNV(void *args)
 {
     struct vkCmdCopyMemoryToImageIndirectNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToImageIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->copyBufferAddress, params->copyCount, params->stride, params->dstImage, params->dstImageLayout, params->pImageSubresources);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
+static void thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
 {
     struct
     {
@@ -27309,20 +27210,18 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToImageIndirectNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
+static void thunk64_vkCmdCopyMemoryToMicromapEXT(void *args)
 {
     struct vkCmdCopyMemoryToMicromapEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMemoryToMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
+static void thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)
 {
     struct
     {
@@ -27333,20 +27232,18 @@ static NTSTATUS thunk32_vkCmdCopyMemoryToMicromapEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMicromapEXT(void *args)
+static void thunk64_vkCmdCopyMicromapEXT(void *args)
 {
     struct vkCmdCopyMicromapEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)
+static void thunk32_vkCmdCopyMicromapEXT(void *args)
 {
     struct
     {
@@ -27357,20 +27254,18 @@ static NTSTATUS thunk32_vkCmdCopyMicromapEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
+static void thunk64_vkCmdCopyMicromapToMemoryEXT(void *args)
 {
     struct vkCmdCopyMicromapToMemoryEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyMicromapToMemoryEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
+static void thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)
 {
     struct
     {
@@ -27381,20 +27276,18 @@ static NTSTATUS thunk32_vkCmdCopyMicromapToMemoryEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCopyQueryPoolResults(void *args)
+static void thunk64_vkCmdCopyQueryPoolResults(void *args)
 {
     struct vkCmdCopyQueryPoolResults_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCopyQueryPoolResults(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount, params->dstBuffer, params->dstOffset, params->stride, params->flags);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
+static void thunk32_vkCmdCopyQueryPoolResults(void *args)
 {
     struct
     {
@@ -27409,20 +27302,18 @@ static NTSTATUS thunk32_vkCmdCopyQueryPoolResults(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdCuLaunchKernelNVX(void *args)
+static void thunk64_vkCmdCuLaunchKernelNVX(void *args)
 {
     struct vkCmdCuLaunchKernelNVX_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdCuLaunchKernelNVX(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLaunchInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)
+static void thunk32_vkCmdCuLaunchKernelNVX(void *args)
 {
     struct
     {
@@ -27433,20 +27324,18 @@ static NTSTATUS thunk32_vkCmdCuLaunchKernelNVX(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDebugMarkerBeginEXT(void *args)
+static void thunk64_vkCmdDebugMarkerBeginEXT(void *args)
 {
     struct vkCmdDebugMarkerBeginEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerBeginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)
+static void thunk32_vkCmdDebugMarkerBeginEXT(void *args)
 {
     struct
     {
@@ -27457,20 +27346,18 @@ static NTSTATUS thunk32_vkCmdDebugMarkerBeginEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDebugMarkerEndEXT(void *args)
+static void thunk64_vkCmdDebugMarkerEndEXT(void *args)
 {
     struct vkCmdDebugMarkerEndEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerEndEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
+static void thunk32_vkCmdDebugMarkerEndEXT(void *args)
 {
     struct
     {
@@ -27478,20 +27365,18 @@ static NTSTATUS thunk32_vkCmdDebugMarkerEndEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDebugMarkerInsertEXT(void *args)
+static void thunk64_vkCmdDebugMarkerInsertEXT(void *args)
 {
     struct vkCmdDebugMarkerInsertEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDebugMarkerInsertEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pMarkerInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)
+static void thunk32_vkCmdDebugMarkerInsertEXT(void *args)
 {
     struct
     {
@@ -27502,20 +27387,18 @@ static NTSTATUS thunk32_vkCmdDebugMarkerInsertEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
+static void thunk64_vkCmdDecompressMemoryIndirectCountNV(void *args)
 {
     struct vkCmdDecompressMemoryIndirectCountNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectCommandsAddress, params->indirectCommandsCountAddress, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
+static void thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
 {
     struct
     {
@@ -27526,20 +27409,18 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryIndirectCountNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDecompressMemoryNV(void *args)
+static void thunk64_vkCmdDecompressMemoryNV(void *args)
 {
     struct vkCmdDecompressMemoryNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->decompressRegionCount, params->pDecompressMemoryRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
+static void thunk32_vkCmdDecompressMemoryNV(void *args)
 {
     struct
     {
@@ -27554,20 +27435,18 @@ static NTSTATUS thunk32_vkCmdDecompressMemoryNV(void *args)
     pDecompressMemoryRegions_host = convert_VkDecompressMemoryRegionNV_array_win32_to_host(&ctx, (const VkDecompressMemoryRegionNV32 *)UlongToPtr(params->pDecompressMemoryRegions), params->decompressRegionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDecompressMemoryNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->decompressRegionCount, pDecompressMemoryRegions_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDispatch(void *args)
+static void thunk64_vkCmdDispatch(void *args)
 {
     struct vkCmdDispatch_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatch(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDispatch(void *args)
+static void thunk32_vkCmdDispatch(void *args)
 {
     struct
     {
@@ -27578,20 +27457,18 @@ static NTSTATUS thunk32_vkCmdDispatch(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDispatchBase(void *args)
+static void thunk64_vkCmdDispatchBase(void *args)
 {
     struct vkCmdDispatchBase_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBase(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
+static void thunk32_vkCmdDispatchBase(void *args)
 {
     struct
     {
@@ -27605,20 +27482,18 @@ static NTSTATUS thunk32_vkCmdDispatchBase(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDispatchBaseKHR(void *args)
+static void thunk64_vkCmdDispatchBaseKHR(void *args)
 {
     struct vkCmdDispatchBaseKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchBaseKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->baseGroupX, params->baseGroupY, params->baseGroupZ, params->groupCountX, params->groupCountY, params->groupCountZ);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
+static void thunk32_vkCmdDispatchBaseKHR(void *args)
 {
     struct
     {
@@ -27632,20 +27507,18 @@ static NTSTATUS thunk32_vkCmdDispatchBaseKHR(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDispatchIndirect(void *args)
+static void thunk64_vkCmdDispatchIndirect(void *args)
 {
     struct vkCmdDispatchIndirect_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDispatchIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
+static void thunk32_vkCmdDispatchIndirect(void *args)
 {
     struct
     {
@@ -27655,20 +27528,18 @@ static NTSTATUS thunk32_vkCmdDispatchIndirect(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDraw(void *args)
+static void thunk64_vkCmdDraw(void *args)
 {
     struct vkCmdDraw_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDraw(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexCount, params->instanceCount, params->firstVertex, params->firstInstance);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDraw(void *args)
+static void thunk32_vkCmdDraw(void *args)
 {
     struct
     {
@@ -27680,20 +27551,18 @@ static NTSTATUS thunk32_vkCmdDraw(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndexed(void *args)
+static void thunk64_vkCmdDrawIndexed(void *args)
 {
     struct vkCmdDrawIndexed_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexed(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indexCount, params->instanceCount, params->firstIndex, params->vertexOffset, params->firstInstance);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
+static void thunk32_vkCmdDrawIndexed(void *args)
 {
     struct
     {
@@ -27706,20 +27575,18 @@ static NTSTATUS thunk32_vkCmdDrawIndexed(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndexedIndirect(void *args)
+static void thunk64_vkCmdDrawIndexedIndirect(void *args)
 {
     struct vkCmdDrawIndexedIndirect_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
+static void thunk32_vkCmdDrawIndexedIndirect(void *args)
 {
     struct
     {
@@ -27731,20 +27598,18 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirect(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCount(void *args)
+static void thunk64_vkCmdDrawIndexedIndirectCount(void *args)
 {
     struct vkCmdDrawIndexedIndirectCount_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
+static void thunk32_vkCmdDrawIndexedIndirectCount(void *args)
 {
     struct
     {
@@ -27758,20 +27623,18 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCount(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
+static void thunk64_vkCmdDrawIndexedIndirectCountAMD(void *args)
 {
     struct vkCmdDrawIndexedIndirectCountAMD_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
+static void thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
 {
     struct
     {
@@ -27785,20 +27648,18 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountAMD(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
+static void thunk64_vkCmdDrawIndexedIndirectCountKHR(void *args)
 {
     struct vkCmdDrawIndexedIndirectCountKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndexedIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
+static void thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
 {
     struct
     {
@@ -27812,20 +27673,18 @@ static NTSTATUS thunk32_vkCmdDrawIndexedIndirectCountKHR(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndirect(void *args)
+static void thunk64_vkCmdDrawIndirect(void *args)
 {
     struct vkCmdDrawIndirect_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirect(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
+static void thunk32_vkCmdDrawIndirect(void *args)
 {
     struct
     {
@@ -27837,20 +27696,18 @@ static NTSTATUS thunk32_vkCmdDrawIndirect(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
+static void thunk64_vkCmdDrawIndirectByteCountEXT(void *args)
 {
     struct vkCmdDrawIndirectByteCountEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectByteCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->instanceCount, params->firstInstance, params->counterBuffer, params->counterBufferOffset, params->counterOffset, params->vertexStride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
+static void thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
 {
     struct
     {
@@ -27864,20 +27721,18 @@ static NTSTATUS thunk32_vkCmdDrawIndirectByteCountEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndirectCount(void *args)
+static void thunk64_vkCmdDrawIndirectCount(void *args)
 {
     struct vkCmdDrawIndirectCount_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
+static void thunk32_vkCmdDrawIndirectCount(void *args)
 {
     struct
     {
@@ -27891,20 +27746,18 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCount(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndirectCountAMD(void *args)
+static void thunk64_vkCmdDrawIndirectCountAMD(void *args)
 {
     struct vkCmdDrawIndirectCountAMD_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
+static void thunk32_vkCmdDrawIndirectCountAMD(void *args)
 {
     struct
     {
@@ -27918,20 +27771,18 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountAMD(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawIndirectCountKHR(void *args)
+static void thunk64_vkCmdDrawIndirectCountKHR(void *args)
 {
     struct vkCmdDrawIndirectCountKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawIndirectCountKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
+static void thunk32_vkCmdDrawIndirectCountKHR(void *args)
 {
     struct
     {
@@ -27945,20 +27796,18 @@ static NTSTATUS thunk32_vkCmdDrawIndirectCountKHR(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksEXT(void *args)
+static void thunk64_vkCmdDrawMeshTasksEXT(void *args)
 {
     struct vkCmdDrawMeshTasksEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->groupCountX, params->groupCountY, params->groupCountZ);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
+static void thunk32_vkCmdDrawMeshTasksEXT(void *args)
 {
     struct
     {
@@ -27969,20 +27818,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
+static void thunk64_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectCountEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
+static void thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
 {
     struct
     {
@@ -27996,20 +27843,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
+static void thunk64_vkCmdDrawMeshTasksIndirectCountNV(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectCountNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectCountNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->countBuffer, params->countBufferOffset, params->maxDrawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
+static void thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
 {
     struct
     {
@@ -28023,20 +27868,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectCountNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
+static void thunk64_vkCmdDrawMeshTasksIndirectEXT(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
+static void thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
 {
     struct
     {
@@ -28048,20 +27891,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
+static void thunk64_vkCmdDrawMeshTasksIndirectNV(void *args)
 {
     struct vkCmdDrawMeshTasksIndirectNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksIndirectNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->buffer, params->offset, params->drawCount, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
+static void thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
 {
     struct
     {
@@ -28073,20 +27914,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksIndirectNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMeshTasksNV(void *args)
+static void thunk64_vkCmdDrawMeshTasksNV(void *args)
 {
     struct vkCmdDrawMeshTasksNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMeshTasksNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->taskCount, params->firstTask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
+static void thunk32_vkCmdDrawMeshTasksNV(void *args)
 {
     struct
     {
@@ -28096,20 +27935,18 @@ static NTSTATUS thunk32_vkCmdDrawMeshTasksNV(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMultiEXT(void *args)
+static void thunk64_vkCmdDrawMultiEXT(void *args)
 {
     struct vkCmdDrawMultiEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pVertexInfo, params->instanceCount, params->firstInstance, params->stride);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
+static void thunk32_vkCmdDrawMultiEXT(void *args)
 {
     struct
     {
@@ -28122,20 +27959,18 @@ static NTSTATUS thunk32_vkCmdDrawMultiEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawInfoEXT *)UlongToPtr(params->pVertexInfo), params->instanceCount, params->firstInstance, params->stride);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdDrawMultiIndexedEXT(void *args)
+static void thunk64_vkCmdDrawMultiIndexedEXT(void *args)
 {
     struct vkCmdDrawMultiIndexedEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->drawCount, params->pIndexInfo, params->instanceCount, params->firstInstance, params->stride, params->pVertexOffset);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
+static void thunk32_vkCmdDrawMultiIndexedEXT(void *args)
 {
     struct
     {
@@ -28149,20 +27984,18 @@ static NTSTATUS thunk32_vkCmdDrawMultiIndexedEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdDrawMultiIndexedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->drawCount, (const VkMultiDrawIndexedInfoEXT *)UlongToPtr(params->pIndexInfo), params->instanceCount, params->firstInstance, params->stride, (const int32_t *)UlongToPtr(params->pVertexOffset));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndConditionalRenderingEXT(void *args)
+static void thunk64_vkCmdEndConditionalRenderingEXT(void *args)
 {
     struct vkCmdEndConditionalRenderingEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndConditionalRenderingEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
+static void thunk32_vkCmdEndConditionalRenderingEXT(void *args)
 {
     struct
     {
@@ -28170,20 +28003,18 @@ static NTSTATUS thunk32_vkCmdEndConditionalRenderingEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
+static void thunk64_vkCmdEndDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdEndDebugUtilsLabelEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
+static void thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
 {
     struct
     {
@@ -28191,20 +28022,18 @@ static NTSTATUS thunk32_vkCmdEndDebugUtilsLabelEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndQuery(void *args)
+static void thunk64_vkCmdEndQuery(void *args)
 {
     struct vkCmdEndQuery_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQuery(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndQuery(void *args)
+static void thunk32_vkCmdEndQuery(void *args)
 {
     struct
     {
@@ -28214,20 +28043,18 @@ static NTSTATUS thunk32_vkCmdEndQuery(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndQueryIndexedEXT(void *args)
+static void thunk64_vkCmdEndQueryIndexedEXT(void *args)
 {
     struct vkCmdEndQueryIndexedEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndQueryIndexedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->query, params->index);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
+static void thunk32_vkCmdEndQueryIndexedEXT(void *args)
 {
     struct
     {
@@ -28238,20 +28065,18 @@ static NTSTATUS thunk32_vkCmdEndQueryIndexedEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndRenderPass(void *args)
+static void thunk64_vkCmdEndRenderPass(void *args)
 {
     struct vkCmdEndRenderPass_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
+static void thunk32_vkCmdEndRenderPass(void *args)
 {
     struct
     {
@@ -28259,20 +28084,18 @@ static NTSTATUS thunk32_vkCmdEndRenderPass(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndRenderPass2(void *args)
+static void thunk64_vkCmdEndRenderPass2(void *args)
 {
     struct vkCmdEndRenderPass2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
+static void thunk32_vkCmdEndRenderPass2(void *args)
 {
     struct
     {
@@ -28286,20 +28109,18 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2(void *args)
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndRenderPass2KHR(void *args)
+static void thunk64_vkCmdEndRenderPass2KHR(void *args)
 {
     struct vkCmdEndRenderPass2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassEndInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
+static void thunk32_vkCmdEndRenderPass2KHR(void *args)
 {
     struct
     {
@@ -28313,20 +28134,18 @@ static NTSTATUS thunk32_vkCmdEndRenderPass2KHR(void *args)
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdEndRenderPass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndRendering(void *args)
+static void thunk64_vkCmdEndRendering(void *args)
 {
     struct vkCmdEndRendering_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRendering(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndRendering(void *args)
+static void thunk32_vkCmdEndRendering(void *args)
 {
     struct
     {
@@ -28334,20 +28153,18 @@ static NTSTATUS thunk32_vkCmdEndRendering(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndRenderingKHR(void *args)
+static void thunk64_vkCmdEndRenderingKHR(void *args)
 {
     struct vkCmdEndRenderingKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndRenderingKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
+static void thunk32_vkCmdEndRenderingKHR(void *args)
 {
     struct
     {
@@ -28355,20 +28172,18 @@ static NTSTATUS thunk32_vkCmdEndRenderingKHR(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdEndTransformFeedbackEXT(void *args)
+static void thunk64_vkCmdEndTransformFeedbackEXT(void *args)
 {
     struct vkCmdEndTransformFeedbackEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdEndTransformFeedbackEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstCounterBuffer, params->counterBufferCount, params->pCounterBuffers, params->pCounterBufferOffsets);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
+static void thunk32_vkCmdEndTransformFeedbackEXT(void *args)
 {
     struct
     {
@@ -28380,11 +28195,10 @@ static NTSTATUS thunk32_vkCmdEndTransformFeedbackEXT(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
+static void thunk64_vkCmdExecuteCommands(void *args)
 {
     struct vkCmdExecuteCommands_params *params = args;
     const VkCommandBuffer *pCommandBuffers_host;
@@ -28394,11 +28208,10 @@ static NTSTATUS thunk64_vkCmdExecuteCommands(void *args)
     pCommandBuffers_host = convert_VkCommandBuffer_array_win64_to_host(&ctx, params->pCommandBuffers, params->commandBufferCount);
     wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->commandBufferCount, pCommandBuffers_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
+static void thunk32_vkCmdExecuteCommands(void *args)
 {
     struct
     {
@@ -28413,20 +28226,18 @@ static NTSTATUS thunk32_vkCmdExecuteCommands(void *args)
     pCommandBuffers_host = convert_VkCommandBuffer_array_win32_to_host(&ctx, (const PTR32 *)UlongToPtr(params->pCommandBuffers), params->commandBufferCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteCommands(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->commandBufferCount, pCommandBuffers_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
+static void thunk64_vkCmdExecuteGeneratedCommandsNV(void *args)
 {
     struct vkCmdExecuteGeneratedCommandsNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->isPreprocessed, params->pGeneratedCommandsInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
+static void thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
 {
     struct
     {
@@ -28441,20 +28252,18 @@ static NTSTATUS thunk32_vkCmdExecuteGeneratedCommandsNV(void *args)
     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdExecuteGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->isPreprocessed, &pGeneratedCommandsInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdFillBuffer(void *args)
+static void thunk64_vkCmdFillBuffer(void *args)
 {
     struct vkCmdFillBuffer_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
+static void thunk32_vkCmdFillBuffer(void *args)
 {
     struct
     {
@@ -28466,20 +28275,18 @@ static NTSTATUS thunk32_vkCmdFillBuffer(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdFillBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->size, params->data);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
+static void thunk64_vkCmdInsertDebugUtilsLabelEXT(void *args)
 {
     struct vkCmdInsertDebugUtilsLabelEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdInsertDebugUtilsLabelEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pLabelInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
+static void thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)
 {
     struct
     {
@@ -28490,20 +28297,18 @@ static NTSTATUS thunk32_vkCmdInsertDebugUtilsLabelEXT(void *args)

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdNextSubpass(void *args)
+static void thunk64_vkCmdNextSubpass(void *args)
 {
     struct vkCmdNextSubpass_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->contents);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
+static void thunk32_vkCmdNextSubpass(void *args)
 {
     struct
     {
@@ -28512,20 +28317,18 @@ static NTSTATUS thunk32_vkCmdNextSubpass(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->contents);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdNextSubpass2(void *args)
+static void thunk64_vkCmdNextSubpass2(void *args)
 {
     struct vkCmdNextSubpass2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
+static void thunk32_vkCmdNextSubpass2(void *args)
 {
     struct
     {
@@ -28542,20 +28345,18 @@ static NTSTATUS thunk32_vkCmdNextSubpass2(void *args)
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdNextSubpass2KHR(void *args)
+static void thunk64_vkCmdNextSubpass2KHR(void *args)
 {
     struct vkCmdNextSubpass2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSubpassBeginInfo, params->pSubpassEndInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
+static void thunk32_vkCmdNextSubpass2KHR(void *args)
 {
     struct
     {
@@ -28572,20 +28373,18 @@ static NTSTATUS thunk32_vkCmdNextSubpass2KHR(void *args)
     convert_VkSubpassEndInfo_win32_to_host(&ctx, (const VkSubpassEndInfo32 *)UlongToPtr(params->pSubpassEndInfo), &pSubpassEndInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdNextSubpass2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSubpassBeginInfo_host, &pSubpassEndInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdOpticalFlowExecuteNV(void *args)
+static void thunk64_vkCmdOpticalFlowExecuteNV(void *args)
 {
     struct vkCmdOpticalFlowExecuteNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->session, params->pExecuteInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)
+static void thunk32_vkCmdOpticalFlowExecuteNV(void *args)
 {
     struct
     {
@@ -28597,20 +28396,18 @@ static NTSTATUS thunk32_vkCmdOpticalFlowExecuteNV(void *args)

convert_VkOpticalFlowExecuteInfoNV_win32_to_host((const VkOpticalFlowExecuteInfoNV32 *)UlongToPtr(params->pExecuteInfo), &pExecuteInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdOpticalFlowExecuteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->session, &pExecuteInfo_host);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPipelineBarrier(void *args)
+static void thunk64_vkCmdPipelineBarrier(void *args)
 {
     struct vkCmdPipelineBarrier_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
+static void thunk32_vkCmdPipelineBarrier(void *args)
 {
     struct
     {
@@ -28636,20 +28433,18 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier(void *args)
     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->srcStageMask, params->dstStageMask, params->dependencyFlags, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPipelineBarrier2(void *args)
+static void thunk64_vkCmdPipelineBarrier2(void *args)
 {
     struct vkCmdPipelineBarrier2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
+static void thunk32_vkCmdPipelineBarrier2(void *args)
 {
     struct
     {
@@ -28663,20 +28458,18 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2(void *args)
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPipelineBarrier2KHR(void *args)
+static void thunk64_vkCmdPipelineBarrier2KHR(void *args)
 {
     struct vkCmdPipelineBarrier2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pDependencyInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
+static void thunk32_vkCmdPipelineBarrier2KHR(void *args)
 {
     struct
     {
@@ -28690,20 +28483,18 @@ static NTSTATUS thunk32_vkCmdPipelineBarrier2KHR(void *args)
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPipelineBarrier2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pDependencyInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
+static void thunk64_vkCmdPreprocessGeneratedCommandsNV(void *args)
 {
     struct vkCmdPreprocessGeneratedCommandsNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pGeneratedCommandsInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
+static void thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
 {
     struct
     {
@@ -28717,20 +28508,18 @@ static NTSTATUS thunk32_vkCmdPreprocessGeneratedCommandsNV(void *args)
     convert_VkGeneratedCommandsInfoNV_win32_to_host(&ctx, (const VkGeneratedCommandsInfoNV32 *)UlongToPtr(params->pGeneratedCommandsInfo), &pGeneratedCommandsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPreprocessGeneratedCommandsNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pGeneratedCommandsInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPushConstants(void *args)
+static void thunk64_vkCmdPushConstants(void *args)
 {
     struct vkCmdPushConstants_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->layout, params->stageFlags, params->offset, params->size, params->pValues);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPushConstants(void *args)
+static void thunk32_vkCmdPushConstants(void *args)
 {
     struct
     {
@@ -28743,20 +28532,18 @@ static NTSTATUS thunk32_vkCmdPushConstants(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->layout, params->stageFlags, params->offset, params->size, (const void *)UlongToPtr(params->pValues));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPushDescriptorSetKHR(void *args)
+static void thunk64_vkCmdPushDescriptorSetKHR(void *args)
 {
     struct vkCmdPushDescriptorSetKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, params->pDescriptorWrites);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
+static void thunk32_vkCmdPushDescriptorSetKHR(void *args)
 {
     struct
     {
@@ -28774,20 +28561,18 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetKHR(void *args)
     pDescriptorWrites_host = convert_VkWriteDescriptorSet_array_win32_to_host(&ctx, (const VkWriteDescriptorSet32 *)UlongToPtr(params->pDescriptorWrites), params->descriptorWriteCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->set, params->descriptorWriteCount, pDescriptorWrites_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
+static void thunk64_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
 {
     struct vkCmdPushDescriptorSetWithTemplateKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, params->pData);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
+static void thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
 {
     struct
     {
@@ -28799,20 +28584,18 @@ static NTSTATUS thunk32_vkCmdPushDescriptorSetWithTemplateKHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdPushDescriptorSetWithTemplateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->descriptorUpdateTemplate, params->layout, params->set, (const void *)UlongToPtr(params->pData));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResetEvent(void *args)
+static void thunk64_vkCmdResetEvent(void *args)
 {
     struct vkCmdResetEvent_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResetEvent(void *args)
+static void thunk32_vkCmdResetEvent(void *args)
 {
     struct
     {
@@ -28822,20 +28605,18 @@ static NTSTATUS thunk32_vkCmdResetEvent(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResetEvent2(void *args)
+static void thunk64_vkCmdResetEvent2(void *args)
 {
     struct vkCmdResetEvent2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
+static void thunk32_vkCmdResetEvent2(void *args)
 {
     struct
     {
@@ -28845,20 +28626,18 @@ static NTSTATUS thunk32_vkCmdResetEvent2(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResetEvent2KHR(void *args)
+static void thunk64_vkCmdResetEvent2KHR(void *args)
 {
     struct vkCmdResetEvent2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
+static void thunk32_vkCmdResetEvent2KHR(void *args)
 {
     struct
     {
@@ -28868,20 +28647,18 @@ static NTSTATUS thunk32_vkCmdResetEvent2KHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResetQueryPool(void *args)
+static void thunk64_vkCmdResetQueryPool(void *args)
 {
     struct vkCmdResetQueryPool_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
+static void thunk32_vkCmdResetQueryPool(void *args)
 {
     struct
     {
@@ -28892,20 +28669,18 @@ static NTSTATUS thunk32_vkCmdResetQueryPool(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResetQueryPool(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->queryPool, params->firstQuery, params->queryCount);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResolveImage(void *args)
+static void thunk64_vkCmdResolveImage(void *args)
 {
     struct vkCmdResolveImage_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->srcImage, params->srcImageLayout, params->dstImage, params->dstImageLayout, params->regionCount, params->pRegions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResolveImage(void *args)
+static void thunk32_vkCmdResolveImage(void *args)
 {
     struct
     {
@@ -28919,20 +28694,18 @@ static NTSTATUS thunk32_vkCmdResolveImage(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResolveImage2(void *args)
+static void thunk64_vkCmdResolveImage2(void *args)
 {
     struct vkCmdResolveImage2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
+static void thunk32_vkCmdResolveImage2(void *args)
 {
     struct
     {
@@ -28946,20 +28719,18 @@ static NTSTATUS thunk32_vkCmdResolveImage2(void *args)
     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdResolveImage2KHR(void *args)
+static void thunk64_vkCmdResolveImage2KHR(void *args)
 {
     struct vkCmdResolveImage2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pResolveImageInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
+static void thunk32_vkCmdResolveImage2KHR(void *args)
 {
     struct
     {
@@ -28973,20 +28744,18 @@ static NTSTATUS thunk32_vkCmdResolveImage2KHR(void *args)
     convert_VkResolveImageInfo2_win32_to_host(&ctx, (const VkResolveImageInfo232 *)UlongToPtr(params->pResolveImageInfo), &pResolveImageInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdResolveImage2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pResolveImageInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
+static void thunk64_vkCmdSetAlphaToCoverageEnableEXT(void *args)
 {
     struct vkCmdSetAlphaToCoverageEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToCoverageEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
+static void thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
 {
     struct
     {
@@ -28995,20 +28764,18 @@ static NTSTATUS thunk32_vkCmdSetAlphaToCoverageEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToCoverageEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToCoverageEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
+static void thunk64_vkCmdSetAlphaToOneEnableEXT(void *args)
 {
     struct vkCmdSetAlphaToOneEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->alphaToOneEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
+static void thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
 {
     struct
     {
@@ -29017,20 +28784,18 @@ static NTSTATUS thunk32_vkCmdSetAlphaToOneEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetAlphaToOneEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->alphaToOneEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetBlendConstants(void *args)
+static void thunk64_vkCmdSetBlendConstants(void *args)
 {
     struct vkCmdSetBlendConstants_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->blendConstants);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
+static void thunk32_vkCmdSetBlendConstants(void *args)
 {
     struct
     {
@@ -29039,20 +28804,18 @@ static NTSTATUS thunk32_vkCmdSetBlendConstants(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetBlendConstants(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const float *)UlongToPtr(params->blendConstants));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCheckpointNV(void *args)
+static void thunk64_vkCmdSetCheckpointNV(void *args)
 {
     struct vkCmdSetCheckpointNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pCheckpointMarker);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
+static void thunk32_vkCmdSetCheckpointNV(void *args)
 {
     struct
     {
@@ -29061,20 +28824,18 @@ static NTSTATUS thunk32_vkCmdSetCheckpointNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCheckpointNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const void *)UlongToPtr(params->pCheckpointMarker));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
+static void thunk64_vkCmdSetCoarseSampleOrderNV(void *args)
 {
     struct vkCmdSetCoarseSampleOrderNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleOrderType, params->customSampleOrderCount, params->pCustomSampleOrders);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
+static void thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
 {
     struct
     {
@@ -29090,20 +28851,18 @@ static NTSTATUS thunk32_vkCmdSetCoarseSampleOrderNV(void *args)
     pCustomSampleOrders_host = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(&ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(params->pCustomSampleOrders), params->customSampleOrderCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoarseSampleOrderNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleOrderType, params->customSampleOrderCount, pCustomSampleOrders_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
+static void thunk64_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
     struct vkCmdSetColorBlendAdvancedEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendAdvanced);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
+static void thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
 {
     struct
     {
@@ -29114,20 +28873,18 @@ static NTSTATUS thunk32_vkCmdSetColorBlendAdvancedEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendAdvancedEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendAdvancedEXT *)UlongToPtr(params->pColorBlendAdvanced));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetColorBlendEnableEXT(void *args)
+static void thunk64_vkCmdSetColorBlendEnableEXT(void *args)
 {
     struct vkCmdSetColorBlendEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEnables);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
+static void thunk32_vkCmdSetColorBlendEnableEXT(void *args)
 {
     struct
     {
@@ -29138,20 +28895,18 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorBlendEnables));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetColorBlendEquationEXT(void *args)
+static void thunk64_vkCmdSetColorBlendEquationEXT(void *args)
 {
     struct vkCmdSetColorBlendEquationEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorBlendEquations);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
+static void thunk32_vkCmdSetColorBlendEquationEXT(void *args)
 {
     struct
     {
@@ -29162,20 +28917,18 @@ static NTSTATUS thunk32_vkCmdSetColorBlendEquationEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorBlendEquationEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorBlendEquationEXT *)UlongToPtr(params->pColorBlendEquations));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetColorWriteEnableEXT(void *args)
+static void thunk64_vkCmdSetColorWriteEnableEXT(void *args)
 {
     struct vkCmdSetColorWriteEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->attachmentCount, params->pColorWriteEnables);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
+static void thunk32_vkCmdSetColorWriteEnableEXT(void *args)
 {
     struct
     {
@@ -29185,20 +28938,18 @@ static NTSTATUS thunk32_vkCmdSetColorWriteEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->attachmentCount, (const VkBool32 *)UlongToPtr(params->pColorWriteEnables));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetColorWriteMaskEXT(void *args)
+static void thunk64_vkCmdSetColorWriteMaskEXT(void *args)
 {
     struct vkCmdSetColorWriteMaskEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstAttachment, params->attachmentCount, params->pColorWriteMasks);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
+static void thunk32_vkCmdSetColorWriteMaskEXT(void *args)
 {
     struct
     {
@@ -29209,20 +28960,18 @@ static NTSTATUS thunk32_vkCmdSetColorWriteMaskEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetColorWriteMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstAttachment, params->attachmentCount, (const VkColorComponentFlags *)UlongToPtr(params->pColorWriteMasks));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
+static void thunk64_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
     struct vkCmdSetConservativeRasterizationModeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->conservativeRasterizationMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
+static void thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
 {
     struct
     {
@@ -29231,20 +28980,18 @@ static NTSTATUS thunk32_vkCmdSetConservativeRasterizationModeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetConservativeRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->conservativeRasterizationMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageModulationModeNV(void *args)
+static void thunk64_vkCmdSetCoverageModulationModeNV(void *args)
 {
     struct vkCmdSetCoverageModulationModeNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
+static void thunk32_vkCmdSetCoverageModulationModeNV(void *args)
 {
     struct
     {
@@ -29253,20 +29000,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationModeNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
+static void thunk64_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
     struct vkCmdSetCoverageModulationTableEnableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
+static void thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
 {
     struct
     {
@@ -29275,20 +29020,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableEnableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageModulationTableNV(void *args)
+static void thunk64_vkCmdSetCoverageModulationTableNV(void *args)
 {
     struct vkCmdSetCoverageModulationTableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageModulationTableCount, params->pCoverageModulationTable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
+static void thunk32_vkCmdSetCoverageModulationTableNV(void *args)
 {
     struct
     {
@@ -29298,20 +29041,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageModulationTableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageModulationTableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageModulationTableCount, (const float *)UlongToPtr(params->pCoverageModulationTable));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageReductionModeNV(void *args)
+static void thunk64_vkCmdSetCoverageReductionModeNV(void *args)
 {
     struct vkCmdSetCoverageReductionModeNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageReductionMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
+static void thunk32_vkCmdSetCoverageReductionModeNV(void *args)
 {
     struct
     {
@@ -29320,20 +29061,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageReductionModeNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageReductionModeNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageReductionMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
+static void thunk64_vkCmdSetCoverageToColorEnableNV(void *args)
 {
     struct vkCmdSetCoverageToColorEnableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
+static void thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
 {
     struct
     {
@@ -29342,20 +29081,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorEnableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
+static void thunk64_vkCmdSetCoverageToColorLocationNV(void *args)
 {
     struct vkCmdSetCoverageToColorLocationNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->coverageToColorLocation);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
+static void thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
 {
     struct
     {
@@ -29364,20 +29101,18 @@ static NTSTATUS thunk32_vkCmdSetCoverageToColorLocationNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCoverageToColorLocationNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->coverageToColorLocation);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCullMode(void *args)
+static void thunk64_vkCmdSetCullMode(void *args)
 {
     struct vkCmdSetCullMode_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
+static void thunk32_vkCmdSetCullMode(void *args)
 {
     struct
     {
@@ -29386,20 +29121,18 @@ static NTSTATUS thunk32_vkCmdSetCullMode(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullMode(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetCullModeEXT(void *args)
+static void thunk64_vkCmdSetCullModeEXT(void *args)
 {
     struct vkCmdSetCullModeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->cullMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
+static void thunk32_vkCmdSetCullModeEXT(void *args)
 {
     struct
     {
@@ -29408,20 +29141,18 @@ static NTSTATUS thunk32_vkCmdSetCullModeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetCullModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->cullMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBias(void *args)
+static void thunk64_vkCmdSetDepthBias(void *args)
 {
     struct vkCmdSetDepthBias_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
+static void thunk32_vkCmdSetDepthBias(void *args)
 {
     struct
     {
@@ -29432,20 +29163,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBias(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBias(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasConstantFactor, params->depthBiasClamp, params->depthBiasSlopeFactor);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBiasEnable(void *args)
+static void thunk64_vkCmdSetDepthBiasEnable(void *args)
 {
     struct vkCmdSetDepthBiasEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
+static void thunk32_vkCmdSetDepthBiasEnable(void *args)
 {
     struct
     {
@@ -29454,20 +29183,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthBiasEnableEXT(void *args)
 {
     struct vkCmdSetDepthBiasEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBiasEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
 {
     struct
     {
@@ -29476,20 +29203,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBiasEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBiasEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBiasEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBounds(void *args)
+static void thunk64_vkCmdSetDepthBounds(void *args)
 {
     struct vkCmdSetDepthBounds_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->minDepthBounds, params->maxDepthBounds);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
+static void thunk32_vkCmdSetDepthBounds(void *args)
 {
     struct
     {
@@ -29499,20 +29224,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBounds(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBounds(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->minDepthBounds, params->maxDepthBounds);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
+static void thunk64_vkCmdSetDepthBoundsTestEnable(void *args)
 {
     struct vkCmdSetDepthBoundsTestEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
+static void thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
 {
     struct
     {
@@ -29521,20 +29244,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthBoundsTestEnableEXT(void *args)
 {
     struct vkCmdSetDepthBoundsTestEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthBoundsTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
 {
     struct
     {
@@ -29543,20 +29264,18 @@ static NTSTATUS thunk32_vkCmdSetDepthBoundsTestEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthBoundsTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthBoundsTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthClampEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthClampEnableEXT(void *args)
 {
     struct vkCmdSetDepthClampEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClampEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthClampEnableEXT(void *args)
 {
     struct
     {
@@ -29565,20 +29284,18 @@ static NTSTATUS thunk32_vkCmdSetDepthClampEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClampEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClampEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthClipEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthClipEnableEXT(void *args)
 {
     struct vkCmdSetDepthClipEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthClipEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthClipEnableEXT(void *args)
 {
     struct
     {
@@ -29587,20 +29304,18 @@ static NTSTATUS thunk32_vkCmdSetDepthClipEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthClipEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
+static void thunk64_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
 {
     struct vkCmdSetDepthClipNegativeOneToOneEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->negativeOneToOne);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
+static void thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
 {
     struct
     {
@@ -29609,20 +29324,18 @@ static NTSTATUS thunk32_vkCmdSetDepthClipNegativeOneToOneEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthClipNegativeOneToOneEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->negativeOneToOne);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthCompareOp(void *args)
+static void thunk64_vkCmdSetDepthCompareOp(void *args)
 {
     struct vkCmdSetDepthCompareOp_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
+static void thunk32_vkCmdSetDepthCompareOp(void *args)
 {
     struct
     {
@@ -29631,20 +29344,18 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOp(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthCompareOpEXT(void *args)
+static void thunk64_vkCmdSetDepthCompareOpEXT(void *args)
 {
     struct vkCmdSetDepthCompareOpEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthCompareOp);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
+static void thunk32_vkCmdSetDepthCompareOpEXT(void *args)
 {
     struct
     {
@@ -29653,20 +29364,18 @@ static NTSTATUS thunk32_vkCmdSetDepthCompareOpEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthCompareOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthCompareOp);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthTestEnable(void *args)
+static void thunk64_vkCmdSetDepthTestEnable(void *args)
 {
     struct vkCmdSetDepthTestEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
+static void thunk32_vkCmdSetDepthTestEnable(void *args)
 {
     struct
     {
@@ -29675,20 +29384,18 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthTestEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthTestEnableEXT(void *args)
 {
     struct vkCmdSetDepthTestEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthTestEnableEXT(void *args)
 {
     struct
     {
@@ -29697,20 +29404,18 @@ static NTSTATUS thunk32_vkCmdSetDepthTestEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthWriteEnable(void *args)
+static void thunk64_vkCmdSetDepthWriteEnable(void *args)
 {
     struct vkCmdSetDepthWriteEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
+static void thunk32_vkCmdSetDepthWriteEnable(void *args)
 {
     struct
     {
@@ -29719,20 +29424,18 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
+static void thunk64_vkCmdSetDepthWriteEnableEXT(void *args)
 {
     struct vkCmdSetDepthWriteEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->depthWriteEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
+static void thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
 {
     struct
     {
@@ -29741,20 +29444,18 @@ static NTSTATUS thunk32_vkCmdSetDepthWriteEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDepthWriteEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->depthWriteEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
+static void thunk64_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
 {
     struct vkCmdSetDescriptorBufferOffsetsEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, params->pBufferIndices, params->pOffsets);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
+static void thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
 {
     struct
     {
@@ -29768,20 +29469,18 @@ static NTSTATUS thunk32_vkCmdSetDescriptorBufferOffsetsEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDescriptorBufferOffsetsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineBindPoint, params->layout, params->firstSet, params->setCount, (const uint32_t *)UlongToPtr(params->pBufferIndices), (const VkDeviceSize *)UlongToPtr(params->pOffsets));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDeviceMask(void *args)
+static void thunk64_vkCmdSetDeviceMask(void *args)
 {
     struct vkCmdSetDeviceMask_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
+static void thunk32_vkCmdSetDeviceMask(void *args)
 {
     struct
     {
@@ -29790,20 +29489,18 @@ static NTSTATUS thunk32_vkCmdSetDeviceMask(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDeviceMaskKHR(void *args)
+static void thunk64_vkCmdSetDeviceMaskKHR(void *args)
 {
     struct vkCmdSetDeviceMaskKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->deviceMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
+static void thunk32_vkCmdSetDeviceMaskKHR(void *args)
 {
     struct
     {
@@ -29812,20 +29509,18 @@ static NTSTATUS thunk32_vkCmdSetDeviceMaskKHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDeviceMaskKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->deviceMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetDiscardRectangleEXT(void *args)
+static void thunk64_vkCmdSetDiscardRectangleEXT(void *args)
 {
     struct vkCmdSetDiscardRectangleEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, params->pDiscardRectangles);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
+static void thunk32_vkCmdSetDiscardRectangleEXT(void *args)
 {
     struct
     {
@@ -29836,20 +29531,18 @@ static NTSTATUS thunk32_vkCmdSetDiscardRectangleEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetDiscardRectangleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstDiscardRectangle, params->discardRectangleCount, (const VkRect2D *)UlongToPtr(params->pDiscardRectangles));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetEvent(void *args)
+static void thunk64_vkCmdSetEvent(void *args)
 {
     struct vkCmdSetEvent_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetEvent(void *args)
+static void thunk32_vkCmdSetEvent(void *args)
 {
     struct
     {
@@ -29859,20 +29552,18 @@ static NTSTATUS thunk32_vkCmdSetEvent(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, params->stageMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetEvent2(void *args)
+static void thunk64_vkCmdSetEvent2(void *args)
 {
     struct vkCmdSetEvent2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
+static void thunk32_vkCmdSetEvent2(void *args)
 {
     struct
     {
@@ -29887,20 +29578,18 @@ static NTSTATUS thunk32_vkCmdSetEvent2(void *args)
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetEvent2KHR(void *args)
+static void thunk64_vkCmdSetEvent2KHR(void *args)
 {
     struct vkCmdSetEvent2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->event, params->pDependencyInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
+static void thunk32_vkCmdSetEvent2KHR(void *args)
 {
     struct
     {
@@ -29915,20 +29604,18 @@ static NTSTATUS thunk32_vkCmdSetEvent2KHR(void *args)
     convert_VkDependencyInfo_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfo), &pDependencyInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetEvent2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->event, &pDependencyInfo_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetExclusiveScissorNV(void *args)
+static void thunk64_vkCmdSetExclusiveScissorNV(void *args)
 {
     struct vkCmdSetExclusiveScissorNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, params->pExclusiveScissors);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
+static void thunk32_vkCmdSetExclusiveScissorNV(void *args)
 {
     struct
     {
@@ -29939,20 +29626,18 @@ static NTSTATUS thunk32_vkCmdSetExclusiveScissorNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExclusiveScissorNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstExclusiveScissor, params->exclusiveScissorCount, (const VkRect2D *)UlongToPtr(params->pExclusiveScissors));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
+static void thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
 {
     struct vkCmdSetExtraPrimitiveOverestimationSizeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->extraPrimitiveOverestimationSize);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
+static void thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
 {
     struct
     {
@@ -29961,20 +29646,18 @@ static NTSTATUS thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetExtraPrimitiveOverestimationSizeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->extraPrimitiveOverestimationSize);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
+static void thunk64_vkCmdSetFragmentShadingRateEnumNV(void *args)
 {
     struct vkCmdSetFragmentShadingRateEnumNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRate, params->combinerOps);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
+static void thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
 {
     struct
     {
@@ -29984,20 +29667,18 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateEnumNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateEnumNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRate, (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
+static void thunk64_vkCmdSetFragmentShadingRateKHR(void *args)
 {
     struct vkCmdSetFragmentShadingRateKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pFragmentSize, params->combinerOps);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
+static void thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
 {
     struct
     {
@@ -30007,20 +29688,18 @@ static NTSTATUS thunk32_vkCmdSetFragmentShadingRateKHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFragmentShadingRateKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, (const VkExtent2D *)UlongToPtr(params->pFragmentSize), (const VkFragmentShadingRateCombinerOpKHR *)UlongToPtr(params->combinerOps));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetFrontFace(void *args)
+static void thunk64_vkCmdSetFrontFace(void *args)
 {
     struct vkCmdSetFrontFace_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
+static void thunk32_vkCmdSetFrontFace(void *args)
 {
     struct
     {
@@ -30029,20 +29708,18 @@ static NTSTATUS thunk32_vkCmdSetFrontFace(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFace(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetFrontFaceEXT(void *args)
+static void thunk64_vkCmdSetFrontFaceEXT(void *args)
 {
     struct vkCmdSetFrontFaceEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->frontFace);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
+static void thunk32_vkCmdSetFrontFaceEXT(void *args)
 {
     struct
     {
@@ -30051,20 +29728,18 @@ static NTSTATUS thunk32_vkCmdSetFrontFaceEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetFrontFaceEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->frontFace);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
+static void thunk64_vkCmdSetLineRasterizationModeEXT(void *args)
 {
     struct vkCmdSetLineRasterizationModeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineRasterizationMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
+static void thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
 {
     struct
     {
@@ -30073,20 +29748,18 @@ static NTSTATUS thunk32_vkCmdSetLineRasterizationModeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineRasterizationModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineRasterizationMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLineStippleEXT(void *args)
+static void thunk64_vkCmdSetLineStippleEXT(void *args)
 {
     struct vkCmdSetLineStippleEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
+static void thunk32_vkCmdSetLineStippleEXT(void *args)
 {
     struct
     {
@@ -30096,20 +29769,18 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineStippleFactor, params->lineStipplePattern);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLineStippleEnableEXT(void *args)
+static void thunk64_vkCmdSetLineStippleEnableEXT(void *args)
 {
     struct vkCmdSetLineStippleEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stippledLineEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
+static void thunk32_vkCmdSetLineStippleEnableEXT(void *args)
 {
     struct
     {
@@ -30118,20 +29789,18 @@ static NTSTATUS thunk32_vkCmdSetLineStippleEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineStippleEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stippledLineEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLineWidth(void *args)
+static void thunk64_vkCmdSetLineWidth(void *args)
 {
     struct vkCmdSetLineWidth_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->lineWidth);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
+static void thunk32_vkCmdSetLineWidth(void *args)
 {
     struct
     {
@@ -30140,20 +29809,18 @@ static NTSTATUS thunk32_vkCmdSetLineWidth(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLineWidth(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->lineWidth);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLogicOpEXT(void *args)
+static void thunk64_vkCmdSetLogicOpEXT(void *args)
 {
     struct vkCmdSetLogicOpEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOp);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
+static void thunk32_vkCmdSetLogicOpEXT(void *args)
 {
     struct
     {
@@ -30162,20 +29829,18 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOp);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetLogicOpEnableEXT(void *args)
+static void thunk64_vkCmdSetLogicOpEnableEXT(void *args)
 {
     struct vkCmdSetLogicOpEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->logicOpEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
+static void thunk32_vkCmdSetLogicOpEnableEXT(void *args)
 {
     struct
     {
@@ -30184,20 +29849,18 @@ static NTSTATUS thunk32_vkCmdSetLogicOpEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetLogicOpEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->logicOpEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPatchControlPointsEXT(void *args)
+static void thunk64_vkCmdSetPatchControlPointsEXT(void *args)
 {
     struct vkCmdSetPatchControlPointsEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->patchControlPoints);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
+static void thunk32_vkCmdSetPatchControlPointsEXT(void *args)
 {
     struct
     {
@@ -30206,7 +29869,6 @@ static NTSTATUS thunk32_vkCmdSetPatchControlPointsEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPatchControlPointsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->patchControlPoints);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
@@ -30297,16 +29959,15 @@ static NTSTATUS thunk32_vkCmdSetPerformanceStreamMarkerINTEL(void *args)
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPolygonModeEXT(void *args)
+static void thunk64_vkCmdSetPolygonModeEXT(void *args)
 {
     struct vkCmdSetPolygonModeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->polygonMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
+static void thunk32_vkCmdSetPolygonModeEXT(void *args)
 {
     struct
     {
@@ -30315,20 +29976,18 @@ static NTSTATUS thunk32_vkCmdSetPolygonModeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPolygonModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->polygonMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
+static void thunk64_vkCmdSetPrimitiveRestartEnable(void *args)
 {
     struct vkCmdSetPrimitiveRestartEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
+static void thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
 {
     struct
     {
@@ -30337,20 +29996,18 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
+static void thunk64_vkCmdSetPrimitiveRestartEnableEXT(void *args)
 {
     struct vkCmdSetPrimitiveRestartEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveRestartEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
+static void thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
 {
     struct
     {
@@ -30359,20 +30016,18 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveRestartEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveRestartEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveRestartEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPrimitiveTopology(void *args)
+static void thunk64_vkCmdSetPrimitiveTopology(void *args)
 {
     struct vkCmdSetPrimitiveTopology_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
+static void thunk32_vkCmdSetPrimitiveTopology(void *args)
 {
     struct
     {
@@ -30381,20 +30036,18 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopology(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopology(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
+static void thunk64_vkCmdSetPrimitiveTopologyEXT(void *args)
 {
     struct vkCmdSetPrimitiveTopologyEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->primitiveTopology);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
+static void thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
 {
     struct
     {
@@ -30403,20 +30056,18 @@ static NTSTATUS thunk32_vkCmdSetPrimitiveTopologyEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetPrimitiveTopologyEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->primitiveTopology);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
+static void thunk64_vkCmdSetProvokingVertexModeEXT(void *args)
 {
     struct vkCmdSetProvokingVertexModeEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->provokingVertexMode);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
+static void thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
 {
     struct
     {
@@ -30425,20 +30076,18 @@ static NTSTATUS thunk32_vkCmdSetProvokingVertexModeEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetProvokingVertexModeEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->provokingVertexMode);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
+static void thunk64_vkCmdSetRasterizationSamplesEXT(void *args)
 {
     struct vkCmdSetRasterizationSamplesEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationSamples);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
+static void thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
 {
     struct
     {
@@ -30447,20 +30096,18 @@ static NTSTATUS thunk32_vkCmdSetRasterizationSamplesEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationSamplesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationSamples);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRasterizationStreamEXT(void *args)
+static void thunk64_vkCmdSetRasterizationStreamEXT(void *args)
 {
     struct vkCmdSetRasterizationStreamEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizationStream);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
+static void thunk32_vkCmdSetRasterizationStreamEXT(void *args)
 {
     struct
     {
@@ -30469,20 +30116,18 @@ static NTSTATUS thunk32_vkCmdSetRasterizationStreamEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizationStreamEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizationStream);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
+static void thunk64_vkCmdSetRasterizerDiscardEnable(void *args)
 {
     struct vkCmdSetRasterizerDiscardEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
+static void thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
 {
     struct
     {
@@ -30491,20 +30136,18 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
+static void thunk64_vkCmdSetRasterizerDiscardEnableEXT(void *args)
 {
     struct vkCmdSetRasterizerDiscardEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->rasterizerDiscardEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
+static void thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
 {
     struct
     {
@@ -30513,20 +30156,18 @@ static NTSTATUS thunk32_vkCmdSetRasterizerDiscardEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRasterizerDiscardEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->rasterizerDiscardEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
+static void thunk64_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
 {
     struct vkCmdSetRayTracingPipelineStackSizeKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStackSize);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
+static void thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
 {
     struct
     {
@@ -30535,20 +30176,18 @@ static NTSTATUS thunk32_vkCmdSetRayTracingPipelineStackSizeKHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRayTracingPipelineStackSizeKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStackSize);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
+static void thunk64_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
 {
     struct vkCmdSetRepresentativeFragmentTestEnableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->representativeFragmentTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
+static void thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
 {
     struct
     {
@@ -30557,20 +30196,18 @@ static NTSTATUS thunk32_vkCmdSetRepresentativeFragmentTestEnableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetRepresentativeFragmentTestEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->representativeFragmentTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetSampleLocationsEXT(void *args)
+static void thunk64_vkCmdSetSampleLocationsEXT(void *args)
 {
     struct vkCmdSetSampleLocationsEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pSampleLocationsInfo);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)
+static void thunk32_vkCmdSetSampleLocationsEXT(void *args)
 {
     struct
     {
@@ -30581,20 +30218,18 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEXT(void *args)

convert_VkSampleLocationsInfoEXT_win32_to_host((const VkSampleLocationsInfoEXT32 *)UlongToPtr(params->pSampleLocationsInfo), &pSampleLocationsInfo_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pSampleLocationsInfo_host);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
+static void thunk64_vkCmdSetSampleLocationsEnableEXT(void *args)
 {
     struct vkCmdSetSampleLocationsEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->sampleLocationsEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
+static void thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
 {
     struct
     {
@@ -30603,20 +30238,18 @@ static NTSTATUS thunk32_vkCmdSetSampleLocationsEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleLocationsEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->sampleLocationsEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetSampleMaskEXT(void *args)
+static void thunk64_vkCmdSetSampleMaskEXT(void *args)
 {
     struct vkCmdSetSampleMaskEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->samples, params->pSampleMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
+static void thunk32_vkCmdSetSampleMaskEXT(void *args)
 {
     struct
     {
@@ -30626,20 +30259,18 @@ static NTSTATUS thunk32_vkCmdSetSampleMaskEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetSampleMaskEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->samples, (const VkSampleMask *)UlongToPtr(params->pSampleMask));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetScissor(void *args)
+static void thunk64_vkCmdSetScissor(void *args)
 {
     struct vkCmdSetScissor_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstScissor, params->scissorCount, params->pScissors);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetScissor(void *args)
+static void thunk32_vkCmdSetScissor(void *args)
 {
     struct
     {
@@ -30650,20 +30281,18 @@ static NTSTATUS thunk32_vkCmdSetScissor(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissor(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstScissor, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetScissorWithCount(void *args)
+static void thunk64_vkCmdSetScissorWithCount(void *args)
 {
     struct vkCmdSetScissorWithCount_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
+static void thunk32_vkCmdSetScissorWithCount(void *args)
 {
     struct
     {
@@ -30673,20 +30302,18 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCount(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetScissorWithCountEXT(void *args)
+static void thunk64_vkCmdSetScissorWithCountEXT(void *args)
 {
     struct vkCmdSetScissorWithCountEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->scissorCount, params->pScissors);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
+static void thunk32_vkCmdSetScissorWithCountEXT(void *args)
 {
     struct
     {
@@ -30696,20 +30323,18 @@ static NTSTATUS thunk32_vkCmdSetScissorWithCountEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetScissorWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->scissorCount, (const VkRect2D *)UlongToPtr(params->pScissors));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
+static void thunk64_vkCmdSetShadingRateImageEnableNV(void *args)
 {
     struct vkCmdSetShadingRateImageEnableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->shadingRateImageEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
+static void thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
 {
     struct
     {
@@ -30718,20 +30343,18 @@ static NTSTATUS thunk32_vkCmdSetShadingRateImageEnableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetShadingRateImageEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->shadingRateImageEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilCompareMask(void *args)
+static void thunk64_vkCmdSetStencilCompareMask(void *args)
 {
     struct vkCmdSetStencilCompareMask_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->compareMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
+static void thunk32_vkCmdSetStencilCompareMask(void *args)
 {
     struct
     {
@@ -30741,20 +30364,18 @@ static NTSTATUS thunk32_vkCmdSetStencilCompareMask(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilCompareMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->compareMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilOp(void *args)
+static void thunk64_vkCmdSetStencilOp(void *args)
 {
     struct vkCmdSetStencilOp_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
+static void thunk32_vkCmdSetStencilOp(void *args)
 {
     struct
     {
@@ -30767,20 +30388,18 @@ static NTSTATUS thunk32_vkCmdSetStencilOp(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOp(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilOpEXT(void *args)
+static void thunk64_vkCmdSetStencilOpEXT(void *args)
 {
     struct vkCmdSetStencilOpEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
+static void thunk32_vkCmdSetStencilOpEXT(void *args)
 {
     struct
     {
@@ -30793,20 +30412,18 @@ static NTSTATUS thunk32_vkCmdSetStencilOpEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilOpEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->failOp, params->passOp, params->depthFailOp, params->compareOp);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilReference(void *args)
+static void thunk64_vkCmdSetStencilReference(void *args)
 {
     struct vkCmdSetStencilReference_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->reference);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
+static void thunk32_vkCmdSetStencilReference(void *args)
 {
     struct
     {
@@ -30816,20 +30433,18 @@ static NTSTATUS thunk32_vkCmdSetStencilReference(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilReference(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->reference);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilTestEnable(void *args)
+static void thunk64_vkCmdSetStencilTestEnable(void *args)
 {
     struct vkCmdSetStencilTestEnable_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
+static void thunk32_vkCmdSetStencilTestEnable(void *args)
 {
     struct
     {
@@ -30838,20 +30453,18 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnable(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnable(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilTestEnableEXT(void *args)
+static void thunk64_vkCmdSetStencilTestEnableEXT(void *args)
 {
     struct vkCmdSetStencilTestEnableEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stencilTestEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
+static void thunk32_vkCmdSetStencilTestEnableEXT(void *args)
 {
     struct
     {
@@ -30860,20 +30473,18 @@ static NTSTATUS thunk32_vkCmdSetStencilTestEnableEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilTestEnableEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stencilTestEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetStencilWriteMask(void *args)
+static void thunk64_vkCmdSetStencilWriteMask(void *args)
 {
     struct vkCmdSetStencilWriteMask_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->faceMask, params->writeMask);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
+static void thunk32_vkCmdSetStencilWriteMask(void *args)
 {
     struct
     {
@@ -30883,20 +30494,18 @@ static NTSTATUS thunk32_vkCmdSetStencilWriteMask(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetStencilWriteMask(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->faceMask, params->writeMask);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
+static void thunk64_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
     struct vkCmdSetTessellationDomainOriginEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->domainOrigin);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
+static void thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
 {
     struct
     {
@@ -30905,20 +30514,18 @@ static NTSTATUS thunk32_vkCmdSetTessellationDomainOriginEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetTessellationDomainOriginEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->domainOrigin);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetVertexInputEXT(void *args)
+static void thunk64_vkCmdSetVertexInputEXT(void *args)
 {
     struct vkCmdSetVertexInputEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->vertexBindingDescriptionCount, params->pVertexBindingDescriptions, params->vertexAttributeDescriptionCount, params->pVertexAttributeDescriptions);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
+static void thunk32_vkCmdSetVertexInputEXT(void *args)
 {
     struct
     {
@@ -30937,20 +30544,18 @@ static NTSTATUS thunk32_vkCmdSetVertexInputEXT(void *args)
     pVertexAttributeDescriptions_host = convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(&ctx, (const VkVertexInputAttributeDescription2EXT32 *)UlongToPtr(params->pVertexAttributeDescriptions), params->vertexAttributeDescriptionCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetVertexInputEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->vertexBindingDescriptionCount, pVertexBindingDescriptions_host, params->vertexAttributeDescriptionCount, pVertexAttributeDescriptions_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewport(void *args)
+static void thunk64_vkCmdSetViewport(void *args)
 {
     struct vkCmdSetViewport_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewports);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewport(void *args)
+static void thunk32_vkCmdSetViewport(void *args)
 {
     struct
     {
@@ -30961,20 +30566,18 @@ static NTSTATUS thunk32_vkCmdSetViewport(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewport(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
+static void thunk64_vkCmdSetViewportShadingRatePaletteNV(void *args)
 {
     struct vkCmdSetViewportShadingRatePaletteNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pShadingRatePalettes);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
+static void thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
 {
     struct
     {
@@ -30990,20 +30593,18 @@ static NTSTATUS thunk32_vkCmdSetViewportShadingRatePaletteNV(void *args)
     pShadingRatePalettes_host = convert_VkShadingRatePaletteNV_array_win32_to_host(&ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(params->pShadingRatePalettes), params->viewportCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportShadingRatePaletteNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, pShadingRatePalettes_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportSwizzleNV(void *args)
+static void thunk64_vkCmdSetViewportSwizzleNV(void *args)
 {
     struct vkCmdSetViewportSwizzleNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportSwizzles);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
+static void thunk32_vkCmdSetViewportSwizzleNV(void *args)
 {
     struct
     {
@@ -31014,20 +30615,18 @@ static NTSTATUS thunk32_vkCmdSetViewportSwizzleNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportSwizzleNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportSwizzleNV *)UlongToPtr(params->pViewportSwizzles));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
+static void thunk64_vkCmdSetViewportWScalingEnableNV(void *args)
 {
     struct vkCmdSetViewportWScalingEnableNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportWScalingEnable);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
+static void thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
 {
     struct
     {
@@ -31036,20 +30635,18 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingEnableNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingEnableNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportWScalingEnable);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportWScalingNV(void *args)
+static void thunk64_vkCmdSetViewportWScalingNV(void *args)
 {
     struct vkCmdSetViewportWScalingNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->firstViewport, params->viewportCount, params->pViewportWScalings);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
+static void thunk32_vkCmdSetViewportWScalingNV(void *args)
 {
     struct
     {
@@ -31060,20 +30657,18 @@ static NTSTATUS thunk32_vkCmdSetViewportWScalingNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWScalingNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->firstViewport, params->viewportCount, (const VkViewportWScalingNV *)UlongToPtr(params->pViewportWScalings));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportWithCount(void *args)
+static void thunk64_vkCmdSetViewportWithCount(void *args)
 {
     struct vkCmdSetViewportWithCount_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
+static void thunk32_vkCmdSetViewportWithCount(void *args)
 {
     struct
     {
@@ -31083,20 +30678,18 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCount(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCount(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSetViewportWithCountEXT(void *args)
+static void thunk64_vkCmdSetViewportWithCountEXT(void *args)
 {
     struct vkCmdSetViewportWithCountEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->viewportCount, params->pViewports);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
+static void thunk32_vkCmdSetViewportWithCountEXT(void *args)
 {
     struct
     {
@@ -31106,20 +30699,18 @@ static NTSTATUS thunk32_vkCmdSetViewportWithCountEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdSetViewportWithCountEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->viewportCount, (const VkViewport *)UlongToPtr(params->pViewports));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdSubpassShadingHUAWEI(void *args)
+static void thunk64_vkCmdSubpassShadingHUAWEI(void *args)
 {
     struct vkCmdSubpassShadingHUAWEI_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdSubpassShadingHUAWEI(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
+static void thunk32_vkCmdSubpassShadingHUAWEI(void *args)
 {
     struct
     {
@@ -31127,20 +30718,18 @@ static NTSTATUS thunk32_vkCmdSubpassShadingHUAWEI(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
+static void thunk64_vkCmdTraceRaysIndirect2KHR(void *args)
 {
     struct vkCmdTraceRaysIndirect2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->indirectDeviceAddress);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
+static void thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
 {
     struct
     {
@@ -31149,20 +30738,18 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirect2KHR(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirect2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->indirectDeviceAddress);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdTraceRaysIndirectKHR(void *args)
+static void thunk64_vkCmdTraceRaysIndirectKHR(void *args)
 {
     struct vkCmdTraceRaysIndirectKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->indirectDeviceAddress);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
+static void thunk32_vkCmdTraceRaysIndirectKHR(void *args)
 {
     struct
     {
@@ -31183,20 +30770,18 @@ static NTSTATUS thunk32_vkCmdTraceRaysIndirectKHR(void *args)
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysIndirectKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->indirectDeviceAddress);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdTraceRaysKHR(void *args)
+static void thunk64_vkCmdTraceRaysKHR(void *args)
 {
     struct vkCmdTraceRaysKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pRaygenShaderBindingTable, params->pMissShaderBindingTable, params->pHitShaderBindingTable, params->pCallableShaderBindingTable, params->width, params->height, params->depth);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
+static void thunk32_vkCmdTraceRaysKHR(void *args)
 {
     struct
     {
@@ -31219,20 +30804,18 @@ static NTSTATUS thunk32_vkCmdTraceRaysKHR(void *args)
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pHitShaderBindingTable), &pHitShaderBindingTable_host);
     convert_VkStridedDeviceAddressRegionKHR_win32_to_host((const VkStridedDeviceAddressRegionKHR32 *)UlongToPtr(params->pCallableShaderBindingTable), &pCallableShaderBindingTable_host);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, &pRaygenShaderBindingTable_host, &pMissShaderBindingTable_host, &pHitShaderBindingTable_host, &pCallableShaderBindingTable_host, params->width, params->height, params->depth);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdTraceRaysNV(void *args)
+static void thunk64_vkCmdTraceRaysNV(void *args)
 {
     struct vkCmdTraceRaysNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
+static void thunk32_vkCmdTraceRaysNV(void *args)
 {
     struct
     {
@@ -31254,20 +30837,18 @@ static NTSTATUS thunk32_vkCmdTraceRaysNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdTraceRaysNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->raygenShaderBindingTableBuffer, params->raygenShaderBindingOffset, params->missShaderBindingTableBuffer, params->missShaderBindingOffset, params->missShaderBindingStride, params->hitShaderBindingTableBuffer, params->hitShaderBindingOffset, params->hitShaderBindingStride, params->callableShaderBindingTableBuffer, params->callableShaderBindingOffset, params->callableShaderBindingStride, params->width, params->height, params->depth);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdUpdateBuffer(void *args)
+static void thunk64_vkCmdUpdateBuffer(void *args)
 {
     struct vkCmdUpdateBuffer_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, params->pData);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
+static void thunk32_vkCmdUpdateBuffer(void *args)
 {
     struct
     {
@@ -31279,20 +30860,18 @@ static NTSTATUS thunk32_vkCmdUpdateBuffer(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdUpdateBuffer(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->dstBuffer, params->dstOffset, params->dataSize, (const void *)UlongToPtr(params->pData));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWaitEvents(void *args)
+static void thunk64_vkCmdWaitEvents(void *args)
 {
     struct vkCmdWaitEvents_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, params->pMemoryBarriers, params->bufferMemoryBarrierCount, params->pBufferMemoryBarriers, params->imageMemoryBarrierCount, params->pImageMemoryBarriers);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
+static void thunk32_vkCmdWaitEvents(void *args)
 {
     struct
     {
@@ -31319,20 +30898,18 @@ static NTSTATUS thunk32_vkCmdWaitEvents(void *args)
     pImageMemoryBarriers_host = convert_VkImageMemoryBarrier_array_win32_to_host(&ctx, (const VkImageMemoryBarrier32 *)UlongToPtr(params->pImageMemoryBarriers), params->imageMemoryBarrierCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), params->srcStageMask, params->dstStageMask, params->memoryBarrierCount, pMemoryBarriers_host, params->bufferMemoryBarrierCount, pBufferMemoryBarriers_host, params->imageMemoryBarrierCount, pImageMemoryBarriers_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWaitEvents2(void *args)
+static void thunk64_vkCmdWaitEvents2(void *args)
 {
     struct vkCmdWaitEvents2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
+static void thunk32_vkCmdWaitEvents2(void *args)
 {
     struct
     {
@@ -31348,20 +30925,18 @@ static NTSTATUS thunk32_vkCmdWaitEvents2(void *args)
     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWaitEvents2KHR(void *args)
+static void thunk64_vkCmdWaitEvents2KHR(void *args)
 {
     struct vkCmdWaitEvents2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->eventCount, params->pEvents, params->pDependencyInfos);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
+static void thunk32_vkCmdWaitEvents2KHR(void *args)
 {
     struct
     {
@@ -31377,20 +30952,18 @@ static NTSTATUS thunk32_vkCmdWaitEvents2KHR(void *args)
     pDependencyInfos_host = convert_VkDependencyInfo_array_win32_to_host(&ctx, (const VkDependencyInfo32 *)UlongToPtr(params->pDependencyInfos), params->eventCount);
     wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWaitEvents2KHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->eventCount, (const VkEvent *)UlongToPtr(params->pEvents), pDependencyInfos_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
+static void thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
 {
     struct vkCmdWriteAccelerationStructuresPropertiesKHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
+static void thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args)
 {
     struct
     {
@@ -31403,20 +30976,18 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR(void *args
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesKHR(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureKHR *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
+static void thunk64_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
 {
     struct vkCmdWriteAccelerationStructuresPropertiesNV_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->accelerationStructureCount, params->pAccelerationStructures, params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
+static void thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
 {
     struct
     {
@@ -31429,20 +31000,18 @@ static NTSTATUS thunk32_vkCmdWriteAccelerationStructuresPropertiesNV(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteAccelerationStructuresPropertiesNV(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->accelerationStructureCount, (const VkAccelerationStructureNV *)UlongToPtr(params->pAccelerationStructures), params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteBufferMarker2AMD(void *args)
+static void thunk64_vkCmdWriteBufferMarker2AMD(void *args)
 {
     struct vkCmdWriteBufferMarker2AMD_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
+static void thunk32_vkCmdWriteBufferMarker2AMD(void *args)
 {
     struct
     {
@@ -31454,20 +31023,18 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarker2AMD(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarker2AMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->stage, params->dstBuffer, params->dstOffset, params->marker);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteBufferMarkerAMD(void *args)
+static void thunk64_vkCmdWriteBufferMarkerAMD(void *args)
 {
     struct vkCmdWriteBufferMarkerAMD_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
+static void thunk32_vkCmdWriteBufferMarkerAMD(void *args)
 {
     struct
     {
@@ -31479,20 +31046,18 @@ static NTSTATUS thunk32_vkCmdWriteBufferMarkerAMD(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteBufferMarkerAMD(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->pipelineStage, params->dstBuffer, params->dstOffset, params->marker);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
+static void thunk64_vkCmdWriteMicromapsPropertiesEXT(void *args)
 {
     struct vkCmdWriteMicromapsPropertiesEXT_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->micromapCount, params->pMicromaps, params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
+static void thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
 {
     struct
     {
@@ -31505,20 +31070,18 @@ static NTSTATUS thunk32_vkCmdWriteMicromapsPropertiesEXT(void *args)
     } *params = args;

wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->device->funcs.p_vkCmdWriteMicromapsPropertiesEXT(wine_cmd_buffer_from_handle((VkCommandBuffer)UlongToPtr(params->commandBuffer))->command_buffer, params->micromapCount, (const VkMicromapEXT *)UlongToPtr(params->pMicromaps), params->queryType, params->queryPool, params->firstQuery);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteTimestamp(void *args)
+static void thunk64_vkCmdWriteTimestamp(void *args)
 {
     struct vkCmdWriteTimestamp_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->pipelineStage, params->queryPool, params->query);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
+static void thunk32_vkCmdWriteTimestamp(void *args)
 {
     struct
     {
@@ -31529,20 +31092,18 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteTimestamp2(void *args)
+static void thunk64_vkCmdWriteTimestamp2(void *args)
 {
     struct vkCmdWriteTimestamp2_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
+static void thunk32_vkCmdWriteTimestamp2(void *args)
 {
     struct
     {
@@ -31553,20 +31114,18 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2(void *args)
     } *params = args;

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

#ifdef _WIN64
-static NTSTATUS thunk64_vkCmdWriteTimestamp2KHR(void *args)
+static void thunk64_vkCmdWriteTimestamp2KHR(void *args)
 {
     struct vkCmdWriteTimestamp2KHR_params *params = args;

wine_cmd_buffer_from_handle(params->commandBuffer)->device->funcs.p_vkCmdWriteTimestamp2KHR(wine_cmd_buffer_from_handle(params->commandBuffer)->command_buffer, params->stage, params->queryPool, params->query);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
+static void thunk32_vkCmdWriteTimestamp2KHR(void *args)
 {
     struct
     {
@@ -31577,7 +31136,6 @@ static NTSTATUS thunk32_vkCmdWriteTimestamp2KHR(void *args)
     } *params = args;

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

#ifdef _WIN64
@@ -35419,16 +34977,15 @@ static NTSTATUS thunk32_vkGetDeferredOperationResultKHR(void *args)
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkGetDescriptorEXT(void *args)
+static void thunk64_vkGetDescriptorEXT(void *args)
 {
     struct vkGetDescriptorEXT_params *params = args;

wine_device_from_handle(params->device)->funcs.p_vkGetDescriptorEXT(wine_device_from_handle(params->device)->device, params->pDescriptorInfo, params->dataSize, params->pDescriptor);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkGetDescriptorEXT(void *args)
+static void thunk32_vkGetDescriptorEXT(void *args)
 {
     struct
     {
@@ -35444,7 +35001,6 @@ static NTSTATUS thunk32_vkGetDescriptorEXT(void *args)
     convert_VkDescriptorGetInfoEXT_win32_to_host(&ctx, (const VkDescriptorGetInfoEXT32 *)UlongToPtr(params->pDescriptorInfo), &pDescriptorInfo_host);
     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkGetDescriptorEXT(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, &pDescriptorInfo_host, params->dataSize, (void *)UlongToPtr(params->pDescriptor));
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
@@ -40152,16 +39708,15 @@ static NTSTATUS thunk32_vkUnmapMemory(void *args)
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
+static void thunk64_vkUpdateDescriptorSetWithTemplate(void *args)
 {
     struct vkUpdateDescriptorSetWithTemplate_params *params = args;

wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle(params->device)->device, params->descriptorSet, params->descriptorUpdateTemplate, params->pData);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
+static void thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
 {
     struct
     {
@@ -40172,7 +39727,6 @@ static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplate(void *args)
     } *params = args;

wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSetWithTemplate(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorSet, params->descriptorUpdateTemplate, (const void *)UlongToPtr(params->pData));
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
@@ -40204,16 +39758,15 @@ static NTSTATUS thunk32_vkUpdateDescriptorSetWithTemplateKHR(void *args)
 }

#ifdef _WIN64
-static NTSTATUS thunk64_vkUpdateDescriptorSets(void *args)
+static void thunk64_vkUpdateDescriptorSets(void *args)
 {
     struct vkUpdateDescriptorSets_params *params = args;

wine_device_from_handle(params->device)->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle(params->device)->device, params->descriptorWriteCount, params->pDescriptorWrites, params->descriptorCopyCount, params->pDescriptorCopies);
-    return STATUS_SUCCESS;
 }
 #endif /* _WIN64 */

-static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
+static void thunk32_vkUpdateDescriptorSets(void *args)
 {
     struct
     {
@@ -40232,7 +39785,6 @@ static NTSTATUS thunk32_vkUpdateDescriptorSets(void *args)
     pDescriptorCopies_host = convert_VkCopyDescriptorSet_array_win32_to_host(&ctx, (const VkCopyDescriptorSet32 *)UlongToPtr(params->pDescriptorCopies), params->descriptorCopyCount);
     wine_device_from_handle((VkDevice)UlongToPtr(params->device))->funcs.p_vkUpdateDescriptorSets(wine_device_from_handle((VkDevice)UlongToPtr(params->device))->device, params->descriptorWriteCount, pDescriptorWrites_host, params->descriptorCopyCount, pDescriptorCopies_host);
     free_conversion_context(&ctx);
-    return STATUS_SUCCESS;
 }

#ifdef _WIN64
@@ -40740,230 +40292,230 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkBindOpticalFlowSessionImageNV,
     thunk64_vkBuildAccelerationStructuresKHR,
     thunk64_vkBuildMicromapsEXT,
-    thunk64_vkCmdBeginConditionalRenderingEXT,
-    thunk64_vkCmdBeginDebugUtilsLabelEXT,
-    thunk64_vkCmdBeginQuery,
-    thunk64_vkCmdBeginQueryIndexedEXT,
-    thunk64_vkCmdBeginRenderPass,
-    thunk64_vkCmdBeginRenderPass2,
-    thunk64_vkCmdBeginRenderPass2KHR,
-    thunk64_vkCmdBeginRendering,
-    thunk64_vkCmdBeginRenderingKHR,
-    thunk64_vkCmdBeginTransformFeedbackEXT,
-    thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
-    thunk64_vkCmdBindDescriptorBuffersEXT,
-    thunk64_vkCmdBindDescriptorSets,
-    thunk64_vkCmdBindIndexBuffer,
-    thunk64_vkCmdBindInvocationMaskHUAWEI,
-    thunk64_vkCmdBindPipeline,
-    thunk64_vkCmdBindPipelineShaderGroupNV,
-    thunk64_vkCmdBindShadingRateImageNV,
-    thunk64_vkCmdBindTransformFeedbackBuffersEXT,
-    thunk64_vkCmdBindVertexBuffers,
-    thunk64_vkCmdBindVertexBuffers2,
-    thunk64_vkCmdBindVertexBuffers2EXT,
-    thunk64_vkCmdBlitImage,
-    thunk64_vkCmdBlitImage2,
-    thunk64_vkCmdBlitImage2KHR,
-    thunk64_vkCmdBuildAccelerationStructureNV,
-    thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
-    thunk64_vkCmdBuildAccelerationStructuresKHR,
-    thunk64_vkCmdBuildMicromapsEXT,
-    thunk64_vkCmdClearAttachments,
-    thunk64_vkCmdClearColorImage,
-    thunk64_vkCmdClearDepthStencilImage,
-    thunk64_vkCmdCopyAccelerationStructureKHR,
-    thunk64_vkCmdCopyAccelerationStructureNV,
-    thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
-    thunk64_vkCmdCopyBuffer,
-    thunk64_vkCmdCopyBuffer2,
-    thunk64_vkCmdCopyBuffer2KHR,
-    thunk64_vkCmdCopyBufferToImage,
-    thunk64_vkCmdCopyBufferToImage2,
-    thunk64_vkCmdCopyBufferToImage2KHR,
-    thunk64_vkCmdCopyImage,
-    thunk64_vkCmdCopyImage2,
-    thunk64_vkCmdCopyImage2KHR,
-    thunk64_vkCmdCopyImageToBuffer,
-    thunk64_vkCmdCopyImageToBuffer2,
-    thunk64_vkCmdCopyImageToBuffer2KHR,
-    thunk64_vkCmdCopyMemoryIndirectNV,
-    thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
-    thunk64_vkCmdCopyMemoryToImageIndirectNV,
-    thunk64_vkCmdCopyMemoryToMicromapEXT,
-    thunk64_vkCmdCopyMicromapEXT,
-    thunk64_vkCmdCopyMicromapToMemoryEXT,
-    thunk64_vkCmdCopyQueryPoolResults,
-    thunk64_vkCmdCuLaunchKernelNVX,
-    thunk64_vkCmdDebugMarkerBeginEXT,
-    thunk64_vkCmdDebugMarkerEndEXT,
-    thunk64_vkCmdDebugMarkerInsertEXT,
-    thunk64_vkCmdDecompressMemoryIndirectCountNV,
-    thunk64_vkCmdDecompressMemoryNV,
-    thunk64_vkCmdDispatch,
-    thunk64_vkCmdDispatchBase,
-    thunk64_vkCmdDispatchBaseKHR,
-    thunk64_vkCmdDispatchIndirect,
-    thunk64_vkCmdDraw,
-    thunk64_vkCmdDrawIndexed,
-    thunk64_vkCmdDrawIndexedIndirect,
-    thunk64_vkCmdDrawIndexedIndirectCount,
-    thunk64_vkCmdDrawIndexedIndirectCountAMD,
-    thunk64_vkCmdDrawIndexedIndirectCountKHR,
-    thunk64_vkCmdDrawIndirect,
-    thunk64_vkCmdDrawIndirectByteCountEXT,
-    thunk64_vkCmdDrawIndirectCount,
-    thunk64_vkCmdDrawIndirectCountAMD,
-    thunk64_vkCmdDrawIndirectCountKHR,
-    thunk64_vkCmdDrawMeshTasksEXT,
-    thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
-    thunk64_vkCmdDrawMeshTasksIndirectCountNV,
-    thunk64_vkCmdDrawMeshTasksIndirectEXT,
-    thunk64_vkCmdDrawMeshTasksIndirectNV,
-    thunk64_vkCmdDrawMeshTasksNV,
-    thunk64_vkCmdDrawMultiEXT,
-    thunk64_vkCmdDrawMultiIndexedEXT,
-    thunk64_vkCmdEndConditionalRenderingEXT,
-    thunk64_vkCmdEndDebugUtilsLabelEXT,
-    thunk64_vkCmdEndQuery,
-    thunk64_vkCmdEndQueryIndexedEXT,
-    thunk64_vkCmdEndRenderPass,
-    thunk64_vkCmdEndRenderPass2,
-    thunk64_vkCmdEndRenderPass2KHR,
-    thunk64_vkCmdEndRendering,
-    thunk64_vkCmdEndRenderingKHR,
-    thunk64_vkCmdEndTransformFeedbackEXT,
-    thunk64_vkCmdExecuteCommands,
-    thunk64_vkCmdExecuteGeneratedCommandsNV,
-    thunk64_vkCmdFillBuffer,
-    thunk64_vkCmdInsertDebugUtilsLabelEXT,
-    thunk64_vkCmdNextSubpass,
-    thunk64_vkCmdNextSubpass2,
-    thunk64_vkCmdNextSubpass2KHR,
-    thunk64_vkCmdOpticalFlowExecuteNV,
-    thunk64_vkCmdPipelineBarrier,
-    thunk64_vkCmdPipelineBarrier2,
-    thunk64_vkCmdPipelineBarrier2KHR,
-    thunk64_vkCmdPreprocessGeneratedCommandsNV,
-    thunk64_vkCmdPushConstants,
-    thunk64_vkCmdPushDescriptorSetKHR,
-    thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
-    thunk64_vkCmdResetEvent,
-    thunk64_vkCmdResetEvent2,
-    thunk64_vkCmdResetEvent2KHR,
-    thunk64_vkCmdResetQueryPool,
-    thunk64_vkCmdResolveImage,
-    thunk64_vkCmdResolveImage2,
-    thunk64_vkCmdResolveImage2KHR,
-    thunk64_vkCmdSetAlphaToCoverageEnableEXT,
-    thunk64_vkCmdSetAlphaToOneEnableEXT,
-    thunk64_vkCmdSetBlendConstants,
-    thunk64_vkCmdSetCheckpointNV,
-    thunk64_vkCmdSetCoarseSampleOrderNV,
-    thunk64_vkCmdSetColorBlendAdvancedEXT,
-    thunk64_vkCmdSetColorBlendEnableEXT,
-    thunk64_vkCmdSetColorBlendEquationEXT,
-    thunk64_vkCmdSetColorWriteEnableEXT,
-    thunk64_vkCmdSetColorWriteMaskEXT,
-    thunk64_vkCmdSetConservativeRasterizationModeEXT,
-    thunk64_vkCmdSetCoverageModulationModeNV,
-    thunk64_vkCmdSetCoverageModulationTableEnableNV,
-    thunk64_vkCmdSetCoverageModulationTableNV,
-    thunk64_vkCmdSetCoverageReductionModeNV,
-    thunk64_vkCmdSetCoverageToColorEnableNV,
-    thunk64_vkCmdSetCoverageToColorLocationNV,
-    thunk64_vkCmdSetCullMode,
-    thunk64_vkCmdSetCullModeEXT,
-    thunk64_vkCmdSetDepthBias,
-    thunk64_vkCmdSetDepthBiasEnable,
-    thunk64_vkCmdSetDepthBiasEnableEXT,
-    thunk64_vkCmdSetDepthBounds,
-    thunk64_vkCmdSetDepthBoundsTestEnable,
-    thunk64_vkCmdSetDepthBoundsTestEnableEXT,
-    thunk64_vkCmdSetDepthClampEnableEXT,
-    thunk64_vkCmdSetDepthClipEnableEXT,
-    thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
-    thunk64_vkCmdSetDepthCompareOp,
-    thunk64_vkCmdSetDepthCompareOpEXT,
-    thunk64_vkCmdSetDepthTestEnable,
-    thunk64_vkCmdSetDepthTestEnableEXT,
-    thunk64_vkCmdSetDepthWriteEnable,
-    thunk64_vkCmdSetDepthWriteEnableEXT,
-    thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
-    thunk64_vkCmdSetDeviceMask,
-    thunk64_vkCmdSetDeviceMaskKHR,
-    thunk64_vkCmdSetDiscardRectangleEXT,
-    thunk64_vkCmdSetEvent,
-    thunk64_vkCmdSetEvent2,
-    thunk64_vkCmdSetEvent2KHR,
-    thunk64_vkCmdSetExclusiveScissorNV,
-    thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
-    thunk64_vkCmdSetFragmentShadingRateEnumNV,
-    thunk64_vkCmdSetFragmentShadingRateKHR,
-    thunk64_vkCmdSetFrontFace,
-    thunk64_vkCmdSetFrontFaceEXT,
-    thunk64_vkCmdSetLineRasterizationModeEXT,
-    thunk64_vkCmdSetLineStippleEXT,
-    thunk64_vkCmdSetLineStippleEnableEXT,
-    thunk64_vkCmdSetLineWidth,
-    thunk64_vkCmdSetLogicOpEXT,
-    thunk64_vkCmdSetLogicOpEnableEXT,
-    thunk64_vkCmdSetPatchControlPointsEXT,
+    (void *)thunk64_vkCmdBeginConditionalRenderingEXT,
+    (void *)thunk64_vkCmdBeginDebugUtilsLabelEXT,
+    (void *)thunk64_vkCmdBeginQuery,
+    (void *)thunk64_vkCmdBeginQueryIndexedEXT,
+    (void *)thunk64_vkCmdBeginRenderPass,
+    (void *)thunk64_vkCmdBeginRenderPass2,
+    (void *)thunk64_vkCmdBeginRenderPass2KHR,
+    (void *)thunk64_vkCmdBeginRendering,
+    (void *)thunk64_vkCmdBeginRenderingKHR,
+    (void *)thunk64_vkCmdBeginTransformFeedbackEXT,
+    (void *)thunk64_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
+    (void *)thunk64_vkCmdBindDescriptorBuffersEXT,
+    (void *)thunk64_vkCmdBindDescriptorSets,
+    (void *)thunk64_vkCmdBindIndexBuffer,
+    (void *)thunk64_vkCmdBindInvocationMaskHUAWEI,
+    (void *)thunk64_vkCmdBindPipeline,
+    (void *)thunk64_vkCmdBindPipelineShaderGroupNV,
+    (void *)thunk64_vkCmdBindShadingRateImageNV,
+    (void *)thunk64_vkCmdBindTransformFeedbackBuffersEXT,
+    (void *)thunk64_vkCmdBindVertexBuffers,
+    (void *)thunk64_vkCmdBindVertexBuffers2,
+    (void *)thunk64_vkCmdBindVertexBuffers2EXT,
+    (void *)thunk64_vkCmdBlitImage,
+    (void *)thunk64_vkCmdBlitImage2,
+    (void *)thunk64_vkCmdBlitImage2KHR,
+    (void *)thunk64_vkCmdBuildAccelerationStructureNV,
+    (void *)thunk64_vkCmdBuildAccelerationStructuresIndirectKHR,
+    (void *)thunk64_vkCmdBuildAccelerationStructuresKHR,
+    (void *)thunk64_vkCmdBuildMicromapsEXT,
+    (void *)thunk64_vkCmdClearAttachments,
+    (void *)thunk64_vkCmdClearColorImage,
+    (void *)thunk64_vkCmdClearDepthStencilImage,
+    (void *)thunk64_vkCmdCopyAccelerationStructureKHR,
+    (void *)thunk64_vkCmdCopyAccelerationStructureNV,
+    (void *)thunk64_vkCmdCopyAccelerationStructureToMemoryKHR,
+    (void *)thunk64_vkCmdCopyBuffer,
+    (void *)thunk64_vkCmdCopyBuffer2,
+    (void *)thunk64_vkCmdCopyBuffer2KHR,
+    (void *)thunk64_vkCmdCopyBufferToImage,
+    (void *)thunk64_vkCmdCopyBufferToImage2,
+    (void *)thunk64_vkCmdCopyBufferToImage2KHR,
+    (void *)thunk64_vkCmdCopyImage,
+    (void *)thunk64_vkCmdCopyImage2,
+    (void *)thunk64_vkCmdCopyImage2KHR,
+    (void *)thunk64_vkCmdCopyImageToBuffer,
+    (void *)thunk64_vkCmdCopyImageToBuffer2,
+    (void *)thunk64_vkCmdCopyImageToBuffer2KHR,
+    (void *)thunk64_vkCmdCopyMemoryIndirectNV,
+    (void *)thunk64_vkCmdCopyMemoryToAccelerationStructureKHR,
+    (void *)thunk64_vkCmdCopyMemoryToImageIndirectNV,
+    (void *)thunk64_vkCmdCopyMemoryToMicromapEXT,
+    (void *)thunk64_vkCmdCopyMicromapEXT,
+    (void *)thunk64_vkCmdCopyMicromapToMemoryEXT,
+    (void *)thunk64_vkCmdCopyQueryPoolResults,
+    (void *)thunk64_vkCmdCuLaunchKernelNVX,
+    (void *)thunk64_vkCmdDebugMarkerBeginEXT,
+    (void *)thunk64_vkCmdDebugMarkerEndEXT,
+    (void *)thunk64_vkCmdDebugMarkerInsertEXT,
+    (void *)thunk64_vkCmdDecompressMemoryIndirectCountNV,
+    (void *)thunk64_vkCmdDecompressMemoryNV,
+    (void *)thunk64_vkCmdDispatch,
+    (void *)thunk64_vkCmdDispatchBase,
+    (void *)thunk64_vkCmdDispatchBaseKHR,
+    (void *)thunk64_vkCmdDispatchIndirect,
+    (void *)thunk64_vkCmdDraw,
+    (void *)thunk64_vkCmdDrawIndexed,
+    (void *)thunk64_vkCmdDrawIndexedIndirect,
+    (void *)thunk64_vkCmdDrawIndexedIndirectCount,
+    (void *)thunk64_vkCmdDrawIndexedIndirectCountAMD,
+    (void *)thunk64_vkCmdDrawIndexedIndirectCountKHR,
+    (void *)thunk64_vkCmdDrawIndirect,
+    (void *)thunk64_vkCmdDrawIndirectByteCountEXT,
+    (void *)thunk64_vkCmdDrawIndirectCount,
+    (void *)thunk64_vkCmdDrawIndirectCountAMD,
+    (void *)thunk64_vkCmdDrawIndirectCountKHR,
+    (void *)thunk64_vkCmdDrawMeshTasksEXT,
+    (void *)thunk64_vkCmdDrawMeshTasksIndirectCountEXT,
+    (void *)thunk64_vkCmdDrawMeshTasksIndirectCountNV,
+    (void *)thunk64_vkCmdDrawMeshTasksIndirectEXT,
+    (void *)thunk64_vkCmdDrawMeshTasksIndirectNV,
+    (void *)thunk64_vkCmdDrawMeshTasksNV,
+    (void *)thunk64_vkCmdDrawMultiEXT,
+    (void *)thunk64_vkCmdDrawMultiIndexedEXT,
+    (void *)thunk64_vkCmdEndConditionalRenderingEXT,
+    (void *)thunk64_vkCmdEndDebugUtilsLabelEXT,
+    (void *)thunk64_vkCmdEndQuery,
+    (void *)thunk64_vkCmdEndQueryIndexedEXT,
+    (void *)thunk64_vkCmdEndRenderPass,
+    (void *)thunk64_vkCmdEndRenderPass2,
+    (void *)thunk64_vkCmdEndRenderPass2KHR,
+    (void *)thunk64_vkCmdEndRendering,
+    (void *)thunk64_vkCmdEndRenderingKHR,
+    (void *)thunk64_vkCmdEndTransformFeedbackEXT,
+    (void *)thunk64_vkCmdExecuteCommands,
+    (void *)thunk64_vkCmdExecuteGeneratedCommandsNV,
+    (void *)thunk64_vkCmdFillBuffer,
+    (void *)thunk64_vkCmdInsertDebugUtilsLabelEXT,
+    (void *)thunk64_vkCmdNextSubpass,
+    (void *)thunk64_vkCmdNextSubpass2,
+    (void *)thunk64_vkCmdNextSubpass2KHR,
+    (void *)thunk64_vkCmdOpticalFlowExecuteNV,
+    (void *)thunk64_vkCmdPipelineBarrier,
+    (void *)thunk64_vkCmdPipelineBarrier2,
+    (void *)thunk64_vkCmdPipelineBarrier2KHR,
+    (void *)thunk64_vkCmdPreprocessGeneratedCommandsNV,
+    (void *)thunk64_vkCmdPushConstants,
+    (void *)thunk64_vkCmdPushDescriptorSetKHR,
+    (void *)thunk64_vkCmdPushDescriptorSetWithTemplateKHR,
+    (void *)thunk64_vkCmdResetEvent,
+    (void *)thunk64_vkCmdResetEvent2,
+    (void *)thunk64_vkCmdResetEvent2KHR,
+    (void *)thunk64_vkCmdResetQueryPool,
+    (void *)thunk64_vkCmdResolveImage,
+    (void *)thunk64_vkCmdResolveImage2,
+    (void *)thunk64_vkCmdResolveImage2KHR,
+    (void *)thunk64_vkCmdSetAlphaToCoverageEnableEXT,
+    (void *)thunk64_vkCmdSetAlphaToOneEnableEXT,
+    (void *)thunk64_vkCmdSetBlendConstants,
+    (void *)thunk64_vkCmdSetCheckpointNV,
+    (void *)thunk64_vkCmdSetCoarseSampleOrderNV,
+    (void *)thunk64_vkCmdSetColorBlendAdvancedEXT,
+    (void *)thunk64_vkCmdSetColorBlendEnableEXT,
+    (void *)thunk64_vkCmdSetColorBlendEquationEXT,
+    (void *)thunk64_vkCmdSetColorWriteEnableEXT,
+    (void *)thunk64_vkCmdSetColorWriteMaskEXT,
+    (void *)thunk64_vkCmdSetConservativeRasterizationModeEXT,
+    (void *)thunk64_vkCmdSetCoverageModulationModeNV,
+    (void *)thunk64_vkCmdSetCoverageModulationTableEnableNV,
+    (void *)thunk64_vkCmdSetCoverageModulationTableNV,
+    (void *)thunk64_vkCmdSetCoverageReductionModeNV,
+    (void *)thunk64_vkCmdSetCoverageToColorEnableNV,
+    (void *)thunk64_vkCmdSetCoverageToColorLocationNV,
+    (void *)thunk64_vkCmdSetCullMode,
+    (void *)thunk64_vkCmdSetCullModeEXT,
+    (void *)thunk64_vkCmdSetDepthBias,
+    (void *)thunk64_vkCmdSetDepthBiasEnable,
+    (void *)thunk64_vkCmdSetDepthBiasEnableEXT,
+    (void *)thunk64_vkCmdSetDepthBounds,
+    (void *)thunk64_vkCmdSetDepthBoundsTestEnable,
+    (void *)thunk64_vkCmdSetDepthBoundsTestEnableEXT,
+    (void *)thunk64_vkCmdSetDepthClampEnableEXT,
+    (void *)thunk64_vkCmdSetDepthClipEnableEXT,
+    (void *)thunk64_vkCmdSetDepthClipNegativeOneToOneEXT,
+    (void *)thunk64_vkCmdSetDepthCompareOp,
+    (void *)thunk64_vkCmdSetDepthCompareOpEXT,
+    (void *)thunk64_vkCmdSetDepthTestEnable,
+    (void *)thunk64_vkCmdSetDepthTestEnableEXT,
+    (void *)thunk64_vkCmdSetDepthWriteEnable,
+    (void *)thunk64_vkCmdSetDepthWriteEnableEXT,
+    (void *)thunk64_vkCmdSetDescriptorBufferOffsetsEXT,
+    (void *)thunk64_vkCmdSetDeviceMask,
+    (void *)thunk64_vkCmdSetDeviceMaskKHR,
+    (void *)thunk64_vkCmdSetDiscardRectangleEXT,
+    (void *)thunk64_vkCmdSetEvent,
+    (void *)thunk64_vkCmdSetEvent2,
+    (void *)thunk64_vkCmdSetEvent2KHR,
+    (void *)thunk64_vkCmdSetExclusiveScissorNV,
+    (void *)thunk64_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
+    (void *)thunk64_vkCmdSetFragmentShadingRateEnumNV,
+    (void *)thunk64_vkCmdSetFragmentShadingRateKHR,
+    (void *)thunk64_vkCmdSetFrontFace,
+    (void *)thunk64_vkCmdSetFrontFaceEXT,
+    (void *)thunk64_vkCmdSetLineRasterizationModeEXT,
+    (void *)thunk64_vkCmdSetLineStippleEXT,
+    (void *)thunk64_vkCmdSetLineStippleEnableEXT,
+    (void *)thunk64_vkCmdSetLineWidth,
+    (void *)thunk64_vkCmdSetLogicOpEXT,
+    (void *)thunk64_vkCmdSetLogicOpEnableEXT,
+    (void *)thunk64_vkCmdSetPatchControlPointsEXT,
     thunk64_vkCmdSetPerformanceMarkerINTEL,
     thunk64_vkCmdSetPerformanceOverrideINTEL,
     thunk64_vkCmdSetPerformanceStreamMarkerINTEL,
-    thunk64_vkCmdSetPolygonModeEXT,
-    thunk64_vkCmdSetPrimitiveRestartEnable,
-    thunk64_vkCmdSetPrimitiveRestartEnableEXT,
-    thunk64_vkCmdSetPrimitiveTopology,
-    thunk64_vkCmdSetPrimitiveTopologyEXT,
-    thunk64_vkCmdSetProvokingVertexModeEXT,
-    thunk64_vkCmdSetRasterizationSamplesEXT,
-    thunk64_vkCmdSetRasterizationStreamEXT,
-    thunk64_vkCmdSetRasterizerDiscardEnable,
-    thunk64_vkCmdSetRasterizerDiscardEnableEXT,
-    thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
-    thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
-    thunk64_vkCmdSetSampleLocationsEXT,
-    thunk64_vkCmdSetSampleLocationsEnableEXT,
-    thunk64_vkCmdSetSampleMaskEXT,
-    thunk64_vkCmdSetScissor,
-    thunk64_vkCmdSetScissorWithCount,
-    thunk64_vkCmdSetScissorWithCountEXT,
-    thunk64_vkCmdSetShadingRateImageEnableNV,
-    thunk64_vkCmdSetStencilCompareMask,
-    thunk64_vkCmdSetStencilOp,
-    thunk64_vkCmdSetStencilOpEXT,
-    thunk64_vkCmdSetStencilReference,
-    thunk64_vkCmdSetStencilTestEnable,
-    thunk64_vkCmdSetStencilTestEnableEXT,
-    thunk64_vkCmdSetStencilWriteMask,
-    thunk64_vkCmdSetTessellationDomainOriginEXT,
-    thunk64_vkCmdSetVertexInputEXT,
-    thunk64_vkCmdSetViewport,
-    thunk64_vkCmdSetViewportShadingRatePaletteNV,
-    thunk64_vkCmdSetViewportSwizzleNV,
-    thunk64_vkCmdSetViewportWScalingEnableNV,
-    thunk64_vkCmdSetViewportWScalingNV,
-    thunk64_vkCmdSetViewportWithCount,
-    thunk64_vkCmdSetViewportWithCountEXT,
-    thunk64_vkCmdSubpassShadingHUAWEI,
-    thunk64_vkCmdTraceRaysIndirect2KHR,
-    thunk64_vkCmdTraceRaysIndirectKHR,
-    thunk64_vkCmdTraceRaysKHR,
-    thunk64_vkCmdTraceRaysNV,
-    thunk64_vkCmdUpdateBuffer,
-    thunk64_vkCmdWaitEvents,
-    thunk64_vkCmdWaitEvents2,
-    thunk64_vkCmdWaitEvents2KHR,
-    thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
-    thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
-    thunk64_vkCmdWriteBufferMarker2AMD,
-    thunk64_vkCmdWriteBufferMarkerAMD,
-    thunk64_vkCmdWriteMicromapsPropertiesEXT,
-    thunk64_vkCmdWriteTimestamp,
-    thunk64_vkCmdWriteTimestamp2,
-    thunk64_vkCmdWriteTimestamp2KHR,
+    (void *)thunk64_vkCmdSetPolygonModeEXT,
+    (void *)thunk64_vkCmdSetPrimitiveRestartEnable,
+    (void *)thunk64_vkCmdSetPrimitiveRestartEnableEXT,
+    (void *)thunk64_vkCmdSetPrimitiveTopology,
+    (void *)thunk64_vkCmdSetPrimitiveTopologyEXT,
+    (void *)thunk64_vkCmdSetProvokingVertexModeEXT,
+    (void *)thunk64_vkCmdSetRasterizationSamplesEXT,
+    (void *)thunk64_vkCmdSetRasterizationStreamEXT,
+    (void *)thunk64_vkCmdSetRasterizerDiscardEnable,
+    (void *)thunk64_vkCmdSetRasterizerDiscardEnableEXT,
+    (void *)thunk64_vkCmdSetRayTracingPipelineStackSizeKHR,
+    (void *)thunk64_vkCmdSetRepresentativeFragmentTestEnableNV,
+    (void *)thunk64_vkCmdSetSampleLocationsEXT,
+    (void *)thunk64_vkCmdSetSampleLocationsEnableEXT,
+    (void *)thunk64_vkCmdSetSampleMaskEXT,
+    (void *)thunk64_vkCmdSetScissor,
+    (void *)thunk64_vkCmdSetScissorWithCount,
+    (void *)thunk64_vkCmdSetScissorWithCountEXT,
+    (void *)thunk64_vkCmdSetShadingRateImageEnableNV,
+    (void *)thunk64_vkCmdSetStencilCompareMask,
+    (void *)thunk64_vkCmdSetStencilOp,
+    (void *)thunk64_vkCmdSetStencilOpEXT,
+    (void *)thunk64_vkCmdSetStencilReference,
+    (void *)thunk64_vkCmdSetStencilTestEnable,
+    (void *)thunk64_vkCmdSetStencilTestEnableEXT,
+    (void *)thunk64_vkCmdSetStencilWriteMask,
+    (void *)thunk64_vkCmdSetTessellationDomainOriginEXT,
+    (void *)thunk64_vkCmdSetVertexInputEXT,
+    (void *)thunk64_vkCmdSetViewport,
+    (void *)thunk64_vkCmdSetViewportShadingRatePaletteNV,
+    (void *)thunk64_vkCmdSetViewportSwizzleNV,
+    (void *)thunk64_vkCmdSetViewportWScalingEnableNV,
+    (void *)thunk64_vkCmdSetViewportWScalingNV,
+    (void *)thunk64_vkCmdSetViewportWithCount,
+    (void *)thunk64_vkCmdSetViewportWithCountEXT,
+    (void *)thunk64_vkCmdSubpassShadingHUAWEI,
+    (void *)thunk64_vkCmdTraceRaysIndirect2KHR,
+    (void *)thunk64_vkCmdTraceRaysIndirectKHR,
+    (void *)thunk64_vkCmdTraceRaysKHR,
+    (void *)thunk64_vkCmdTraceRaysNV,
+    (void *)thunk64_vkCmdUpdateBuffer,
+    (void *)thunk64_vkCmdWaitEvents,
+    (void *)thunk64_vkCmdWaitEvents2,
+    (void *)thunk64_vkCmdWaitEvents2KHR,
+    (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesKHR,
+    (void *)thunk64_vkCmdWriteAccelerationStructuresPropertiesNV,
+    (void *)thunk64_vkCmdWriteBufferMarker2AMD,
+    (void *)thunk64_vkCmdWriteBufferMarkerAMD,
+    (void *)thunk64_vkCmdWriteMicromapsPropertiesEXT,
+    (void *)thunk64_vkCmdWriteTimestamp,
+    (void *)thunk64_vkCmdWriteTimestamp2,
+    (void *)thunk64_vkCmdWriteTimestamp2KHR,
     thunk64_vkCompileDeferredNV,
     thunk64_vkCopyAccelerationStructureKHR,
     thunk64_vkCopyAccelerationStructureToMemoryKHR,
@@ -41089,7 +40641,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkGetCalibratedTimestampsEXT,
     thunk64_vkGetDeferredOperationMaxConcurrencyKHR,
     thunk64_vkGetDeferredOperationResultKHR,
-    thunk64_vkGetDescriptorEXT,
+    (void *)thunk64_vkGetDescriptorEXT,
     thunk64_vkGetDescriptorSetHostMappingVALVE,
     thunk64_vkGetDescriptorSetLayoutBindingOffsetEXT,
     thunk64_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
@@ -41240,9 +40792,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk64_vkTrimCommandPoolKHR,
     thunk64_vkUninitializePerformanceApiINTEL,
     thunk64_vkUnmapMemory,
-    thunk64_vkUpdateDescriptorSetWithTemplate,
+    (void *)thunk64_vkUpdateDescriptorSetWithTemplate,
     thunk64_vkUpdateDescriptorSetWithTemplateKHR,
-    thunk64_vkUpdateDescriptorSets,
+    (void *)thunk64_vkUpdateDescriptorSets,
     thunk64_vkWaitForFences,
     thunk64_vkWaitForPresentKHR,
     thunk64_vkWaitSemaphores,
@@ -41281,230 +40833,230 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkBindOpticalFlowSessionImageNV,
     thunk32_vkBuildAccelerationStructuresKHR,
     thunk32_vkBuildMicromapsEXT,
-    thunk32_vkCmdBeginConditionalRenderingEXT,
-    thunk32_vkCmdBeginDebugUtilsLabelEXT,
-    thunk32_vkCmdBeginQuery,
-    thunk32_vkCmdBeginQueryIndexedEXT,
-    thunk32_vkCmdBeginRenderPass,
-    thunk32_vkCmdBeginRenderPass2,
-    thunk32_vkCmdBeginRenderPass2KHR,
-    thunk32_vkCmdBeginRendering,
-    thunk32_vkCmdBeginRenderingKHR,
-    thunk32_vkCmdBeginTransformFeedbackEXT,
-    thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
-    thunk32_vkCmdBindDescriptorBuffersEXT,
-    thunk32_vkCmdBindDescriptorSets,
-    thunk32_vkCmdBindIndexBuffer,
-    thunk32_vkCmdBindInvocationMaskHUAWEI,
-    thunk32_vkCmdBindPipeline,
-    thunk32_vkCmdBindPipelineShaderGroupNV,
-    thunk32_vkCmdBindShadingRateImageNV,
-    thunk32_vkCmdBindTransformFeedbackBuffersEXT,
-    thunk32_vkCmdBindVertexBuffers,
-    thunk32_vkCmdBindVertexBuffers2,
-    thunk32_vkCmdBindVertexBuffers2EXT,
-    thunk32_vkCmdBlitImage,
-    thunk32_vkCmdBlitImage2,
-    thunk32_vkCmdBlitImage2KHR,
-    thunk32_vkCmdBuildAccelerationStructureNV,
-    thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
-    thunk32_vkCmdBuildAccelerationStructuresKHR,
-    thunk32_vkCmdBuildMicromapsEXT,
-    thunk32_vkCmdClearAttachments,
-    thunk32_vkCmdClearColorImage,
-    thunk32_vkCmdClearDepthStencilImage,
-    thunk32_vkCmdCopyAccelerationStructureKHR,
-    thunk32_vkCmdCopyAccelerationStructureNV,
-    thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
-    thunk32_vkCmdCopyBuffer,
-    thunk32_vkCmdCopyBuffer2,
-    thunk32_vkCmdCopyBuffer2KHR,
-    thunk32_vkCmdCopyBufferToImage,
-    thunk32_vkCmdCopyBufferToImage2,
-    thunk32_vkCmdCopyBufferToImage2KHR,
-    thunk32_vkCmdCopyImage,
-    thunk32_vkCmdCopyImage2,
-    thunk32_vkCmdCopyImage2KHR,
-    thunk32_vkCmdCopyImageToBuffer,
-    thunk32_vkCmdCopyImageToBuffer2,
-    thunk32_vkCmdCopyImageToBuffer2KHR,
-    thunk32_vkCmdCopyMemoryIndirectNV,
-    thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
-    thunk32_vkCmdCopyMemoryToImageIndirectNV,
-    thunk32_vkCmdCopyMemoryToMicromapEXT,
-    thunk32_vkCmdCopyMicromapEXT,
-    thunk32_vkCmdCopyMicromapToMemoryEXT,
-    thunk32_vkCmdCopyQueryPoolResults,
-    thunk32_vkCmdCuLaunchKernelNVX,
-    thunk32_vkCmdDebugMarkerBeginEXT,
-    thunk32_vkCmdDebugMarkerEndEXT,
-    thunk32_vkCmdDebugMarkerInsertEXT,
-    thunk32_vkCmdDecompressMemoryIndirectCountNV,
-    thunk32_vkCmdDecompressMemoryNV,
-    thunk32_vkCmdDispatch,
-    thunk32_vkCmdDispatchBase,
-    thunk32_vkCmdDispatchBaseKHR,
-    thunk32_vkCmdDispatchIndirect,
-    thunk32_vkCmdDraw,
-    thunk32_vkCmdDrawIndexed,
-    thunk32_vkCmdDrawIndexedIndirect,
-    thunk32_vkCmdDrawIndexedIndirectCount,
-    thunk32_vkCmdDrawIndexedIndirectCountAMD,
-    thunk32_vkCmdDrawIndexedIndirectCountKHR,
-    thunk32_vkCmdDrawIndirect,
-    thunk32_vkCmdDrawIndirectByteCountEXT,
-    thunk32_vkCmdDrawIndirectCount,
-    thunk32_vkCmdDrawIndirectCountAMD,
-    thunk32_vkCmdDrawIndirectCountKHR,
-    thunk32_vkCmdDrawMeshTasksEXT,
-    thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
-    thunk32_vkCmdDrawMeshTasksIndirectCountNV,
-    thunk32_vkCmdDrawMeshTasksIndirectEXT,
-    thunk32_vkCmdDrawMeshTasksIndirectNV,
-    thunk32_vkCmdDrawMeshTasksNV,
-    thunk32_vkCmdDrawMultiEXT,
-    thunk32_vkCmdDrawMultiIndexedEXT,
-    thunk32_vkCmdEndConditionalRenderingEXT,
-    thunk32_vkCmdEndDebugUtilsLabelEXT,
-    thunk32_vkCmdEndQuery,
-    thunk32_vkCmdEndQueryIndexedEXT,
-    thunk32_vkCmdEndRenderPass,
-    thunk32_vkCmdEndRenderPass2,
-    thunk32_vkCmdEndRenderPass2KHR,
-    thunk32_vkCmdEndRendering,
-    thunk32_vkCmdEndRenderingKHR,
-    thunk32_vkCmdEndTransformFeedbackEXT,
-    thunk32_vkCmdExecuteCommands,
-    thunk32_vkCmdExecuteGeneratedCommandsNV,
-    thunk32_vkCmdFillBuffer,
-    thunk32_vkCmdInsertDebugUtilsLabelEXT,
-    thunk32_vkCmdNextSubpass,
-    thunk32_vkCmdNextSubpass2,
-    thunk32_vkCmdNextSubpass2KHR,
-    thunk32_vkCmdOpticalFlowExecuteNV,
-    thunk32_vkCmdPipelineBarrier,
-    thunk32_vkCmdPipelineBarrier2,
-    thunk32_vkCmdPipelineBarrier2KHR,
-    thunk32_vkCmdPreprocessGeneratedCommandsNV,
-    thunk32_vkCmdPushConstants,
-    thunk32_vkCmdPushDescriptorSetKHR,
-    thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
-    thunk32_vkCmdResetEvent,
-    thunk32_vkCmdResetEvent2,
-    thunk32_vkCmdResetEvent2KHR,
-    thunk32_vkCmdResetQueryPool,
-    thunk32_vkCmdResolveImage,
-    thunk32_vkCmdResolveImage2,
-    thunk32_vkCmdResolveImage2KHR,
-    thunk32_vkCmdSetAlphaToCoverageEnableEXT,
-    thunk32_vkCmdSetAlphaToOneEnableEXT,
-    thunk32_vkCmdSetBlendConstants,
-    thunk32_vkCmdSetCheckpointNV,
-    thunk32_vkCmdSetCoarseSampleOrderNV,
-    thunk32_vkCmdSetColorBlendAdvancedEXT,
-    thunk32_vkCmdSetColorBlendEnableEXT,
-    thunk32_vkCmdSetColorBlendEquationEXT,
-    thunk32_vkCmdSetColorWriteEnableEXT,
-    thunk32_vkCmdSetColorWriteMaskEXT,
-    thunk32_vkCmdSetConservativeRasterizationModeEXT,
-    thunk32_vkCmdSetCoverageModulationModeNV,
-    thunk32_vkCmdSetCoverageModulationTableEnableNV,
-    thunk32_vkCmdSetCoverageModulationTableNV,
-    thunk32_vkCmdSetCoverageReductionModeNV,
-    thunk32_vkCmdSetCoverageToColorEnableNV,
-    thunk32_vkCmdSetCoverageToColorLocationNV,
-    thunk32_vkCmdSetCullMode,
-    thunk32_vkCmdSetCullModeEXT,
-    thunk32_vkCmdSetDepthBias,
-    thunk32_vkCmdSetDepthBiasEnable,
-    thunk32_vkCmdSetDepthBiasEnableEXT,
-    thunk32_vkCmdSetDepthBounds,
-    thunk32_vkCmdSetDepthBoundsTestEnable,
-    thunk32_vkCmdSetDepthBoundsTestEnableEXT,
-    thunk32_vkCmdSetDepthClampEnableEXT,
-    thunk32_vkCmdSetDepthClipEnableEXT,
-    thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
-    thunk32_vkCmdSetDepthCompareOp,
-    thunk32_vkCmdSetDepthCompareOpEXT,
-    thunk32_vkCmdSetDepthTestEnable,
-    thunk32_vkCmdSetDepthTestEnableEXT,
-    thunk32_vkCmdSetDepthWriteEnable,
-    thunk32_vkCmdSetDepthWriteEnableEXT,
-    thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
-    thunk32_vkCmdSetDeviceMask,
-    thunk32_vkCmdSetDeviceMaskKHR,
-    thunk32_vkCmdSetDiscardRectangleEXT,
-    thunk32_vkCmdSetEvent,
-    thunk32_vkCmdSetEvent2,
-    thunk32_vkCmdSetEvent2KHR,
-    thunk32_vkCmdSetExclusiveScissorNV,
-    thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
-    thunk32_vkCmdSetFragmentShadingRateEnumNV,
-    thunk32_vkCmdSetFragmentShadingRateKHR,
-    thunk32_vkCmdSetFrontFace,
-    thunk32_vkCmdSetFrontFaceEXT,
-    thunk32_vkCmdSetLineRasterizationModeEXT,
-    thunk32_vkCmdSetLineStippleEXT,
-    thunk32_vkCmdSetLineStippleEnableEXT,
-    thunk32_vkCmdSetLineWidth,
-    thunk32_vkCmdSetLogicOpEXT,
-    thunk32_vkCmdSetLogicOpEnableEXT,
-    thunk32_vkCmdSetPatchControlPointsEXT,
+    (void *)thunk32_vkCmdBeginConditionalRenderingEXT,
+    (void *)thunk32_vkCmdBeginDebugUtilsLabelEXT,
+    (void *)thunk32_vkCmdBeginQuery,
+    (void *)thunk32_vkCmdBeginQueryIndexedEXT,
+    (void *)thunk32_vkCmdBeginRenderPass,
+    (void *)thunk32_vkCmdBeginRenderPass2,
+    (void *)thunk32_vkCmdBeginRenderPass2KHR,
+    (void *)thunk32_vkCmdBeginRendering,
+    (void *)thunk32_vkCmdBeginRenderingKHR,
+    (void *)thunk32_vkCmdBeginTransformFeedbackEXT,
+    (void *)thunk32_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
+    (void *)thunk32_vkCmdBindDescriptorBuffersEXT,
+    (void *)thunk32_vkCmdBindDescriptorSets,
+    (void *)thunk32_vkCmdBindIndexBuffer,
+    (void *)thunk32_vkCmdBindInvocationMaskHUAWEI,
+    (void *)thunk32_vkCmdBindPipeline,
+    (void *)thunk32_vkCmdBindPipelineShaderGroupNV,
+    (void *)thunk32_vkCmdBindShadingRateImageNV,
+    (void *)thunk32_vkCmdBindTransformFeedbackBuffersEXT,
+    (void *)thunk32_vkCmdBindVertexBuffers,
+    (void *)thunk32_vkCmdBindVertexBuffers2,
+    (void *)thunk32_vkCmdBindVertexBuffers2EXT,
+    (void *)thunk32_vkCmdBlitImage,
+    (void *)thunk32_vkCmdBlitImage2,
+    (void *)thunk32_vkCmdBlitImage2KHR,
+    (void *)thunk32_vkCmdBuildAccelerationStructureNV,
+    (void *)thunk32_vkCmdBuildAccelerationStructuresIndirectKHR,
+    (void *)thunk32_vkCmdBuildAccelerationStructuresKHR,
+    (void *)thunk32_vkCmdBuildMicromapsEXT,
+    (void *)thunk32_vkCmdClearAttachments,
+    (void *)thunk32_vkCmdClearColorImage,
+    (void *)thunk32_vkCmdClearDepthStencilImage,
+    (void *)thunk32_vkCmdCopyAccelerationStructureKHR,
+    (void *)thunk32_vkCmdCopyAccelerationStructureNV,
+    (void *)thunk32_vkCmdCopyAccelerationStructureToMemoryKHR,
+    (void *)thunk32_vkCmdCopyBuffer,
+    (void *)thunk32_vkCmdCopyBuffer2,
+    (void *)thunk32_vkCmdCopyBuffer2KHR,
+    (void *)thunk32_vkCmdCopyBufferToImage,
+    (void *)thunk32_vkCmdCopyBufferToImage2,
+    (void *)thunk32_vkCmdCopyBufferToImage2KHR,
+    (void *)thunk32_vkCmdCopyImage,
+    (void *)thunk32_vkCmdCopyImage2,
+    (void *)thunk32_vkCmdCopyImage2KHR,
+    (void *)thunk32_vkCmdCopyImageToBuffer,
+    (void *)thunk32_vkCmdCopyImageToBuffer2,
+    (void *)thunk32_vkCmdCopyImageToBuffer2KHR,
+    (void *)thunk32_vkCmdCopyMemoryIndirectNV,
+    (void *)thunk32_vkCmdCopyMemoryToAccelerationStructureKHR,
+    (void *)thunk32_vkCmdCopyMemoryToImageIndirectNV,
+    (void *)thunk32_vkCmdCopyMemoryToMicromapEXT,
+    (void *)thunk32_vkCmdCopyMicromapEXT,
+    (void *)thunk32_vkCmdCopyMicromapToMemoryEXT,
+    (void *)thunk32_vkCmdCopyQueryPoolResults,
+    (void *)thunk32_vkCmdCuLaunchKernelNVX,
+    (void *)thunk32_vkCmdDebugMarkerBeginEXT,
+    (void *)thunk32_vkCmdDebugMarkerEndEXT,
+    (void *)thunk32_vkCmdDebugMarkerInsertEXT,
+    (void *)thunk32_vkCmdDecompressMemoryIndirectCountNV,
+    (void *)thunk32_vkCmdDecompressMemoryNV,
+    (void *)thunk32_vkCmdDispatch,
+    (void *)thunk32_vkCmdDispatchBase,
+    (void *)thunk32_vkCmdDispatchBaseKHR,
+    (void *)thunk32_vkCmdDispatchIndirect,
+    (void *)thunk32_vkCmdDraw,
+    (void *)thunk32_vkCmdDrawIndexed,
+    (void *)thunk32_vkCmdDrawIndexedIndirect,
+    (void *)thunk32_vkCmdDrawIndexedIndirectCount,
+    (void *)thunk32_vkCmdDrawIndexedIndirectCountAMD,
+    (void *)thunk32_vkCmdDrawIndexedIndirectCountKHR,
+    (void *)thunk32_vkCmdDrawIndirect,
+    (void *)thunk32_vkCmdDrawIndirectByteCountEXT,
+    (void *)thunk32_vkCmdDrawIndirectCount,
+    (void *)thunk32_vkCmdDrawIndirectCountAMD,
+    (void *)thunk32_vkCmdDrawIndirectCountKHR,
+    (void *)thunk32_vkCmdDrawMeshTasksEXT,
+    (void *)thunk32_vkCmdDrawMeshTasksIndirectCountEXT,
+    (void *)thunk32_vkCmdDrawMeshTasksIndirectCountNV,
+    (void *)thunk32_vkCmdDrawMeshTasksIndirectEXT,
+    (void *)thunk32_vkCmdDrawMeshTasksIndirectNV,
+    (void *)thunk32_vkCmdDrawMeshTasksNV,
+    (void *)thunk32_vkCmdDrawMultiEXT,
+    (void *)thunk32_vkCmdDrawMultiIndexedEXT,
+    (void *)thunk32_vkCmdEndConditionalRenderingEXT,
+    (void *)thunk32_vkCmdEndDebugUtilsLabelEXT,
+    (void *)thunk32_vkCmdEndQuery,
+    (void *)thunk32_vkCmdEndQueryIndexedEXT,
+    (void *)thunk32_vkCmdEndRenderPass,
+    (void *)thunk32_vkCmdEndRenderPass2,
+    (void *)thunk32_vkCmdEndRenderPass2KHR,
+    (void *)thunk32_vkCmdEndRendering,
+    (void *)thunk32_vkCmdEndRenderingKHR,
+    (void *)thunk32_vkCmdEndTransformFeedbackEXT,
+    (void *)thunk32_vkCmdExecuteCommands,
+    (void *)thunk32_vkCmdExecuteGeneratedCommandsNV,
+    (void *)thunk32_vkCmdFillBuffer,
+    (void *)thunk32_vkCmdInsertDebugUtilsLabelEXT,
+    (void *)thunk32_vkCmdNextSubpass,
+    (void *)thunk32_vkCmdNextSubpass2,
+    (void *)thunk32_vkCmdNextSubpass2KHR,
+    (void *)thunk32_vkCmdOpticalFlowExecuteNV,
+    (void *)thunk32_vkCmdPipelineBarrier,
+    (void *)thunk32_vkCmdPipelineBarrier2,
+    (void *)thunk32_vkCmdPipelineBarrier2KHR,
+    (void *)thunk32_vkCmdPreprocessGeneratedCommandsNV,
+    (void *)thunk32_vkCmdPushConstants,
+    (void *)thunk32_vkCmdPushDescriptorSetKHR,
+    (void *)thunk32_vkCmdPushDescriptorSetWithTemplateKHR,
+    (void *)thunk32_vkCmdResetEvent,
+    (void *)thunk32_vkCmdResetEvent2,
+    (void *)thunk32_vkCmdResetEvent2KHR,
+    (void *)thunk32_vkCmdResetQueryPool,
+    (void *)thunk32_vkCmdResolveImage,
+    (void *)thunk32_vkCmdResolveImage2,
+    (void *)thunk32_vkCmdResolveImage2KHR,
+    (void *)thunk32_vkCmdSetAlphaToCoverageEnableEXT,
+    (void *)thunk32_vkCmdSetAlphaToOneEnableEXT,
+    (void *)thunk32_vkCmdSetBlendConstants,
+    (void *)thunk32_vkCmdSetCheckpointNV,
+    (void *)thunk32_vkCmdSetCoarseSampleOrderNV,
+    (void *)thunk32_vkCmdSetColorBlendAdvancedEXT,
+    (void *)thunk32_vkCmdSetColorBlendEnableEXT,
+    (void *)thunk32_vkCmdSetColorBlendEquationEXT,
+    (void *)thunk32_vkCmdSetColorWriteEnableEXT,
+    (void *)thunk32_vkCmdSetColorWriteMaskEXT,
+    (void *)thunk32_vkCmdSetConservativeRasterizationModeEXT,
+    (void *)thunk32_vkCmdSetCoverageModulationModeNV,
+    (void *)thunk32_vkCmdSetCoverageModulationTableEnableNV,
+    (void *)thunk32_vkCmdSetCoverageModulationTableNV,
+    (void *)thunk32_vkCmdSetCoverageReductionModeNV,
+    (void *)thunk32_vkCmdSetCoverageToColorEnableNV,
+    (void *)thunk32_vkCmdSetCoverageToColorLocationNV,
+    (void *)thunk32_vkCmdSetCullMode,
+    (void *)thunk32_vkCmdSetCullModeEXT,
+    (void *)thunk32_vkCmdSetDepthBias,
+    (void *)thunk32_vkCmdSetDepthBiasEnable,
+    (void *)thunk32_vkCmdSetDepthBiasEnableEXT,
+    (void *)thunk32_vkCmdSetDepthBounds,
+    (void *)thunk32_vkCmdSetDepthBoundsTestEnable,
+    (void *)thunk32_vkCmdSetDepthBoundsTestEnableEXT,
+    (void *)thunk32_vkCmdSetDepthClampEnableEXT,
+    (void *)thunk32_vkCmdSetDepthClipEnableEXT,
+    (void *)thunk32_vkCmdSetDepthClipNegativeOneToOneEXT,
+    (void *)thunk32_vkCmdSetDepthCompareOp,
+    (void *)thunk32_vkCmdSetDepthCompareOpEXT,
+    (void *)thunk32_vkCmdSetDepthTestEnable,
+    (void *)thunk32_vkCmdSetDepthTestEnableEXT,
+    (void *)thunk32_vkCmdSetDepthWriteEnable,
+    (void *)thunk32_vkCmdSetDepthWriteEnableEXT,
+    (void *)thunk32_vkCmdSetDescriptorBufferOffsetsEXT,
+    (void *)thunk32_vkCmdSetDeviceMask,
+    (void *)thunk32_vkCmdSetDeviceMaskKHR,
+    (void *)thunk32_vkCmdSetDiscardRectangleEXT,
+    (void *)thunk32_vkCmdSetEvent,
+    (void *)thunk32_vkCmdSetEvent2,
+    (void *)thunk32_vkCmdSetEvent2KHR,
+    (void *)thunk32_vkCmdSetExclusiveScissorNV,
+    (void *)thunk32_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
+    (void *)thunk32_vkCmdSetFragmentShadingRateEnumNV,
+    (void *)thunk32_vkCmdSetFragmentShadingRateKHR,
+    (void *)thunk32_vkCmdSetFrontFace,
+    (void *)thunk32_vkCmdSetFrontFaceEXT,
+    (void *)thunk32_vkCmdSetLineRasterizationModeEXT,
+    (void *)thunk32_vkCmdSetLineStippleEXT,
+    (void *)thunk32_vkCmdSetLineStippleEnableEXT,
+    (void *)thunk32_vkCmdSetLineWidth,
+    (void *)thunk32_vkCmdSetLogicOpEXT,
+    (void *)thunk32_vkCmdSetLogicOpEnableEXT,
+    (void *)thunk32_vkCmdSetPatchControlPointsEXT,
     thunk32_vkCmdSetPerformanceMarkerINTEL,
     thunk32_vkCmdSetPerformanceOverrideINTEL,
     thunk32_vkCmdSetPerformanceStreamMarkerINTEL,
-    thunk32_vkCmdSetPolygonModeEXT,
-    thunk32_vkCmdSetPrimitiveRestartEnable,
-    thunk32_vkCmdSetPrimitiveRestartEnableEXT,
-    thunk32_vkCmdSetPrimitiveTopology,
-    thunk32_vkCmdSetPrimitiveTopologyEXT,
-    thunk32_vkCmdSetProvokingVertexModeEXT,
-    thunk32_vkCmdSetRasterizationSamplesEXT,
-    thunk32_vkCmdSetRasterizationStreamEXT,
-    thunk32_vkCmdSetRasterizerDiscardEnable,
-    thunk32_vkCmdSetRasterizerDiscardEnableEXT,
-    thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
-    thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
-    thunk32_vkCmdSetSampleLocationsEXT,
-    thunk32_vkCmdSetSampleLocationsEnableEXT,
-    thunk32_vkCmdSetSampleMaskEXT,
-    thunk32_vkCmdSetScissor,
-    thunk32_vkCmdSetScissorWithCount,
-    thunk32_vkCmdSetScissorWithCountEXT,
-    thunk32_vkCmdSetShadingRateImageEnableNV,
-    thunk32_vkCmdSetStencilCompareMask,
-    thunk32_vkCmdSetStencilOp,
-    thunk32_vkCmdSetStencilOpEXT,
-    thunk32_vkCmdSetStencilReference,
-    thunk32_vkCmdSetStencilTestEnable,
-    thunk32_vkCmdSetStencilTestEnableEXT,
-    thunk32_vkCmdSetStencilWriteMask,
-    thunk32_vkCmdSetTessellationDomainOriginEXT,
-    thunk32_vkCmdSetVertexInputEXT,
-    thunk32_vkCmdSetViewport,
-    thunk32_vkCmdSetViewportShadingRatePaletteNV,
-    thunk32_vkCmdSetViewportSwizzleNV,
-    thunk32_vkCmdSetViewportWScalingEnableNV,
-    thunk32_vkCmdSetViewportWScalingNV,
-    thunk32_vkCmdSetViewportWithCount,
-    thunk32_vkCmdSetViewportWithCountEXT,
-    thunk32_vkCmdSubpassShadingHUAWEI,
-    thunk32_vkCmdTraceRaysIndirect2KHR,
-    thunk32_vkCmdTraceRaysIndirectKHR,
-    thunk32_vkCmdTraceRaysKHR,
-    thunk32_vkCmdTraceRaysNV,
-    thunk32_vkCmdUpdateBuffer,
-    thunk32_vkCmdWaitEvents,
-    thunk32_vkCmdWaitEvents2,
-    thunk32_vkCmdWaitEvents2KHR,
-    thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
-    thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
-    thunk32_vkCmdWriteBufferMarker2AMD,
-    thunk32_vkCmdWriteBufferMarkerAMD,
-    thunk32_vkCmdWriteMicromapsPropertiesEXT,
-    thunk32_vkCmdWriteTimestamp,
-    thunk32_vkCmdWriteTimestamp2,
-    thunk32_vkCmdWriteTimestamp2KHR,
+    (void *)thunk32_vkCmdSetPolygonModeEXT,
+    (void *)thunk32_vkCmdSetPrimitiveRestartEnable,
+    (void *)thunk32_vkCmdSetPrimitiveRestartEnableEXT,
+    (void *)thunk32_vkCmdSetPrimitiveTopology,
+    (void *)thunk32_vkCmdSetPrimitiveTopologyEXT,
+    (void *)thunk32_vkCmdSetProvokingVertexModeEXT,
+    (void *)thunk32_vkCmdSetRasterizationSamplesEXT,
+    (void *)thunk32_vkCmdSetRasterizationStreamEXT,
+    (void *)thunk32_vkCmdSetRasterizerDiscardEnable,
+    (void *)thunk32_vkCmdSetRasterizerDiscardEnableEXT,
+    (void *)thunk32_vkCmdSetRayTracingPipelineStackSizeKHR,
+    (void *)thunk32_vkCmdSetRepresentativeFragmentTestEnableNV,
+    (void *)thunk32_vkCmdSetSampleLocationsEXT,
+    (void *)thunk32_vkCmdSetSampleLocationsEnableEXT,
+    (void *)thunk32_vkCmdSetSampleMaskEXT,
+    (void *)thunk32_vkCmdSetScissor,
+    (void *)thunk32_vkCmdSetScissorWithCount,
+    (void *)thunk32_vkCmdSetScissorWithCountEXT,
+    (void *)thunk32_vkCmdSetShadingRateImageEnableNV,
+    (void *)thunk32_vkCmdSetStencilCompareMask,
+    (void *)thunk32_vkCmdSetStencilOp,
+    (void *)thunk32_vkCmdSetStencilOpEXT,
+    (void *)thunk32_vkCmdSetStencilReference,
+    (void *)thunk32_vkCmdSetStencilTestEnable,
+    (void *)thunk32_vkCmdSetStencilTestEnableEXT,
+    (void *)thunk32_vkCmdSetStencilWriteMask,
+    (void *)thunk32_vkCmdSetTessellationDomainOriginEXT,
+    (void *)thunk32_vkCmdSetVertexInputEXT,
+    (void *)thunk32_vkCmdSetViewport,
+    (void *)thunk32_vkCmdSetViewportShadingRatePaletteNV,
+    (void *)thunk32_vkCmdSetViewportSwizzleNV,
+    (void *)thunk32_vkCmdSetViewportWScalingEnableNV,
+    (void *)thunk32_vkCmdSetViewportWScalingNV,
+    (void *)thunk32_vkCmdSetViewportWithCount,
+    (void *)thunk32_vkCmdSetViewportWithCountEXT,
+    (void *)thunk32_vkCmdSubpassShadingHUAWEI,
+    (void *)thunk32_vkCmdTraceRaysIndirect2KHR,
+    (void *)thunk32_vkCmdTraceRaysIndirectKHR,
+    (void *)thunk32_vkCmdTraceRaysKHR,
+    (void *)thunk32_vkCmdTraceRaysNV,
+    (void *)thunk32_vkCmdUpdateBuffer,
+    (void *)thunk32_vkCmdWaitEvents,
+    (void *)thunk32_vkCmdWaitEvents2,
+    (void *)thunk32_vkCmdWaitEvents2KHR,
+    (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesKHR,
+    (void *)thunk32_vkCmdWriteAccelerationStructuresPropertiesNV,
+    (void *)thunk32_vkCmdWriteBufferMarker2AMD,
+    (void *)thunk32_vkCmdWriteBufferMarkerAMD,
+    (void *)thunk32_vkCmdWriteMicromapsPropertiesEXT,
+    (void *)thunk32_vkCmdWriteTimestamp,
+    (void *)thunk32_vkCmdWriteTimestamp2,
+    (void *)thunk32_vkCmdWriteTimestamp2KHR,
     thunk32_vkCompileDeferredNV,
     thunk32_vkCopyAccelerationStructureKHR,
     thunk32_vkCopyAccelerationStructureToMemoryKHR,
@@ -41630,7 +41182,7 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkGetCalibratedTimestampsEXT,
     thunk32_vkGetDeferredOperationMaxConcurrencyKHR,
     thunk32_vkGetDeferredOperationResultKHR,
-    thunk32_vkGetDescriptorEXT,
+    (void *)thunk32_vkGetDescriptorEXT,
     thunk32_vkGetDescriptorSetHostMappingVALVE,
     thunk32_vkGetDescriptorSetLayoutBindingOffsetEXT,
     thunk32_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
@@ -41781,9 +41333,9 @@ const unixlib_entry_t __wine_unix_call_funcs[] =
     thunk32_vkTrimCommandPoolKHR,
     thunk32_vkUninitializePerformanceApiINTEL,
     thunk32_vkUnmapMemory,
-    thunk32_vkUpdateDescriptorSetWithTemplate,
+    (void *)thunk32_vkUpdateDescriptorSetWithTemplate,
     thunk32_vkUpdateDescriptorSetWithTemplateKHR,
-    thunk32_vkUpdateDescriptorSets,
+    (void *)thunk32_vkUpdateDescriptorSets,
     thunk32_vkWaitForFences,
     thunk32_vkWaitForPresentKHR,
     thunk32_vkWaitSemaphores,

[mbriar (＠mbriar)]

Hey, thanks for keeping me updated on this. Unfortunately, this seems to have no measurable effect for me in vkoverhead test 0, 46 or 92 (CPU is a Ryzen 3700x). But fwiw, so far I also haven't found any real games where this has an impact (tested Control and some UE4 titles), but patching all this into proton has been a bit too hairy for me. 😅
I think some good games to test would potentially be those mentioned [here](https://github.com/HansKristian-Work/vkd3d-proton/issues/1022), so Monster Hunter Rise, Death Stranding, Spider Man... Also maybe with this [PR](https://github.com/HansKristian-Work/vkd3d-proton/pull/1321) to use descriptor_buffer...

[Rémi Bernon (＠rbernon)]

On Mon Dec 12 13:49:29 2022 +0000, mbriar wrote:
> Hey, thanks for keeping me updated on this. Unfortunately, this seems to
> have no measurable effect for me in vkoverhead test 0, 46 or 92 (CPU is
> a Ryzen 3700x). But fwiw, so far I also haven't found any real games
> where this has an impact (tested Control and some UE4 titles), but
> patching all this into proton has been a bit too hairy for me. 😅
> I think some good games to test would potentially be those mentioned
> [here](https://github.com/HansKristian-Work/vkd3d-proton/issues/1022),
> so Monster Hunter Rise, Death Stranding, Spider Man... Also maybe with
> this [PR](https://github.com/HansKristian-Work/vkd3d-proton/pull/1321)
> to use descriptor_buffer...

Interesting, for me it brings test 46 from 70k (with wine-8.0-rc1) to 82k, which is roughly what direct calls were.

What does `objdump --disassemble=thunk64_vkGetDescriptorEXT dlls/winevulkan/winevulkan.so` output for instance, when you run in your 64-bit build folder with this MR?

[mbriar (＠mbriar)]

On Mon Dec 12 13:49:41 2022 +0000, Rémi Bernon wrote:
> Interesting, for me it brings test 46 from 70k (with wine-8.0-rc1) to
> 82k, which is roughly what direct calls were.
> What does `objdump --disassemble=thunk64_vkGetDescriptorEXT
> dlls/winevulkan/winevulkan.so` output for instance, when you run in your
> 64-bit build folder with this MR?

```
objdump --disassemble=thunk64_vkGetDescriptorEXT dlls/winevulkan/winevulkan.so

dlls/winevulkan/winevulkan.so:     file format elf64-x86-64

Disassembly of section .init:

Disassembly of section .plt:

Disassembly of section .text:

000000000007e4b9 <thunk64_vkGetDescriptorEXT>:
   7e4b9:	55                   	push   %rbp
   7e4ba:	48 89 e5             	mov    %rsp,%rbp
   7e4bd:	41 56                	push   %r14
   7e4bf:	41 55                	push   %r13
   7e4c1:	41 54                	push   %r12
   7e4c3:	53                   	push   %rbx
   7e4c4:	48 83 ec 20          	sub    $0x20,%rsp
   7e4c8:	48 89 7d c8          	mov    %rdi,-0x38(%rbp)
   7e4cc:	48 8b 45 c8          	mov    -0x38(%rbp),%rax
   7e4d0:	48 89 45 d8          	mov    %rax,-0x28(%rbp)
   7e4d4:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
   7e4d8:	48 8b 00             	mov    (%rax),%rax
   7e4db:	48 89 c7             	mov    %rax,%rdi
   7e4de:	e8 e7 3c fa ff       	call   221ca <wine_device_from_handle>
   7e4e3:	4c 8b b0 e8 0a 00 00 	mov    0xae8(%rax),%r14
   7e4ea:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
   7e4ee:	4c 8b 68 18          	mov    0x18(%rax),%r13
   7e4f2:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
   7e4f6:	4c 8b 60 10          	mov    0x10(%rax),%r12
   7e4fa:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
   7e4fe:	48 8b 58 08          	mov    0x8(%rax),%rbx
   7e502:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
   7e506:	48 8b 00             	mov    (%rax),%rax
   7e509:	48 89 c7             	mov    %rax,%rdi
   7e50c:	e8 b9 3c fa ff       	call   221ca <wine_device_from_handle>
   7e511:	48 8b 80 90 0e 00 00 	mov    0xe90(%rax),%rax
   7e518:	4c 89 e9             	mov    %r13,%rcx
   7e51b:	4c 89 e2             	mov    %r12,%rdx
   7e51e:	48 89 de             	mov    %rbx,%rsi
   7e521:	48 89 c7             	mov    %rax,%rdi
   7e524:	41 ff d6             	call   *%r14
   7e527:	90                   	nop
   7e528:	48 83 c4 20          	add    $0x20,%rsp
   7e52c:	5b                   	pop    %rbx
   7e52d:	41 5c                	pop    %r12
   7e52f:	41 5d                	pop    %r13
   7e531:	41 5e                	pop    %r14
   7e533:	5d                   	pop    %rbp
   7e534:	c3                   	ret

```

[Rémi Bernon (＠rbernon)]

On Mon Dec 12 14:25:50 2022 +0000, mbriar wrote:
> objdump --disassemble=thunk64_vkGetDescriptorEXT dlls/winevulkan/winevulkan.so
> dlls/winevulkan/winevulkan.so:     file format elf64-x86-64
> Disassembly of section .init:
> Disassembly of section .plt:
> Disassembly of section .text:
> 000000000007e4b9 <thunk64_vkGetDescriptorEXT>:
>    7e4b9:	55                   	push   %rbp
>    7e4ba:	48 89 e5             	mov    %rsp,%rbp
>    7e4bd:	41 56                	push   %r14
>    7e4bf:	41 55                	push   %r13
>    7e4c1:	41 54                	push   %r12
>    7e4c3:	53                   	push   %rbx
>    7e4c4:	48 83 ec 20          	sub    $0x20,%rsp
>    7e4c8:	48 89 7d c8          	mov    %rdi,-0x38(%rbp)
>    7e4cc:	48 8b 45 c8          	mov    -0x38(%rbp),%rax
>    7e4d0:	48 89 45 d8          	mov    %rax,-0x28(%rbp)
>    7e4d4:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
>    7e4d8:	48 8b 00             	mov    (%rax),%rax
>    7e4db:	48 89 c7             	mov    %rax,%rdi
>    7e4de:	e8 e7 3c fa ff       	call   221ca <wine_device_from_handle>
>    7e4e3:	4c 8b b0 e8 0a 00 00 	mov    0xae8(%rax),%r14
>    7e4ea:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
>    7e4ee:	4c 8b 68 18          	mov    0x18(%rax),%r13
>    7e4f2:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
>    7e4f6:	4c 8b 60 10          	mov    0x10(%rax),%r12
>    7e4fa:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
>    7e4fe:	48 8b 58 08          	mov    0x8(%rax),%rbx
>    7e502:	48 8b 45 d8          	mov    -0x28(%rbp),%rax
>    7e506:	48 8b 00             	mov    (%rax),%rax
>    7e509:	48 89 c7             	mov    %rax,%rdi
>    7e50c:	e8 b9 3c fa ff       	call   221ca <wine_device_from_handle>
>    7e511:	48 8b 80 90 0e 00 00 	mov    0xe90(%rax),%rax
>    7e518:	4c 89 e9             	mov    %r13,%rcx
>    7e51b:	4c 89 e2             	mov    %r12,%rdx
>    7e51e:	48 89 de             	mov    %rbx,%rsi
>    7e521:	48 89 c7             	mov    %rax,%rdi
>    7e524:	41 ff d6             	call   *%r14
>    7e527:	90                   	nop
>    7e528:	48 83 c4 20          	add    $0x20,%rsp
>    7e52c:	5b                   	pop    %rbx
>    7e52d:	41 5c                	pop    %r12
>    7e52f:	41 5d                	pop    %r13
>    7e531:	41 5e                	pop    %r14
>    7e533:	5d                   	pop    %rbp
>    7e534:	c3                   	ret

Well I'm afraid to say that it looks like you're building this without any optimization. You should use O2 at least when running benchmarks.

[Rémi Bernon (＠rbernon)]

On Mon Dec 12 14:32:43 2022 +0000, Rémi Bernon wrote:
> Well I'm afraid to say that it looks like you're building this without
> any optimization. You should use `-O2` at least when running benchmarks.

FWIW it should probably look like:
```
0000000000022960 <thunk64_vkGetDescriptorEXT>:
   22960:	48 8b 07             	mov    (%rdi),%rax
   22963:	48 8b 4f 18          	mov    0x18(%rdi),%rcx
   22967:	48 8b 57 10          	mov    0x10(%rdi),%rdx
   2296b:	48 8b 77 08          	mov    0x8(%rdi),%rsi
   2296f:	48 8b 40 08          	mov    0x8(%rax),%rax
   22973:	48 8b b8 90 0e 00 00 	mov    0xe90(%rax),%rdi
   2297a:	ff a0 e8 0a 00 00    	jmp    *0xae8(%rax)
```

[mbriar (＠mbriar)]

On Mon Dec 12 14:33:10 2022 +0000, Rémi Bernon wrote:
> FWIW it should probably look like:
> 0000000000022960 <thunk64_vkGetDescriptorEXT>:
>    22960:	48 8b 07             	mov    (%rdi),%rax
>    22963:	48 8b 4f 18          	mov    0x18(%rdi),%rcx
>    22967:	48 8b 57 10          	mov    0x10(%rdi),%rdx
>    2296b:	48 8b 77 08          	mov    0x8(%rdi),%rsi
>    2296f:	48 8b 40 08          	mov    0x8(%rax),%rax
>    22973:	48 8b b8 90 0e 00 00 	mov    0xe90(%rax),%rdi
>    2297a:	ff a0 e8 0a 00 00    	jmp    *0xae8(%rax)

Oh wow, sorry, I somehow assumed -O2 would be the default like it is with most projects using meson nowadays, I'll rebuild and try this again.

[Rémi Bernon (＠rbernon)]

On Mon Dec 12 14:35:05 2022 +0000, mbriar wrote:
> Oh wow, sorry, I somehow assumed -O2 would be the default like it is
> with most projects using meson nowadays, I'll rebuild and try this again.

I think it should be set as the default by Wine `configure`, but either it's broken and we have a regression, or somehow it's broken for you?

[mbriar (＠mbriar)]

On Mon Dec 12 14:40:15 2022 +0000, Rémi Bernon wrote:
> I think it should be set as the default by Wine `configure`, but either
> it's broken and we have a regression, or somehow it's broken for you?

I don't know, I just did
```
../configure --enable-win64
make -j16 -s
```
and apparently that resulted in a build without optimizations..

[mbriar (＠mbriar)]

On Mon Dec 12 14:47:51 2022 +0000, mbriar wrote:
> I don't know, I just did
> ../configure --enable-win64
> make -j16 -s
>
> and apparently that resulted in a build without optimizations..

But yeah, explicitly enabling optimization with `../configure --enable-win64 CFLAGS="-O2" CROSSCFLAGS="-O2"` also gets me very close to the numbers with direct calls, although I probably have to run the direct call tests again as well, since I likely used a build without optimizations there too.

[Rémi Bernon (＠rbernon)]

On Mon Dec 12 14:51:47 2022 +0000, mbriar wrote:
> But yeah, explicitly enabling optimization with `../configure
> --enable-win64 CFLAGS="-O2" CROSSCFLAGS="-O2"` also gets me very close
> to the numbers with direct calls, although I probably have to run the
> direct call tests again as well, since I likely used a build without
> optimizations there too.

```
../configure --enable-win64
make -j16 -s
```

This should work, but it also likely depends on `CFLAGS` environment variable. If it is defined, even empty, it will take over the default.

[mbriar (＠mbriar)]

On Mon Dec 12 14:52:43 2022 +0000, Rémi Bernon wrote:
> ../configure --enable-win64
> make -j16 -s
>
> This should work, but it also likely depends on `CFLAGS` environment
> variable. If it is defined, even empty, it will take over the default.

Yeah, I just checked and I had some nonsense in CFLAGS as global environment variable I forgot about, sorry about the noise..

[mbriar (＠mbriar)]

On Mon Dec 12 14:53:52 2022 +0000, mbriar wrote:
> Yeah, I just checked and I had some nonsense in CFLAGS as global
> environment variable I forgot about, sorry about the noise..

OK, new numbers for test 46, now with -O2 enabled for all builds:

- wine-8.0-rc1: ~53000
- wine-8.0-rc1 + this MR: ~56000
- wine-8.0-rc1 with direct calls (git revert -n c4f46feffc44709fa94819948f0ecb6c017d9de5 2f41d8511882253c6f3c2b031255173b40416b29): ~63000

Sanity check for a build of wine-8.0-rc1 + this MR:  
```
objdump --disassemble=thunk64_vkUpdateDescriptorSets dlls/winevulkan/winevulkan.so

dlls/winevulkan/winevulkan.so:     file format elf64-x86-64

Disassembly of section .init:

Disassembly of section .plt:

Disassembly of section .text:

0000000000022a20 <thunk64_vkUpdateDescriptorSets>:
   22a20:	48 8b 07             	mov    (%rdi),%rax
   22a23:	8b 4f 18             	mov    0x18(%rdi),%ecx
   22a26:	48 8b 57 10          	mov    0x10(%rdi),%rdx
   22a2a:	8b 77 08             	mov    0x8(%rdi),%esi
   22a2d:	48 8b 40 08          	mov    0x8(%rax),%rax
   22a31:	4c 8b 47 20          	mov    0x20(%rdi),%r8
   22a35:	4c 8b 88 90 0e 00 00 	mov    0xe90(%rax),%r9
   22a3c:	48 8b 80 48 0e 00 00 	mov    0xe48(%rax),%rax
   22a43:	4c 89 cf             	mov    %r9,%rdi
   22a46:	ff e0                	jmp    *%rax

Disassembly of section .fini:

```