[PATCH 0/1] MR11164: winevulkan: Do not show debug assertion dialog on Unix side exceptions.

[Paul Gofman (＠gofman)]

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/11164

[PATCH 1/1] winevulkan: Do not show debug assertion dialog on Unix side exceptions.

[Paul Gofman]

From: Paul Gofman <[e-mail]>

---
 dlls/winevulkan/loader.c        |   44 +-
 dlls/winevulkan/loader_thunks.c | 1656 ++++++++-----------------------
 dlls/winevulkan/make_vulkan     |    5 +-
 dlls/winevulkan/vulkan_loader.h |   10 +-
 4 files changed, 435 insertions(+), 1280 deletions(-)

diff --git a/dlls/winevulkan/loader.c b/dlls/winevulkan/loader.c
index 684d201339f..864328e3f4f 100644
--- a/dlls/winevulkan/loader.c
+++ b/dlls/winevulkan/loader.c
@@ -376,7 +376,6 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,
     const VkApplicationInfo *app_info;
     struct VkInstance_T *instance;
     uint32_t device_count = 8, i;
-    NTSTATUS status;
 
     TRACE("create_info %p, allocator %p, instance %p\n", create_info, allocator, ret);
 
@@ -415,8 +414,7 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,
         params.pCreateInfo = create_info;
         params.pAllocator = allocator;
         params.pInstance = ret;
-        status = UNIX_CALL(vkCreateInstance, ¶ms);
-        assert(!status);
+        UNIX_CALL_CHECKED(vkCreateInstance, ¶ms);
         if (instance->physical_device_count <= device_count)
             break;
         device_count = instance->physical_device_count;
@@ -435,12 +433,10 @@ VkResult WINAPI vkCreateInstance(const VkInstanceCreateInfo *create_info,
 void WINAPI vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyInstance_params params;
-    NTSTATUS status;
 
     params.instance = instance;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyInstance, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkDestroyInstance, ¶ms);
     free(instance);
 }
 
@@ -452,13 +448,11 @@ static VkResult enum_host_instance_extension_properties(const char *layer_name,
         .pLayerName = layer_name,
         .pPropertyCount = count,
     };
-    NTSTATUS status;
 
     for (;;)
     {
         *properties = params.pProperties;
-        status = UNIX_CALL(vkEnumerateInstanceExtensionProperties, ¶ms);
-        assert(!status && "vkEnumerateInstanceExtensionProperties");
+        UNIX_CALL_CHECKED(vkEnumerateInstanceExtensionProperties, ¶ms);
         if (params.result == VK_INCOMPLETE)
         {
             free(params.pProperties);
@@ -527,13 +521,11 @@ static VkResult enum_host_device_extension_properties(VkPhysicalDevice physical_
         .pLayerName = layer_name,
         .pPropertyCount = count,
     };
-    NTSTATUS status;
 
     for (;;)
     {
         *properties = params.pProperties;
-        status = UNIX_CALL(vkEnumerateDeviceExtensionProperties, ¶ms);
-        assert(!status && "vkEnumerateDeviceExtensionProperties");
+        UNIX_CALL_CHECKED(vkEnumerateDeviceExtensionProperties, ¶ms);
         if (params.result == VK_INCOMPLETE)
         {
             free(params.pProperties);
@@ -608,7 +600,6 @@ done:
 VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version)
 {
     struct vkEnumerateInstanceVersion_params params;
-    NTSTATUS status;
 
     TRACE("%p\n", version);
 
@@ -619,8 +610,7 @@ VkResult WINAPI vkEnumerateInstanceVersion(uint32_t *version)
     }
 
     params.pApiVersion = version;
-    status = UNIX_CALL(vkEnumerateInstanceVersion, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkEnumerateInstanceVersion, ¶ms);
     return params.result;
 }
 
@@ -631,7 +621,6 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC
     struct vkCreateDevice_params params;
     uint32_t queue_count = 0, i;
     VkDevice device;
-    NTSTATUS status;
 
     TRACE("Enabling %u client device extensions\n", create_info->enabledExtensionCount);
     for (uint32_t i = 0; i < create_info->enabledExtensionCount; i++)
@@ -656,8 +645,7 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC
     params.pAllocator = allocator;
     params.pDevice = ret;
 
-    status = UNIX_CALL(vkCreateDevice, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkCreateDevice, ¶ms);
     if (params.result)
     {
         free(device);
@@ -669,12 +657,10 @@ VkResult WINAPI vkCreateDevice(VkPhysicalDevice physical_device, const VkDeviceC
 void WINAPI vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *allocator)
 {
     struct vkDestroyDevice_params params;
-    NTSTATUS status;
 
     params.device = device;
     params.pAllocator = allocator;
-    status = UNIX_CALL(vkDestroyDevice, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkDestroyDevice, ¶ms);
     free(device);
 }
 
@@ -683,7 +669,6 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn
 {
     struct vkCreateCommandPool_params params;
     struct vk_command_pool *cmd_pool;
-    NTSTATUS status;
 
     if (!(cmd_pool = vulkan_client_object_create(sizeof(*cmd_pool))))
         return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -694,8 +679,7 @@ VkResult WINAPI vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateIn
     params.pCreateInfo = create_info;
     params.pAllocator = allocator;
     params.pCommandPool = ret;
-    status = UNIX_CALL(vkCreateCommandPool, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkCreateCommandPool, ¶ms);
     if (params.result)
     {
         free(cmd_pool);
@@ -709,7 +693,6 @@ void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool handle, const Vk
     struct vk_command_pool *cmd_pool = command_pool_from_handle(handle);
     struct vkDestroyCommandPool_params params;
     VkCommandBuffer buffer, cursor;
-    NTSTATUS status;
 
     if (!cmd_pool)
         return;
@@ -726,8 +709,7 @@ void WINAPI vkDestroyCommandPool(VkDevice device, VkCommandPool handle, const Vk
     params.device = device;
     params.commandPool = handle;
     params.pAllocator = allocator;
-    status = UNIX_CALL(vkDestroyCommandPool, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkDestroyCommandPool, ¶ms);
     free(cmd_pool);
 }
 
@@ -736,7 +718,6 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA
 {
     struct vk_command_pool *pool = command_pool_from_handle(allocate_info->commandPool);
     struct vkAllocateCommandBuffers_params params;
-    NTSTATUS status;
     uint32_t i;
 
     for (i = 0; i < allocate_info->commandBufferCount; i++)
@@ -745,8 +726,7 @@ VkResult WINAPI vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferA
     params.device = device;
     params.pAllocateInfo = allocate_info;
     params.pCommandBuffers = buffers;
-    status = UNIX_CALL(vkAllocateCommandBuffers, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkAllocateCommandBuffers, ¶ms);
     if (params.result == VK_SUCCESS)
     {
         for (i = 0; i < allocate_info->commandBufferCount; i++)
@@ -767,15 +747,13 @@ void WINAPI vkFreeCommandBuffers(VkDevice device, VkCommandPool cmd_pool, uint32
                                  const VkCommandBuffer *buffers)
 {
     struct vkFreeCommandBuffers_params params;
-    NTSTATUS status;
     uint32_t i;
 
     params.device = device;
     params.commandPool = cmd_pool;
     params.commandBufferCount = count;
     params.pCommandBuffers = buffers;
-    status = UNIX_CALL(vkFreeCommandBuffers, ¶ms);
-    assert(!status);
+    UNIX_CALL_CHECKED(vkFreeCommandBuffers, ¶ms);
     for (i = 0; i < count; i++)
     {
         if (!buffers[i])
diff --git a/dlls/winevulkan/loader_thunks.c b/dlls/winevulkan/loader_thunks.c
index d8d2365a0e3..6a0cfdebf59 100644
--- a/dlls/winevulkan/loader_thunks.c
+++ b/dlls/winevulkan/loader_thunks.c
@@ -21,271 +21,227 @@ WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
 VkResult WINAPI vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, uint32_t *pImageIndex)
 {
     struct vkAcquireNextImage2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pAcquireInfo = pAcquireInfo;
     params.pImageIndex = pImageIndex;
-    status = UNIX_CALL(vkAcquireNextImage2KHR, ¶ms);
-    assert(!status && "vkAcquireNextImage2KHR");
+    UNIX_CALL_CHECKED(vkAcquireNextImage2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
 {
     struct vkAcquireNextImageKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.timeout = timeout;
     params.semaphore = semaphore;
     params.fence = fence;
     params.pImageIndex = pImageIndex;
-    status = UNIX_CALL(vkAcquireNextImageKHR, ¶ms);
-    assert(!status && "vkAcquireNextImageKHR");
+    UNIX_CALL_CHECKED(vkAcquireNextImageKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL *pAcquireInfo, VkPerformanceConfigurationINTEL *pConfiguration)
 {
     struct vkAcquirePerformanceConfigurationINTEL_params params;
-    NTSTATUS status;
     params.device = device;
     params.pAcquireInfo = pAcquireInfo;
     params.pConfiguration = pConfiguration;
-    status = UNIX_CALL(vkAcquirePerformanceConfigurationINTEL, ¶ms);
-    assert(!status && "vkAcquirePerformanceConfigurationINTEL");
+    UNIX_CALL_CHECKED(vkAcquirePerformanceConfigurationINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR *pInfo)
 {
     struct vkAcquireProfilingLockKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkAcquireProfilingLockKHR, ¶ms);
-    assert(!status && "vkAcquireProfilingLockKHR");
+    UNIX_CALL_CHECKED(vkAcquireProfilingLockKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo, VkDescriptorSet *pDescriptorSets)
 {
     struct vkAllocateDescriptorSets_params params;
-    NTSTATUS status;
     params.device = device;
     params.pAllocateInfo = pAllocateInfo;
     params.pDescriptorSets = pDescriptorSets;
-    status = UNIX_CALL(vkAllocateDescriptorSets, ¶ms);
-    assert(!status && "vkAllocateDescriptorSets");
+    UNIX_CALL_CHECKED(vkAllocateDescriptorSets, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory)
 {
     struct vkAllocateMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.pAllocateInfo = pAllocateInfo;
     params.pAllocator = pAllocator;
     params.pMemory = pMemory;
-    status = UNIX_CALL(vkAllocateMemory, ¶ms);
-    assert(!status && "vkAllocateMemory");
+    UNIX_CALL_CHECKED(vkAllocateMemory, ¶ms);
     return params.result;
 }
 
 void WINAPI vkAntiLagUpdateAMD(VkDevice device, const VkAntiLagDataAMD *pData)
 {
     struct vkAntiLagUpdateAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.pData = pData;
-    status = UNIX_CALL(vkAntiLagUpdateAMD, ¶ms);
-    assert(!status && "vkAntiLagUpdateAMD");
+    UNIX_CALL_CHECKED(vkAntiLagUpdateAMD, ¶ms);
 }
 
 VkResult WINAPI vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
 {
     struct vkBeginCommandBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pBeginInfo = pBeginInfo;
-    status = UNIX_CALL(vkBeginCommandBuffer, ¶ms);
-    assert(!status && "vkBeginCommandBuffer");
+    UNIX_CALL_CHECKED(vkBeginCommandBuffer, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos)
 {
     struct vkBindAccelerationStructureMemoryNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindAccelerationStructureMemoryNV, ¶ms);
-    assert(!status && "vkBindAccelerationStructureMemoryNV");
+    UNIX_CALL_CHECKED(vkBindAccelerationStructureMemoryNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     struct vkBindBufferMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.buffer = buffer;
     params.memory = memory;
     params.memoryOffset = memoryOffset;
-    status = UNIX_CALL(vkBindBufferMemory, ¶ms);
-    assert(!status && "vkBindBufferMemory");
+    UNIX_CALL_CHECKED(vkBindBufferMemory, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
     struct vkBindBufferMemory2_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindBufferMemory2, ¶ms);
-    assert(!status && "vkBindBufferMemory2");
+    UNIX_CALL_CHECKED(vkBindBufferMemory2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos)
 {
     struct vkBindBufferMemory2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindBufferMemory2KHR, ¶ms);
-    assert(!status && "vkBindBufferMemory2KHR");
+    UNIX_CALL_CHECKED(vkBindBufferMemory2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindDataGraphPipelineSessionMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM *pBindInfos)
 {
     struct vkBindDataGraphPipelineSessionMemoryARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindDataGraphPipelineSessionMemoryARM, ¶ms);
-    assert(!status && "vkBindDataGraphPipelineSessionMemoryARM");
+    UNIX_CALL_CHECKED(vkBindDataGraphPipelineSessionMemoryARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
 {
     struct vkBindImageMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.memory = memory;
     params.memoryOffset = memoryOffset;
-    status = UNIX_CALL(vkBindImageMemory, ¶ms);
-    assert(!status && "vkBindImageMemory");
+    UNIX_CALL_CHECKED(vkBindImageMemory, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
     struct vkBindImageMemory2_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindImageMemory2, ¶ms);
-    assert(!status && "vkBindImageMemory2");
+    UNIX_CALL_CHECKED(vkBindImageMemory2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos)
 {
     struct vkBindImageMemory2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindImageMemory2KHR, ¶ms);
-    assert(!status && "vkBindImageMemory2KHR");
+    UNIX_CALL_CHECKED(vkBindImageMemory2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
 {
     struct vkBindOpticalFlowSessionImageNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.session = session;
     params.bindingPoint = bindingPoint;
     params.view = view;
     params.layout = layout;
-    status = UNIX_CALL(vkBindOpticalFlowSessionImageNV, ¶ms);
-    assert(!status && "vkBindOpticalFlowSessionImageNV");
+    UNIX_CALL_CHECKED(vkBindOpticalFlowSessionImageNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindTensorMemoryARM(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM *pBindInfos)
 {
     struct vkBindTensorMemoryARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfos = pBindInfos;
-    status = UNIX_CALL(vkBindTensorMemoryARM, ¶ms);
-    assert(!status && "vkBindTensorMemoryARM");
+    UNIX_CALL_CHECKED(vkBindTensorMemoryARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR *pBindSessionMemoryInfos)
 {
     struct vkBindVideoSessionMemoryKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.videoSession = videoSession;
     params.bindSessionMemoryInfoCount = bindSessionMemoryInfoCount;
     params.pBindSessionMemoryInfos = pBindSessionMemoryInfos;
-    status = UNIX_CALL(vkBindVideoSessionMemoryKHR, ¶ms);
-    assert(!status && "vkBindVideoSessionMemoryKHR");
+    UNIX_CALL_CHECKED(vkBindVideoSessionMemoryKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR *pInfos, const VkAccelerationStructureBuildRangeInfoKHR * const*ppBuildRangeInfos)
 {
     struct vkBuildAccelerationStructuresKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.infoCount = infoCount;
     params.pInfos = pInfos;
     params.ppBuildRangeInfos = ppBuildRangeInfos;
-    status = UNIX_CALL(vkBuildAccelerationStructuresKHR, ¶ms);
-    assert(!status && "vkBuildAccelerationStructuresKHR");
+    UNIX_CALL_CHECKED(vkBuildAccelerationStructuresKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT *pInfos)
 {
     struct vkBuildMicromapsEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.infoCount = infoCount;
     params.pInfos = pInfos;
-    status = UNIX_CALL(vkBuildMicromapsEXT, ¶ms);
-    assert(!status && "vkBuildMicromapsEXT");
+    UNIX_CALL_CHECKED(vkBuildMicromapsEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkClearShaderInstrumentationMetricsARM(VkDevice device, VkShaderInstrumentationARM instrumentation)
 {
     struct vkClearShaderInstrumentationMetricsARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.instrumentation = instrumentation;
-    status = UNIX_CALL(vkClearShaderInstrumentationMetricsARM, ¶ms);
-    assert(!status && "vkClearShaderInstrumentationMetricsARM");
+    UNIX_CALL_CHECKED(vkClearShaderInstrumentationMetricsARM, ¶ms);
 }
 
 void WINAPI vkCmdBeginConditionalRendering2EXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfo2EXT *pConditionalRenderingBegin)
@@ -323,24 +279,20 @@ void WINAPI vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const Vk
 VkResult WINAPI vkCmdBeginGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession, const VkGpaSampleBeginInfoAMD *pGpaSampleBeginInfo, uint32_t *pSampleID)
 {
     struct vkCmdBeginGpaSampleAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.gpaSession = gpaSession;
     params.pGpaSampleBeginInfo = pGpaSampleBeginInfo;
     params.pSampleID = pSampleID;
-    status = UNIX_CALL(vkCmdBeginGpaSampleAMD, ¶ms);
-    assert(!status && "vkCmdBeginGpaSampleAMD");
+    UNIX_CALL_CHECKED(vkCmdBeginGpaSampleAMD, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCmdBeginGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession)
 {
     struct vkCmdBeginGpaSessionAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.gpaSession = gpaSession;
-    status = UNIX_CALL(vkCmdBeginGpaSessionAMD, ¶ms);
-    assert(!status && "vkCmdBeginGpaSessionAMD");
+    UNIX_CALL_CHECKED(vkCmdBeginGpaSessionAMD, ¶ms);
     return params.result;
 }
 
@@ -1599,11 +1551,9 @@ void WINAPI vkCmdEndGpaSampleAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD
 VkResult WINAPI vkCmdEndGpaSessionAMD(VkCommandBuffer commandBuffer, VkGpaSessionAMD gpaSession)
 {
     struct vkCmdEndGpaSessionAMD_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.gpaSession = gpaSession;
-    status = UNIX_CALL(vkCmdEndGpaSessionAMD, ¶ms);
-    assert(!status && "vkCmdEndGpaSessionAMD");
+    UNIX_CALL_CHECKED(vkCmdEndGpaSessionAMD, ¶ms);
     return params.result;
 }
 
@@ -2601,33 +2551,27 @@ void WINAPI vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_
 VkResult WINAPI vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL *pMarkerInfo)
 {
     struct vkCmdSetPerformanceMarkerINTEL_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    status = UNIX_CALL(vkCmdSetPerformanceMarkerINTEL, ¶ms);
-    assert(!status && "vkCmdSetPerformanceMarkerINTEL");
+    UNIX_CALL_CHECKED(vkCmdSetPerformanceMarkerINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL *pOverrideInfo)
 {
     struct vkCmdSetPerformanceOverrideINTEL_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pOverrideInfo = pOverrideInfo;
-    status = UNIX_CALL(vkCmdSetPerformanceOverrideINTEL, ¶ms);
-    assert(!status && "vkCmdSetPerformanceOverrideINTEL");
+    UNIX_CALL_CHECKED(vkCmdSetPerformanceOverrideINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL *pMarkerInfo)
 {
     struct vkCmdSetPerformanceStreamMarkerINTEL_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.pMarkerInfo = pMarkerInfo;
-    status = UNIX_CALL(vkCmdSetPerformanceStreamMarkerINTEL, ¶ms);
-    assert(!status && "vkCmdSetPerformanceStreamMarkerINTEL");
+    UNIX_CALL_CHECKED(vkCmdSetPerformanceStreamMarkerINTEL, ¶ms);
     return params.result;
 }
 
@@ -3209,287 +3153,240 @@ void WINAPI vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineSta
 VkResult WINAPI vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
 {
     struct vkCompileDeferredNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.shader = shader;
-    status = UNIX_CALL(vkCompileDeferredNV, ¶ms);
-    assert(!status && "vkCompileDeferredNV");
+    UNIX_CALL_CHECKED(vkCompileDeferredNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkConvertCooperativeVectorMatrixNV(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV *pInfo)
 {
     struct vkConvertCooperativeVectorMatrixNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkConvertCooperativeVectorMatrixNV, ¶ms);
-    assert(!status && "vkConvertCooperativeVectorMatrixNV");
+    UNIX_CALL_CHECKED(vkConvertCooperativeVectorMatrixNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR *pInfo)
 {
     struct vkCopyAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyAccelerationStructureKHR, ¶ms);
-    assert(!status && "vkCopyAccelerationStructureKHR");
+    UNIX_CALL_CHECKED(vkCopyAccelerationStructureKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR *pInfo)
 {
     struct vkCopyAccelerationStructureToMemoryKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyAccelerationStructureToMemoryKHR, ¶ms);
-    assert(!status && "vkCopyAccelerationStructureToMemoryKHR");
+    UNIX_CALL_CHECKED(vkCopyAccelerationStructureToMemoryKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyImageToImage(VkDevice device, const VkCopyImageToImageInfo *pCopyImageToImageInfo)
 {
     struct vkCopyImageToImage_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyImageToImageInfo = pCopyImageToImageInfo;
-    status = UNIX_CALL(vkCopyImageToImage, ¶ms);
-    assert(!status && "vkCopyImageToImage");
+    UNIX_CALL_CHECKED(vkCopyImageToImage, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyImageToImageEXT(VkDevice device, const VkCopyImageToImageInfo *pCopyImageToImageInfo)
 {
     struct vkCopyImageToImageEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyImageToImageInfo = pCopyImageToImageInfo;
-    status = UNIX_CALL(vkCopyImageToImageEXT, ¶ms);
-    assert(!status && "vkCopyImageToImageEXT");
+    UNIX_CALL_CHECKED(vkCopyImageToImageEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyImageToMemory(VkDevice device, const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
 {
     struct vkCopyImageToMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo;
-    status = UNIX_CALL(vkCopyImageToMemory, ¶ms);
-    assert(!status && "vkCopyImageToMemory");
+    UNIX_CALL_CHECKED(vkCopyImageToMemory, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyImageToMemoryEXT(VkDevice device, const VkCopyImageToMemoryInfo *pCopyImageToMemoryInfo)
 {
     struct vkCopyImageToMemoryEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyImageToMemoryInfo = pCopyImageToMemoryInfo;
-    status = UNIX_CALL(vkCopyImageToMemoryEXT, ¶ms);
-    assert(!status && "vkCopyImageToMemoryEXT");
+    UNIX_CALL_CHECKED(vkCopyImageToMemoryEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR *pInfo)
 {
     struct vkCopyMemoryToAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyMemoryToAccelerationStructureKHR, ¶ms);
-    assert(!status && "vkCopyMemoryToAccelerationStructureKHR");
+    UNIX_CALL_CHECKED(vkCopyMemoryToAccelerationStructureKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMemoryToImage(VkDevice device, const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
 {
     struct vkCopyMemoryToImage_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo;
-    status = UNIX_CALL(vkCopyMemoryToImage, ¶ms);
-    assert(!status && "vkCopyMemoryToImage");
+    UNIX_CALL_CHECKED(vkCopyMemoryToImage, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMemoryToImageEXT(VkDevice device, const VkCopyMemoryToImageInfo *pCopyMemoryToImageInfo)
 {
     struct vkCopyMemoryToImageEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCopyMemoryToImageInfo = pCopyMemoryToImageInfo;
-    status = UNIX_CALL(vkCopyMemoryToImageEXT, ¶ms);
-    assert(!status && "vkCopyMemoryToImageEXT");
+    UNIX_CALL_CHECKED(vkCopyMemoryToImageEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT *pInfo)
 {
     struct vkCopyMemoryToMicromapEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyMemoryToMicromapEXT, ¶ms);
-    assert(!status && "vkCopyMemoryToMicromapEXT");
+    UNIX_CALL_CHECKED(vkCopyMemoryToMicromapEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT *pInfo)
 {
     struct vkCopyMicromapEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyMicromapEXT, ¶ms);
-    assert(!status && "vkCopyMicromapEXT");
+    UNIX_CALL_CHECKED(vkCopyMicromapEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT *pInfo)
 {
     struct vkCopyMicromapToMemoryEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkCopyMicromapToMemoryEXT, ¶ms);
-    assert(!status && "vkCopyMicromapToMemoryEXT");
+    UNIX_CALL_CHECKED(vkCopyMicromapToMemoryEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateAccelerationStructure2KHR(VkDevice device, const VkAccelerationStructureCreateInfo2KHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 {
     struct vkCreateAccelerationStructure2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pAccelerationStructure = pAccelerationStructure;
-    status = UNIX_CALL(vkCreateAccelerationStructure2KHR, ¶ms);
-    assert(!status && "vkCreateAccelerationStructure2KHR");
+    UNIX_CALL_CHECKED(vkCreateAccelerationStructure2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureKHR *pAccelerationStructure)
 {
     struct vkCreateAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pAccelerationStructure = pAccelerationStructure;
-    status = UNIX_CALL(vkCreateAccelerationStructureKHR, ¶ms);
-    assert(!status && "vkCreateAccelerationStructureKHR");
+    UNIX_CALL_CHECKED(vkCreateAccelerationStructureKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkAccelerationStructureNV *pAccelerationStructure)
 {
     struct vkCreateAccelerationStructureNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pAccelerationStructure = pAccelerationStructure;
-    status = UNIX_CALL(vkCreateAccelerationStructureNV, ¶ms);
-    assert(!status && "vkCreateAccelerationStructureNV");
+    UNIX_CALL_CHECKED(vkCreateAccelerationStructureNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer)
 {
     struct vkCreateBuffer_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pBuffer = pBuffer;
-    status = UNIX_CALL(vkCreateBuffer, ¶ms);
-    assert(!status && "vkCreateBuffer");
+    UNIX_CALL_CHECKED(vkCreateBuffer, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView)
 {
     struct vkCreateBufferView_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pView = pView;
-    status = UNIX_CALL(vkCreateBufferView, ¶ms);
-    assert(!status && "vkCreateBufferView");
+    UNIX_CALL_CHECKED(vkCreateBufferView, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     struct vkCreateComputePipelines_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineCache = pipelineCache;
     params.createInfoCount = createInfoCount;
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    status = UNIX_CALL(vkCreateComputePipelines, ¶ms);
-    assert(!status && "vkCreateComputePipelines");
+    UNIX_CALL_CHECKED(vkCreateComputePipelines, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuFunctionNVX *pFunction)
 {
     struct vkCreateCuFunctionNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFunction = pFunction;
-    status = UNIX_CALL(vkCreateCuFunctionNVX, ¶ms);
-    assert(!status && "vkCreateCuFunctionNVX");
+    UNIX_CALL_CHECKED(vkCreateCuFunctionNVX, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCuModuleNVX *pModule)
 {
     struct vkCreateCuModuleNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pModule = pModule;
-    status = UNIX_CALL(vkCreateCuModuleNVX, ¶ms);
-    assert(!status && "vkCreateCuModuleNVX");
+    UNIX_CALL_CHECKED(vkCreateCuModuleNVX, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDataGraphPipelineSessionARM(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDataGraphPipelineSessionARM *pSession)
 {
     struct vkCreateDataGraphPipelineSessionARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSession = pSession;
-    status = UNIX_CALL(vkCreateDataGraphPipelineSessionARM, ¶ms);
-    assert(!status && "vkCreateDataGraphPipelineSessionARM");
+    UNIX_CALL_CHECKED(vkCreateDataGraphPipelineSessionARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     struct vkCreateDataGraphPipelinesARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pipelineCache = pipelineCache;
@@ -3497,341 +3394,289 @@ VkResult WINAPI vkCreateDataGraphPipelinesARM(VkDevice device, VkDeferredOperati
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    status = UNIX_CALL(vkCreateDataGraphPipelinesARM, ¶ms);
-    assert(!status && "vkCreateDataGraphPipelinesARM");
+    UNIX_CALL_CHECKED(vkCreateDataGraphPipelinesARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
 {
     struct vkCreateDebugReportCallbackEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pCallback = pCallback;
-    status = UNIX_CALL(vkCreateDebugReportCallbackEXT, ¶ms);
-    assert(!status && "vkCreateDebugReportCallbackEXT");
+    UNIX_CALL_CHECKED(vkCreateDebugReportCallbackEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger)
 {
     struct vkCreateDebugUtilsMessengerEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pMessenger = pMessenger;
-    status = UNIX_CALL(vkCreateDebugUtilsMessengerEXT, ¶ms);
-    assert(!status && "vkCreateDebugUtilsMessengerEXT");
+    UNIX_CALL_CHECKED(vkCreateDebugUtilsMessengerEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks *pAllocator, VkDeferredOperationKHR *pDeferredOperation)
 {
     struct vkCreateDeferredOperationKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pAllocator = pAllocator;
     params.pDeferredOperation = pDeferredOperation;
-    status = UNIX_CALL(vkCreateDeferredOperationKHR, ¶ms);
-    assert(!status && "vkCreateDeferredOperationKHR");
+    UNIX_CALL_CHECKED(vkCreateDeferredOperationKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool)
 {
     struct vkCreateDescriptorPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorPool = pDescriptorPool;
-    status = UNIX_CALL(vkCreateDescriptorPool, ¶ms);
-    assert(!status && "vkCreateDescriptorPool");
+    UNIX_CALL_CHECKED(vkCreateDescriptorPool, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorSetLayout *pSetLayout)
 {
     struct vkCreateDescriptorSetLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSetLayout = pSetLayout;
-    status = UNIX_CALL(vkCreateDescriptorSetLayout, ¶ms);
-    assert(!status && "vkCreateDescriptorSetLayout");
+    UNIX_CALL_CHECKED(vkCreateDescriptorSetLayout, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
     struct vkCreateDescriptorUpdateTemplate_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
-    status = UNIX_CALL(vkCreateDescriptorUpdateTemplate, ¶ms);
-    assert(!status && "vkCreateDescriptorUpdateTemplate");
+    UNIX_CALL_CHECKED(vkCreateDescriptorUpdateTemplate, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDescriptorUpdateTemplate *pDescriptorUpdateTemplate)
 {
     struct vkCreateDescriptorUpdateTemplateKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pDescriptorUpdateTemplate = pDescriptorUpdateTemplate;
-    status = UNIX_CALL(vkCreateDescriptorUpdateTemplateKHR, ¶ms);
-    assert(!status && "vkCreateDescriptorUpdateTemplateKHR");
+    UNIX_CALL_CHECKED(vkCreateDescriptorUpdateTemplateKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkEvent *pEvent)
 {
     struct vkCreateEvent_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pEvent = pEvent;
-    status = UNIX_CALL(vkCreateEvent, ¶ms);
-    assert(!status && "vkCreateEvent");
+    UNIX_CALL_CHECKED(vkCreateEvent, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
 {
     struct vkCreateFence_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFence = pFence;
-    status = UNIX_CALL(vkCreateFence, ¶ms);
-    assert(!status && "vkCreateFence");
+    UNIX_CALL_CHECKED(vkCreateFence, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer)
 {
     struct vkCreateFramebuffer_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pFramebuffer = pFramebuffer;
-    status = UNIX_CALL(vkCreateFramebuffer, ¶ms);
-    assert(!status && "vkCreateFramebuffer");
+    UNIX_CALL_CHECKED(vkCreateFramebuffer, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateGpaSessionAMD(VkDevice device, const VkGpaSessionCreateInfoAMD *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkGpaSessionAMD *pGpaSession)
 {
     struct vkCreateGpaSessionAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pGpaSession = pGpaSession;
-    status = UNIX_CALL(vkCreateGpaSessionAMD, ¶ms);
-    assert(!status && "vkCreateGpaSessionAMD");
+    UNIX_CALL_CHECKED(vkCreateGpaSessionAMD, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     struct vkCreateGraphicsPipelines_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineCache = pipelineCache;
     params.createInfoCount = createInfoCount;
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    status = UNIX_CALL(vkCreateGraphicsPipelines, ¶ms);
-    assert(!status && "vkCreateGraphicsPipelines");
+    UNIX_CALL_CHECKED(vkCreateGraphicsPipelines, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage)
 {
     struct vkCreateImage_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pImage = pImage;
-    status = UNIX_CALL(vkCreateImage, ¶ms);
-    assert(!status && "vkCreateImage");
+    UNIX_CALL_CHECKED(vkCreateImage, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView)
 {
     struct vkCreateImageView_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pView = pView;
-    status = UNIX_CALL(vkCreateImageView, ¶ms);
-    assert(!status && "vkCreateImageView");
+    UNIX_CALL_CHECKED(vkCreateImageView, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateIndirectCommandsLayoutEXT(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutEXT *pIndirectCommandsLayout)
 {
     struct vkCreateIndirectCommandsLayoutEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pIndirectCommandsLayout = pIndirectCommandsLayout;
-    status = UNIX_CALL(vkCreateIndirectCommandsLayoutEXT, ¶ms);
-    assert(!status && "vkCreateIndirectCommandsLayoutEXT");
+    UNIX_CALL_CHECKED(vkCreateIndirectCommandsLayoutEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectCommandsLayoutNV *pIndirectCommandsLayout)
 {
     struct vkCreateIndirectCommandsLayoutNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pIndirectCommandsLayout = pIndirectCommandsLayout;
-    status = UNIX_CALL(vkCreateIndirectCommandsLayoutNV, ¶ms);
-    assert(!status && "vkCreateIndirectCommandsLayoutNV");
+    UNIX_CALL_CHECKED(vkCreateIndirectCommandsLayoutNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateIndirectExecutionSetEXT(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkIndirectExecutionSetEXT *pIndirectExecutionSet)
 {
     struct vkCreateIndirectExecutionSetEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pIndirectExecutionSet = pIndirectExecutionSet;
-    status = UNIX_CALL(vkCreateIndirectExecutionSetEXT, ¶ms);
-    assert(!status && "vkCreateIndirectExecutionSetEXT");
+    UNIX_CALL_CHECKED(vkCreateIndirectExecutionSetEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkMicromapEXT *pMicromap)
 {
     struct vkCreateMicromapEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pMicromap = pMicromap;
-    status = UNIX_CALL(vkCreateMicromapEXT, ¶ms);
-    assert(!status && "vkCreateMicromapEXT");
+    UNIX_CALL_CHECKED(vkCreateMicromapEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkOpticalFlowSessionNV *pSession)
 {
     struct vkCreateOpticalFlowSessionNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSession = pSession;
-    status = UNIX_CALL(vkCreateOpticalFlowSessionNV, ¶ms);
-    assert(!status && "vkCreateOpticalFlowSessionNV");
+    UNIX_CALL_CHECKED(vkCreateOpticalFlowSessionNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreatePipelineBinariesKHR(VkDevice device, const VkPipelineBinaryCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineBinaryHandlesInfoKHR *pBinaries)
 {
     struct vkCreatePipelineBinariesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pBinaries = pBinaries;
-    status = UNIX_CALL(vkCreatePipelineBinariesKHR, ¶ms);
-    assert(!status && "vkCreatePipelineBinariesKHR");
+    UNIX_CALL_CHECKED(vkCreatePipelineBinariesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache)
 {
     struct vkCreatePipelineCache_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPipelineCache = pPipelineCache;
-    status = UNIX_CALL(vkCreatePipelineCache, ¶ms);
-    assert(!status && "vkCreatePipelineCache");
+    UNIX_CALL_CHECKED(vkCreatePipelineCache, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout)
 {
     struct vkCreatePipelineLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPipelineLayout = pPipelineLayout;
-    status = UNIX_CALL(vkCreatePipelineLayout, ¶ms);
-    assert(!status && "vkCreatePipelineLayout");
+    UNIX_CALL_CHECKED(vkCreatePipelineLayout, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
 {
     struct vkCreatePrivateDataSlot_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPrivateDataSlot = pPrivateDataSlot;
-    status = UNIX_CALL(vkCreatePrivateDataSlot, ¶ms);
-    assert(!status && "vkCreatePrivateDataSlot");
+    UNIX_CALL_CHECKED(vkCreatePrivateDataSlot, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreatePrivateDataSlotEXT(VkDevice device, const VkPrivateDataSlotCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPrivateDataSlot *pPrivateDataSlot)
 {
     struct vkCreatePrivateDataSlotEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pPrivateDataSlot = pPrivateDataSlot;
-    status = UNIX_CALL(vkCreatePrivateDataSlotEXT, ¶ms);
-    assert(!status && "vkCreatePrivateDataSlotEXT");
+    UNIX_CALL_CHECKED(vkCreatePrivateDataSlotEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool)
 {
     struct vkCreateQueryPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pQueryPool = pQueryPool;
-    status = UNIX_CALL(vkCreateQueryPool, ¶ms);
-    assert(!status && "vkCreateQueryPool");
+    UNIX_CALL_CHECKED(vkCreateQueryPool, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     struct vkCreateRayTracingPipelinesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.deferredOperation = deferredOperation;
     params.pipelineCache = pipelineCache;
@@ -3839,274 +3684,232 @@ VkResult WINAPI vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperat
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    status = UNIX_CALL(vkCreateRayTracingPipelinesKHR, ¶ms);
-    assert(!status && "vkCreateRayTracingPipelinesKHR");
+    UNIX_CALL_CHECKED(vkCreateRayTracingPipelinesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines)
 {
     struct vkCreateRayTracingPipelinesNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineCache = pipelineCache;
     params.createInfoCount = createInfoCount;
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pPipelines = pPipelines;
-    status = UNIX_CALL(vkCreateRayTracingPipelinesNV, ¶ms);
-    assert(!status && "vkCreateRayTracingPipelinesNV");
+    UNIX_CALL_CHECKED(vkCreateRayTracingPipelinesNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     struct vkCreateRenderPass_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    status = UNIX_CALL(vkCreateRenderPass, ¶ms);
-    assert(!status && "vkCreateRenderPass");
+    UNIX_CALL_CHECKED(vkCreateRenderPass, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     struct vkCreateRenderPass2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    status = UNIX_CALL(vkCreateRenderPass2, ¶ms);
-    assert(!status && "vkCreateRenderPass2");
+    UNIX_CALL_CHECKED(vkCreateRenderPass2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2 *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass)
 {
     struct vkCreateRenderPass2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pRenderPass = pRenderPass;
-    status = UNIX_CALL(vkCreateRenderPass2KHR, ¶ms);
-    assert(!status && "vkCreateRenderPass2KHR");
+    UNIX_CALL_CHECKED(vkCreateRenderPass2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSampler *pSampler)
 {
     struct vkCreateSampler_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSampler = pSampler;
-    status = UNIX_CALL(vkCreateSampler, ¶ms);
-    assert(!status && "vkCreateSampler");
+    UNIX_CALL_CHECKED(vkCreateSampler, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     struct vkCreateSamplerYcbcrConversion_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pYcbcrConversion = pYcbcrConversion;
-    status = UNIX_CALL(vkCreateSamplerYcbcrConversion, ¶ms);
-    assert(!status && "vkCreateSamplerYcbcrConversion");
+    UNIX_CALL_CHECKED(vkCreateSamplerYcbcrConversion, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSamplerYcbcrConversion *pYcbcrConversion)
 {
     struct vkCreateSamplerYcbcrConversionKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pYcbcrConversion = pYcbcrConversion;
-    status = UNIX_CALL(vkCreateSamplerYcbcrConversionKHR, ¶ms);
-    assert(!status && "vkCreateSamplerYcbcrConversionKHR");
+    UNIX_CALL_CHECKED(vkCreateSamplerYcbcrConversionKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
 {
     struct vkCreateSemaphore_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSemaphore = pSemaphore;
-    status = UNIX_CALL(vkCreateSemaphore, ¶ms);
-    assert(!status && "vkCreateSemaphore");
+    UNIX_CALL_CHECKED(vkCreateSemaphore, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateShaderInstrumentationARM(VkDevice device, const VkShaderInstrumentationCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderInstrumentationARM *pInstrumentation)
 {
     struct vkCreateShaderInstrumentationARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pInstrumentation = pInstrumentation;
-    status = UNIX_CALL(vkCreateShaderInstrumentationARM, ¶ms);
-    assert(!status && "vkCreateShaderInstrumentationARM");
+    UNIX_CALL_CHECKED(vkCreateShaderInstrumentationARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule)
 {
     struct vkCreateShaderModule_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pShaderModule = pShaderModule;
-    status = UNIX_CALL(vkCreateShaderModule, ¶ms);
-    assert(!status && "vkCreateShaderModule");
+    UNIX_CALL_CHECKED(vkCreateShaderModule, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateShadersEXT(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkShaderEXT *pShaders)
 {
     struct vkCreateShadersEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.createInfoCount = createInfoCount;
     params.pCreateInfos = pCreateInfos;
     params.pAllocator = pAllocator;
     params.pShaders = pShaders;
-    status = UNIX_CALL(vkCreateShadersEXT, ¶ms);
-    assert(!status && "vkCreateShadersEXT");
+    UNIX_CALL_CHECKED(vkCreateShadersEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
 {
     struct vkCreateSwapchainKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSwapchain = pSwapchain;
-    status = UNIX_CALL(vkCreateSwapchainKHR, ¶ms);
-    assert(!status && "vkCreateSwapchainKHR");
+    UNIX_CALL_CHECKED(vkCreateSwapchainKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateTensorARM(VkDevice device, const VkTensorCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorARM *pTensor)
 {
     struct vkCreateTensorARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pTensor = pTensor;
-    status = UNIX_CALL(vkCreateTensorARM, ¶ms);
-    assert(!status && "vkCreateTensorARM");
+    UNIX_CALL_CHECKED(vkCreateTensorARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateTensorViewARM(VkDevice device, const VkTensorViewCreateInfoARM *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkTensorViewARM *pView)
 {
     struct vkCreateTensorViewARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pView = pView;
-    status = UNIX_CALL(vkCreateTensorViewARM, ¶ms);
-    assert(!status && "vkCreateTensorViewARM");
+    UNIX_CALL_CHECKED(vkCreateTensorViewARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkValidationCacheEXT *pValidationCache)
 {
     struct vkCreateValidationCacheEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pValidationCache = pValidationCache;
-    status = UNIX_CALL(vkCreateValidationCacheEXT, ¶ms);
-    assert(!status && "vkCreateValidationCacheEXT");
+    UNIX_CALL_CHECKED(vkCreateValidationCacheEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionKHR *pVideoSession)
 {
     struct vkCreateVideoSessionKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pVideoSession = pVideoSession;
-    status = UNIX_CALL(vkCreateVideoSessionKHR, ¶ms);
-    assert(!status && "vkCreateVideoSessionKHR");
+    UNIX_CALL_CHECKED(vkCreateVideoSessionKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkVideoSessionParametersKHR *pVideoSessionParameters)
 {
     struct vkCreateVideoSessionParametersKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pVideoSessionParameters = pVideoSessionParameters;
-    status = UNIX_CALL(vkCreateVideoSessionParametersKHR, ¶ms);
-    assert(!status && "vkCreateVideoSessionParametersKHR");
+    UNIX_CALL_CHECKED(vkCreateVideoSessionParametersKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
 {
     struct vkCreateWin32SurfaceKHR_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pCreateInfo = pCreateInfo;
     params.pAllocator = pAllocator;
     params.pSurface = pSurface;
-    status = UNIX_CALL(vkCreateWin32SurfaceKHR, ¶ms);
-    assert(!status && "vkCreateWin32SurfaceKHR");
+    UNIX_CALL_CHECKED(vkCreateWin32SurfaceKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT *pNameInfo)
 {
     struct vkDebugMarkerSetObjectNameEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pNameInfo = pNameInfo;
-    status = UNIX_CALL(vkDebugMarkerSetObjectNameEXT, ¶ms);
-    assert(!status && "vkDebugMarkerSetObjectNameEXT");
+    UNIX_CALL_CHECKED(vkDebugMarkerSetObjectNameEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT *pTagInfo)
 {
     struct vkDebugMarkerSetObjectTagEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pTagInfo = pTagInfo;
-    status = UNIX_CALL(vkDebugMarkerSetObjectTagEXT, ¶ms);
-    assert(!status && "vkDebugMarkerSetObjectTagEXT");
+    UNIX_CALL_CHECKED(vkDebugMarkerSetObjectTagEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char *pLayerPrefix, const char *pMessage)
 {
     struct vkDebugReportMessageEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.flags = flags;
     params.objectType = objectType;
@@ -4115,950 +3918,783 @@ void WINAPI vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT f
     params.messageCode = messageCode;
     params.pLayerPrefix = pLayerPrefix;
     params.pMessage = pMessage;
-    status = UNIX_CALL(vkDebugReportMessageEXT, ¶ms);
-    assert(!status && "vkDebugReportMessageEXT");
+    UNIX_CALL_CHECKED(vkDebugReportMessageEXT, ¶ms);
 }
 
 VkResult WINAPI vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     struct vkDeferredOperationJoinKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.operation = operation;
-    status = UNIX_CALL(vkDeferredOperationJoinKHR, ¶ms);
-    assert(!status && "vkDeferredOperationJoinKHR");
+    UNIX_CALL_CHECKED(vkDeferredOperationJoinKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyAccelerationStructureKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.accelerationStructure = accelerationStructure;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyAccelerationStructureKHR, ¶ms);
-    assert(!status && "vkDestroyAccelerationStructureKHR");
+    UNIX_CALL_CHECKED(vkDestroyAccelerationStructureKHR, ¶ms);
 }
 
 void WINAPI vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyAccelerationStructureNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.accelerationStructure = accelerationStructure;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyAccelerationStructureNV, ¶ms);
-    assert(!status && "vkDestroyAccelerationStructureNV");
+    UNIX_CALL_CHECKED(vkDestroyAccelerationStructureNV, ¶ms);
 }
 
 void WINAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyBuffer_params params;
-    NTSTATUS status;
     params.device = device;
     params.buffer = buffer;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyBuffer, ¶ms);
-    assert(!status && "vkDestroyBuffer");
+    UNIX_CALL_CHECKED(vkDestroyBuffer, ¶ms);
 }
 
 void WINAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyBufferView_params params;
-    NTSTATUS status;
     params.device = device;
     params.bufferView = bufferView;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyBufferView, ¶ms);
-    assert(!status && "vkDestroyBufferView");
+    UNIX_CALL_CHECKED(vkDestroyBufferView, ¶ms);
 }
 
 void WINAPI vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyCuFunctionNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.function = function;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyCuFunctionNVX, ¶ms);
-    assert(!status && "vkDestroyCuFunctionNVX");
+    UNIX_CALL_CHECKED(vkDestroyCuFunctionNVX, ¶ms);
 }
 
 void WINAPI vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyCuModuleNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.module = module;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyCuModuleNVX, ¶ms);
-    assert(!status && "vkDestroyCuModuleNVX");
+    UNIX_CALL_CHECKED(vkDestroyCuModuleNVX, ¶ms);
 }
 
 void WINAPI vkDestroyDataGraphPipelineSessionARM(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDataGraphPipelineSessionARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.session = session;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDataGraphPipelineSessionARM, ¶ms);
-    assert(!status && "vkDestroyDataGraphPipelineSessionARM");
+    UNIX_CALL_CHECKED(vkDestroyDataGraphPipelineSessionARM, ¶ms);
 }
 
 void WINAPI vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDebugReportCallbackEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.callback = callback;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDebugReportCallbackEXT, ¶ms);
-    assert(!status && "vkDestroyDebugReportCallbackEXT");
+    UNIX_CALL_CHECKED(vkDestroyDebugReportCallbackEXT, ¶ms);
 }
 
 void WINAPI vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDebugUtilsMessengerEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.messenger = messenger;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDebugUtilsMessengerEXT, ¶ms);
-    assert(!status && "vkDestroyDebugUtilsMessengerEXT");
+    UNIX_CALL_CHECKED(vkDestroyDebugUtilsMessengerEXT, ¶ms);
 }
 
 void WINAPI vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDeferredOperationKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.operation = operation;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDeferredOperationKHR, ¶ms);
-    assert(!status && "vkDestroyDeferredOperationKHR");
+    UNIX_CALL_CHECKED(vkDestroyDeferredOperationKHR, ¶ms);
 }
 
 void WINAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDescriptorPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorPool = descriptorPool;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDescriptorPool, ¶ms);
-    assert(!status && "vkDestroyDescriptorPool");
+    UNIX_CALL_CHECKED(vkDestroyDescriptorPool, ¶ms);
 }
 
 void WINAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDescriptorSetLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorSetLayout = descriptorSetLayout;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDescriptorSetLayout, ¶ms);
-    assert(!status && "vkDestroyDescriptorSetLayout");
+    UNIX_CALL_CHECKED(vkDestroyDescriptorSetLayout, ¶ms);
 }
 
 void WINAPI vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDescriptorUpdateTemplate_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDescriptorUpdateTemplate, ¶ms);
-    assert(!status && "vkDestroyDescriptorUpdateTemplate");
+    UNIX_CALL_CHECKED(vkDestroyDescriptorUpdateTemplate, ¶ms);
 }
 
 void WINAPI vkDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyDescriptorUpdateTemplateKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyDescriptorUpdateTemplateKHR, ¶ms);
-    assert(!status && "vkDestroyDescriptorUpdateTemplateKHR");
+    UNIX_CALL_CHECKED(vkDestroyDescriptorUpdateTemplateKHR, ¶ms);
 }
 
 void WINAPI vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyEvent_params params;
-    NTSTATUS status;
     params.device = device;
     params.event = event;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyEvent, ¶ms);
-    assert(!status && "vkDestroyEvent");
+    UNIX_CALL_CHECKED(vkDestroyEvent, ¶ms);
 }
 
 void WINAPI vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyFence_params params;
-    NTSTATUS status;
     params.device = device;
     params.fence = fence;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyFence, ¶ms);
-    assert(!status && "vkDestroyFence");
+    UNIX_CALL_CHECKED(vkDestroyFence, ¶ms);
 }
 
 void WINAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyFramebuffer_params params;
-    NTSTATUS status;
     params.device = device;
     params.framebuffer = framebuffer;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyFramebuffer, ¶ms);
-    assert(!status && "vkDestroyFramebuffer");
+    UNIX_CALL_CHECKED(vkDestroyFramebuffer, ¶ms);
 }
 
 void WINAPI vkDestroyGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyGpaSessionAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.gpaSession = gpaSession;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyGpaSessionAMD, ¶ms);
-    assert(!status && "vkDestroyGpaSessionAMD");
+    UNIX_CALL_CHECKED(vkDestroyGpaSessionAMD, ¶ms);
 }
 
 void WINAPI vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyImage_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyImage, ¶ms);
-    assert(!status && "vkDestroyImage");
+    UNIX_CALL_CHECKED(vkDestroyImage, ¶ms);
 }
 
 void WINAPI vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyImageView_params params;
-    NTSTATUS status;
     params.device = device;
     params.imageView = imageView;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyImageView, ¶ms);
-    assert(!status && "vkDestroyImageView");
+    UNIX_CALL_CHECKED(vkDestroyImageView, ¶ms);
 }
 
 void WINAPI vkDestroyIndirectCommandsLayoutEXT(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyIndirectCommandsLayoutEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.indirectCommandsLayout = indirectCommandsLayout;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyIndirectCommandsLayoutEXT, ¶ms);
-    assert(!status && "vkDestroyIndirectCommandsLayoutEXT");
+    UNIX_CALL_CHECKED(vkDestroyIndirectCommandsLayoutEXT, ¶ms);
 }
 
 void WINAPI vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyIndirectCommandsLayoutNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.indirectCommandsLayout = indirectCommandsLayout;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyIndirectCommandsLayoutNV, ¶ms);
-    assert(!status && "vkDestroyIndirectCommandsLayoutNV");
+    UNIX_CALL_CHECKED(vkDestroyIndirectCommandsLayoutNV, ¶ms);
 }
 
 void WINAPI vkDestroyIndirectExecutionSetEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyIndirectExecutionSetEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.indirectExecutionSet = indirectExecutionSet;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyIndirectExecutionSetEXT, ¶ms);
-    assert(!status && "vkDestroyIndirectExecutionSetEXT");
+    UNIX_CALL_CHECKED(vkDestroyIndirectExecutionSetEXT, ¶ms);
 }
 
 void WINAPI vkDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyMicromapEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.micromap = micromap;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyMicromapEXT, ¶ms);
-    assert(!status && "vkDestroyMicromapEXT");
+    UNIX_CALL_CHECKED(vkDestroyMicromapEXT, ¶ms);
 }
 
 void WINAPI vkDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyOpticalFlowSessionNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.session = session;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyOpticalFlowSessionNV, ¶ms);
-    assert(!status && "vkDestroyOpticalFlowSessionNV");
+    UNIX_CALL_CHECKED(vkDestroyOpticalFlowSessionNV, ¶ms);
 }
 
 void WINAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPipeline_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPipeline, ¶ms);
-    assert(!status && "vkDestroyPipeline");
+    UNIX_CALL_CHECKED(vkDestroyPipeline, ¶ms);
 }
 
 void WINAPI vkDestroyPipelineBinaryKHR(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPipelineBinaryKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineBinary = pipelineBinary;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPipelineBinaryKHR, ¶ms);
-    assert(!status && "vkDestroyPipelineBinaryKHR");
+    UNIX_CALL_CHECKED(vkDestroyPipelineBinaryKHR, ¶ms);
 }
 
 void WINAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPipelineCache_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineCache = pipelineCache;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPipelineCache, ¶ms);
-    assert(!status && "vkDestroyPipelineCache");
+    UNIX_CALL_CHECKED(vkDestroyPipelineCache, ¶ms);
 }
 
 void WINAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPipelineLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineLayout = pipelineLayout;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPipelineLayout, ¶ms);
-    assert(!status && "vkDestroyPipelineLayout");
+    UNIX_CALL_CHECKED(vkDestroyPipelineLayout, ¶ms);
 }
 
 void WINAPI vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPrivateDataSlot_params params;
-    NTSTATUS status;
     params.device = device;
     params.privateDataSlot = privateDataSlot;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPrivateDataSlot, ¶ms);
-    assert(!status && "vkDestroyPrivateDataSlot");
+    UNIX_CALL_CHECKED(vkDestroyPrivateDataSlot, ¶ms);
 }
 
 void WINAPI vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyPrivateDataSlotEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.privateDataSlot = privateDataSlot;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyPrivateDataSlotEXT, ¶ms);
-    assert(!status && "vkDestroyPrivateDataSlotEXT");
+    UNIX_CALL_CHECKED(vkDestroyPrivateDataSlotEXT, ¶ms);
 }
 
 void WINAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyQueryPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.queryPool = queryPool;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyQueryPool, ¶ms);
-    assert(!status && "vkDestroyQueryPool");
+    UNIX_CALL_CHECKED(vkDestroyQueryPool, ¶ms);
 }
 
 void WINAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyRenderPass_params params;
-    NTSTATUS status;
     params.device = device;
     params.renderPass = renderPass;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyRenderPass, ¶ms);
-    assert(!status && "vkDestroyRenderPass");
+    UNIX_CALL_CHECKED(vkDestroyRenderPass, ¶ms);
 }
 
 void WINAPI vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySampler_params params;
-    NTSTATUS status;
     params.device = device;
     params.sampler = sampler;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySampler, ¶ms);
-    assert(!status && "vkDestroySampler");
+    UNIX_CALL_CHECKED(vkDestroySampler, ¶ms);
 }
 
 void WINAPI vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySamplerYcbcrConversion_params params;
-    NTSTATUS status;
     params.device = device;
     params.ycbcrConversion = ycbcrConversion;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySamplerYcbcrConversion, ¶ms);
-    assert(!status && "vkDestroySamplerYcbcrConversion");
+    UNIX_CALL_CHECKED(vkDestroySamplerYcbcrConversion, ¶ms);
 }
 
 void WINAPI vkDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySamplerYcbcrConversionKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.ycbcrConversion = ycbcrConversion;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySamplerYcbcrConversionKHR, ¶ms);
-    assert(!status && "vkDestroySamplerYcbcrConversionKHR");
+    UNIX_CALL_CHECKED(vkDestroySamplerYcbcrConversionKHR, ¶ms);
 }
 
 void WINAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySemaphore_params params;
-    NTSTATUS status;
     params.device = device;
     params.semaphore = semaphore;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySemaphore, ¶ms);
-    assert(!status && "vkDestroySemaphore");
+    UNIX_CALL_CHECKED(vkDestroySemaphore, ¶ms);
 }
 
 void WINAPI vkDestroyShaderEXT(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyShaderEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.shader = shader;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyShaderEXT, ¶ms);
-    assert(!status && "vkDestroyShaderEXT");
+    UNIX_CALL_CHECKED(vkDestroyShaderEXT, ¶ms);
 }
 
 void WINAPI vkDestroyShaderInstrumentationARM(VkDevice device, VkShaderInstrumentationARM instrumentation, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyShaderInstrumentationARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.instrumentation = instrumentation;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyShaderInstrumentationARM, ¶ms);
-    assert(!status && "vkDestroyShaderInstrumentationARM");
+    UNIX_CALL_CHECKED(vkDestroyShaderInstrumentationARM, ¶ms);
 }
 
 void WINAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyShaderModule_params params;
-    NTSTATUS status;
     params.device = device;
     params.shaderModule = shaderModule;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyShaderModule, ¶ms);
-    assert(!status && "vkDestroyShaderModule");
+    UNIX_CALL_CHECKED(vkDestroyShaderModule, ¶ms);
 }
 
 void WINAPI vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySurfaceKHR_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.surface = surface;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySurfaceKHR, ¶ms);
-    assert(!status && "vkDestroySurfaceKHR");
+    UNIX_CALL_CHECKED(vkDestroySurfaceKHR, ¶ms);
 }
 
 void WINAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroySwapchainKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroySwapchainKHR, ¶ms);
-    assert(!status && "vkDestroySwapchainKHR");
+    UNIX_CALL_CHECKED(vkDestroySwapchainKHR, ¶ms);
 }
 
 void WINAPI vkDestroyTensorARM(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyTensorARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.tensor = tensor;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyTensorARM, ¶ms);
-    assert(!status && "vkDestroyTensorARM");
+    UNIX_CALL_CHECKED(vkDestroyTensorARM, ¶ms);
 }
 
 void WINAPI vkDestroyTensorViewARM(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyTensorViewARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.tensorView = tensorView;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyTensorViewARM, ¶ms);
-    assert(!status && "vkDestroyTensorViewARM");
+    UNIX_CALL_CHECKED(vkDestroyTensorViewARM, ¶ms);
 }
 
 void WINAPI vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyValidationCacheEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.validationCache = validationCache;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyValidationCacheEXT, ¶ms);
-    assert(!status && "vkDestroyValidationCacheEXT");
+    UNIX_CALL_CHECKED(vkDestroyValidationCacheEXT, ¶ms);
 }
 
 void WINAPI vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyVideoSessionKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.videoSession = videoSession;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyVideoSessionKHR, ¶ms);
-    assert(!status && "vkDestroyVideoSessionKHR");
+    UNIX_CALL_CHECKED(vkDestroyVideoSessionKHR, ¶ms);
 }
 
 void WINAPI vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks *pAllocator)
 {
     struct vkDestroyVideoSessionParametersKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.videoSessionParameters = videoSessionParameters;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkDestroyVideoSessionParametersKHR, ¶ms);
-    assert(!status && "vkDestroyVideoSessionParametersKHR");
+    UNIX_CALL_CHECKED(vkDestroyVideoSessionParametersKHR, ¶ms);
 }
 
 VkResult WINAPI vkDeviceWaitIdle(VkDevice device)
 {
     struct vkDeviceWaitIdle_params params;
-    NTSTATUS status;
     params.device = device;
-    status = UNIX_CALL(vkDeviceWaitIdle, ¶ms);
-    assert(!status && "vkDeviceWaitIdle");
+    UNIX_CALL_CHECKED(vkDeviceWaitIdle, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEndCommandBuffer(VkCommandBuffer commandBuffer)
 {
     struct vkEndCommandBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
-    status = UNIX_CALL(vkEndCommandBuffer, ¶ms);
-    assert(!status && "vkEndCommandBuffer");
+    UNIX_CALL_CHECKED(vkEndCommandBuffer, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
 {
     struct vkEnumerateDeviceLayerProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkEnumerateDeviceLayerProperties, ¶ms);
-    assert(!status && "vkEnumerateDeviceLayerProperties");
+    UNIX_CALL_CHECKED(vkEnumerateDeviceLayerProperties, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
 {
     struct vkEnumeratePhysicalDeviceGroups_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
-    status = UNIX_CALL(vkEnumeratePhysicalDeviceGroups, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDeviceGroups");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceGroups, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties)
 {
     struct vkEnumeratePhysicalDeviceGroupsKHR_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount;
     params.pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties;
-    status = UNIX_CALL(vkEnumeratePhysicalDeviceGroupsKHR, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDeviceGroupsKHR");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceGroupsKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterARM *pCounters, VkPerformanceCounterDescriptionARM *pCounterDescriptions)
 {
     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.pCounterCount = pCounterCount;
     params.pCounters = pCounters;
     params.pCounterDescriptions = pCounterDescriptions;
-    status = UNIX_CALL(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pCounterCount, VkPerformanceCounterKHR *pCounters, VkPerformanceCounterDescriptionKHR *pCounterDescriptions)
 {
     struct vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.pCounterCount = pCounterCount;
     params.pCounters = pCounters;
     params.pCounterDescriptions = pCounterDescriptions;
-    status = UNIX_CALL(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM(VkPhysicalDevice physicalDevice, uint32_t *pDescriptionCount, VkShaderInstrumentationMetricDescriptionARM *pDescriptions)
 {
     struct vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pDescriptionCount = pDescriptionCount;
     params.pDescriptions = pDescriptions;
-    status = UNIX_CALL(vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
 {
     struct vkEnumeratePhysicalDevices_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.pPhysicalDeviceCount = pPhysicalDeviceCount;
     params.pPhysicalDevices = pPhysicalDevices;
-    status = UNIX_CALL(vkEnumeratePhysicalDevices, ¶ms);
-    assert(!status && "vkEnumeratePhysicalDevices");
+    UNIX_CALL_CHECKED(vkEnumeratePhysicalDevices, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
     struct vkFlushMappedMemoryRanges_params params;
-    NTSTATUS status;
     params.device = device;
     params.memoryRangeCount = memoryRangeCount;
     params.pMemoryRanges = pMemoryRanges;
-    status = UNIX_CALL(vkFlushMappedMemoryRanges, ¶ms);
-    assert(!status && "vkFlushMappedMemoryRanges");
+    UNIX_CALL_CHECKED(vkFlushMappedMemoryRanges, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets)
 {
     struct vkFreeDescriptorSets_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorPool = descriptorPool;
     params.descriptorSetCount = descriptorSetCount;
     params.pDescriptorSets = pDescriptorSets;
-    status = UNIX_CALL(vkFreeDescriptorSets, ¶ms);
-    assert(!status && "vkFreeDescriptorSets");
+    UNIX_CALL_CHECKED(vkFreeDescriptorSets, ¶ms);
     return params.result;
 }
 
 void WINAPI vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator)
 {
     struct vkFreeMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.memory = memory;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkFreeMemory, ¶ms);
-    assert(!status && "vkFreeMemory");
+    UNIX_CALL_CHECKED(vkFreeMemory, ¶ms);
 }
 
 void WINAPI vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR *pBuildInfo, const uint32_t *pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
 {
     struct vkGetAccelerationStructureBuildSizesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.buildType = buildType;
     params.pBuildInfo = pBuildInfo;
     params.pMaxPrimitiveCounts = pMaxPrimitiveCounts;
     params.pSizeInfo = pSizeInfo;
-    status = UNIX_CALL(vkGetAccelerationStructureBuildSizesKHR, ¶ms);
-    assert(!status && "vkGetAccelerationStructureBuildSizesKHR");
+    UNIX_CALL_CHECKED(vkGetAccelerationStructureBuildSizesKHR, ¶ms);
 }
 
 VkDeviceAddress WINAPI vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR *pInfo)
 {
     struct vkGetAccelerationStructureDeviceAddressKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetAccelerationStructureDeviceAddressKHR, ¶ms);
-    assert(!status && "vkGetAccelerationStructureDeviceAddressKHR");
+    UNIX_CALL_CHECKED(vkGetAccelerationStructureDeviceAddressKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void *pData)
 {
     struct vkGetAccelerationStructureHandleNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.accelerationStructure = accelerationStructure;
     params.dataSize = dataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetAccelerationStructureHandleNV, ¶ms);
-    assert(!status && "vkGetAccelerationStructureHandleNV");
+    UNIX_CALL_CHECKED(vkGetAccelerationStructureHandleNV, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetAccelerationStructureMemoryRequirementsNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetAccelerationStructureMemoryRequirementsNV, ¶ms);
-    assert(!status && "vkGetAccelerationStructureMemoryRequirementsNV");
+    UNIX_CALL_CHECKED(vkGetAccelerationStructureMemoryRequirementsNV, ¶ms);
 }
 
 VkResult WINAPI vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT *pInfo, void *pData)
 {
     struct vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, ¶ms);
-    assert(!status && "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT");
+    UNIX_CALL_CHECKED(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, ¶ms);
     return params.result;
 }
 
 VkDeviceAddress WINAPI vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     struct vkGetBufferDeviceAddress_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetBufferDeviceAddress, ¶ms);
-    assert(!status && "vkGetBufferDeviceAddress");
+    UNIX_CALL_CHECKED(vkGetBufferDeviceAddress, ¶ms);
     return params.result;
 }
 
 VkDeviceAddress WINAPI vkGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     struct vkGetBufferDeviceAddressEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetBufferDeviceAddressEXT, ¶ms);
-    assert(!status && "vkGetBufferDeviceAddressEXT");
+    UNIX_CALL_CHECKED(vkGetBufferDeviceAddressEXT, ¶ms);
     return params.result;
 }
 
 VkDeviceAddress WINAPI vkGetBufferDeviceAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     struct vkGetBufferDeviceAddressKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetBufferDeviceAddressKHR, ¶ms);
-    assert(!status && "vkGetBufferDeviceAddressKHR");
+    UNIX_CALL_CHECKED(vkGetBufferDeviceAddressKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements)
 {
     struct vkGetBufferMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.buffer = buffer;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetBufferMemoryRequirements, ¶ms);
-    assert(!status && "vkGetBufferMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetBufferMemoryRequirements2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetBufferMemoryRequirements2, ¶ms);
-    assert(!status && "vkGetBufferMemoryRequirements2");
+    UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements2, ¶ms);
 }
 
 void WINAPI vkGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetBufferMemoryRequirements2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetBufferMemoryRequirements2KHR, ¶ms);
-    assert(!status && "vkGetBufferMemoryRequirements2KHR");
+    UNIX_CALL_CHECKED(vkGetBufferMemoryRequirements2KHR, ¶ms);
 }
 
 uint64_t WINAPI vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     struct vkGetBufferOpaqueCaptureAddress_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetBufferOpaqueCaptureAddress, ¶ms);
-    assert(!status && "vkGetBufferOpaqueCaptureAddress");
+    UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureAddress, ¶ms);
     return params.result;
 }
 
 uint64_t WINAPI vkGetBufferOpaqueCaptureAddressKHR(VkDevice device, const VkBufferDeviceAddressInfo *pInfo)
 {
     struct vkGetBufferOpaqueCaptureAddressKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetBufferOpaqueCaptureAddressKHR, ¶ms);
-    assert(!status && "vkGetBufferOpaqueCaptureAddressKHR");
+    UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureAddressKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetBufferOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT *pInfo, void *pData)
 {
     struct vkGetBufferOpaqueCaptureDescriptorDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetBufferOpaqueCaptureDescriptorDataEXT, ¶ms);
-    assert(!status && "vkGetBufferOpaqueCaptureDescriptorDataEXT");
+    UNIX_CALL_CHECKED(vkGetBufferOpaqueCaptureDescriptorDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
 {
     struct vkGetCalibratedTimestampsEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.timestampCount = timestampCount;
     params.pTimestampInfos = pTimestampInfos;
     params.pTimestamps = pTimestamps;
     params.pMaxDeviation = pMaxDeviation;
-    status = UNIX_CALL(vkGetCalibratedTimestampsEXT, ¶ms);
-    assert(!status && "vkGetCalibratedTimestampsEXT");
+    UNIX_CALL_CHECKED(vkGetCalibratedTimestampsEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetCalibratedTimestampsKHR(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation)
 {
     struct vkGetCalibratedTimestampsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.timestampCount = timestampCount;
     params.pTimestampInfos = pTimestampInfos;
     params.pTimestamps = pTimestamps;
     params.pMaxDeviation = pMaxDeviation;
-    status = UNIX_CALL(vkGetCalibratedTimestampsKHR, ¶ms);
-    assert(!status && "vkGetCalibratedTimestampsKHR");
+    UNIX_CALL_CHECKED(vkGetCalibratedTimestampsKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetClusterAccelerationStructureBuildSizesNV(VkDevice device, const VkClusterAccelerationStructureInputInfoNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
 {
     struct vkGetClusterAccelerationStructureBuildSizesNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSizeInfo = pSizeInfo;
-    status = UNIX_CALL(vkGetClusterAccelerationStructureBuildSizesNV, ¶ms);
-    assert(!status && "vkGetClusterAccelerationStructureBuildSizesNV");
+    UNIX_CALL_CHECKED(vkGetClusterAccelerationStructureBuildSizesNV, ¶ms);
 }
 
 VkResult WINAPI vkGetDataGraphPipelineAvailablePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t *pPropertiesCount, VkDataGraphPipelinePropertyARM *pProperties)
 {
     struct vkGetDataGraphPipelineAvailablePropertiesARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPipelineInfo = pPipelineInfo;
     params.pPropertiesCount = pPropertiesCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetDataGraphPipelineAvailablePropertiesARM, ¶ms);
-    assert(!status && "vkGetDataGraphPipelineAvailablePropertiesARM");
+    UNIX_CALL_CHECKED(vkGetDataGraphPipelineAvailablePropertiesARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDataGraphPipelinePropertiesARM(VkDevice device, const VkDataGraphPipelineInfoARM *pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM *pProperties)
 {
     struct vkGetDataGraphPipelinePropertiesARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPipelineInfo = pPipelineInfo;
     params.propertiesCount = propertiesCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetDataGraphPipelinePropertiesARM, ¶ms);
-    assert(!status && "vkGetDataGraphPipelinePropertiesARM");
+    UNIX_CALL_CHECKED(vkGetDataGraphPipelinePropertiesARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDataGraphPipelineSessionBindPointRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM *pInfo, uint32_t *pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM *pBindPointRequirements)
 {
     struct vkGetDataGraphPipelineSessionBindPointRequirementsARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pBindPointRequirementCount = pBindPointRequirementCount;
     params.pBindPointRequirements = pBindPointRequirements;
-    status = UNIX_CALL(vkGetDataGraphPipelineSessionBindPointRequirementsARM, ¶ms);
-    assert(!status && "vkGetDataGraphPipelineSessionBindPointRequirementsARM");
+    UNIX_CALL_CHECKED(vkGetDataGraphPipelineSessionBindPointRequirementsARM, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetDataGraphPipelineSessionMemoryRequirementsARM(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDataGraphPipelineSessionMemoryRequirementsARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDataGraphPipelineSessionMemoryRequirementsARM, ¶ms);
-    assert(!status && "vkGetDataGraphPipelineSessionMemoryRequirementsARM");
+    UNIX_CALL_CHECKED(vkGetDataGraphPipelineSessionMemoryRequirementsARM, ¶ms);
 }
 
 uint32_t WINAPI vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     struct vkGetDeferredOperationMaxConcurrencyKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.operation = operation;
-    status = UNIX_CALL(vkGetDeferredOperationMaxConcurrencyKHR, ¶ms);
-    assert(!status && "vkGetDeferredOperationMaxConcurrencyKHR");
+    UNIX_CALL_CHECKED(vkGetDeferredOperationMaxConcurrencyKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
 {
     struct vkGetDeferredOperationResultKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.operation = operation;
-    status = UNIX_CALL(vkGetDeferredOperationResultKHR, ¶ms);
-    assert(!status && "vkGetDeferredOperationResultKHR");
+    UNIX_CALL_CHECKED(vkGetDeferredOperationResultKHR, ¶ms);
     return params.result;
 }
 
@@ -5075,1012 +4711,837 @@ void WINAPI vkGetDescriptorEXT(VkDevice device, const VkDescriptorGetInfoEXT *pD
 void WINAPI vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void **ppData)
 {
     struct vkGetDescriptorSetHostMappingVALVE_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorSet = descriptorSet;
     params.ppData = ppData;
-    status = UNIX_CALL(vkGetDescriptorSetHostMappingVALVE, ¶ms);
-    assert(!status && "vkGetDescriptorSetHostMappingVALVE");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetHostMappingVALVE, ¶ms);
 }
 
 void WINAPI vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize *pOffset)
 {
     struct vkGetDescriptorSetLayoutBindingOffsetEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.layout = layout;
     params.binding = binding;
     params.pOffset = pOffset;
-    status = UNIX_CALL(vkGetDescriptorSetLayoutBindingOffsetEXT, ¶ms);
-    assert(!status && "vkGetDescriptorSetLayoutBindingOffsetEXT");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutBindingOffsetEXT, ¶ms);
 }
 
 void WINAPI vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE *pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE *pHostMapping)
 {
     struct vkGetDescriptorSetLayoutHostMappingInfoVALVE_params params;
-    NTSTATUS status;
     params.device = device;
     params.pBindingReference = pBindingReference;
     params.pHostMapping = pHostMapping;
-    status = UNIX_CALL(vkGetDescriptorSetLayoutHostMappingInfoVALVE, ¶ms);
-    assert(!status && "vkGetDescriptorSetLayoutHostMappingInfoVALVE");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutHostMappingInfoVALVE, ¶ms);
 }
 
 void WINAPI vkGetDescriptorSetLayoutSizeEXT(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize *pLayoutSizeInBytes)
 {
     struct vkGetDescriptorSetLayoutSizeEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.layout = layout;
     params.pLayoutSizeInBytes = pLayoutSizeInBytes;
-    status = UNIX_CALL(vkGetDescriptorSetLayoutSizeEXT, ¶ms);
-    assert(!status && "vkGetDescriptorSetLayoutSizeEXT");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSizeEXT, ¶ms);
 }
 
 void WINAPI vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     struct vkGetDescriptorSetLayoutSupport_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pSupport = pSupport;
-    status = UNIX_CALL(vkGetDescriptorSetLayoutSupport, ¶ms);
-    assert(!status && "vkGetDescriptorSetLayoutSupport");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSupport, ¶ms);
 }
 
 void WINAPI vkGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo, VkDescriptorSetLayoutSupport *pSupport)
 {
     struct vkGetDescriptorSetLayoutSupportKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pSupport = pSupport;
-    status = UNIX_CALL(vkGetDescriptorSetLayoutSupportKHR, ¶ms);
-    assert(!status && "vkGetDescriptorSetLayoutSupportKHR");
+    UNIX_CALL_CHECKED(vkGetDescriptorSetLayoutSupportKHR, ¶ms);
 }
 
 void WINAPI vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
 {
     struct vkGetDeviceAccelerationStructureCompatibilityKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pVersionInfo = pVersionInfo;
     params.pCompatibility = pCompatibility;
-    status = UNIX_CALL(vkGetDeviceAccelerationStructureCompatibilityKHR, ¶ms);
-    assert(!status && "vkGetDeviceAccelerationStructureCompatibilityKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceAccelerationStructureCompatibilityKHR, ¶ms);
 }
 
 void WINAPI vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDeviceBufferMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceBufferMemoryRequirements, ¶ms);
-    assert(!status && "vkGetDeviceBufferMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetDeviceBufferMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetDeviceBufferMemoryRequirementsKHR(VkDevice device, const VkDeviceBufferMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDeviceBufferMemoryRequirementsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceBufferMemoryRequirementsKHR, ¶ms);
-    assert(!status && "vkGetDeviceBufferMemoryRequirementsKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceBufferMemoryRequirementsKHR, ¶ms);
 }
 
 uint64_t WINAPI vkGetDeviceCombinedImageSamplerIndexNVX(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex)
 {
     struct vkGetDeviceCombinedImageSamplerIndexNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.imageViewIndex = imageViewIndex;
     params.samplerIndex = samplerIndex;
-    status = UNIX_CALL(vkGetDeviceCombinedImageSamplerIndexNVX, ¶ms);
-    assert(!status && "vkGetDeviceCombinedImageSamplerIndexNVX");
+    UNIX_CALL_CHECKED(vkGetDeviceCombinedImageSamplerIndexNVX, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDeviceFaultDebugInfoKHR(VkDevice device, VkDeviceFaultDebugInfoKHR *pDebugInfo)
 {
     struct vkGetDeviceFaultDebugInfoKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pDebugInfo = pDebugInfo;
-    status = UNIX_CALL(vkGetDeviceFaultDebugInfoKHR, ¶ms);
-    assert(!status && "vkGetDeviceFaultDebugInfoKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceFaultDebugInfoKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT *pFaultCounts, VkDeviceFaultInfoEXT *pFaultInfo)
 {
     struct vkGetDeviceFaultInfoEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pFaultCounts = pFaultCounts;
     params.pFaultInfo = pFaultInfo;
-    status = UNIX_CALL(vkGetDeviceFaultInfoEXT, ¶ms);
-    assert(!status && "vkGetDeviceFaultInfoEXT");
+    UNIX_CALL_CHECKED(vkGetDeviceFaultInfoEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDeviceFaultReportsKHR(VkDevice device, uint64_t timeout, uint32_t *pFaultCounts, VkDeviceFaultInfoKHR *pFaultInfo)
 {
     struct vkGetDeviceFaultReportsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.timeout = timeout;
     params.pFaultCounts = pFaultCounts;
     params.pFaultInfo = pFaultInfo;
-    status = UNIX_CALL(vkGetDeviceFaultReportsKHR, ¶ms);
-    assert(!status && "vkGetDeviceFaultReportsKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceFaultReportsKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     struct vkGetDeviceGroupPeerMemoryFeatures_params params;
-    NTSTATUS status;
     params.device = device;
     params.heapIndex = heapIndex;
     params.localDeviceIndex = localDeviceIndex;
     params.remoteDeviceIndex = remoteDeviceIndex;
     params.pPeerMemoryFeatures = pPeerMemoryFeatures;
-    status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeatures, ¶ms);
-    assert(!status && "vkGetDeviceGroupPeerMemoryFeatures");
+    UNIX_CALL_CHECKED(vkGetDeviceGroupPeerMemoryFeatures, ¶ms);
 }
 
 void WINAPI vkGetDeviceGroupPeerMemoryFeaturesKHR(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags *pPeerMemoryFeatures)
 {
     struct vkGetDeviceGroupPeerMemoryFeaturesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.heapIndex = heapIndex;
     params.localDeviceIndex = localDeviceIndex;
     params.remoteDeviceIndex = remoteDeviceIndex;
     params.pPeerMemoryFeatures = pPeerMemoryFeatures;
-    status = UNIX_CALL(vkGetDeviceGroupPeerMemoryFeaturesKHR, ¶ms);
-    assert(!status && "vkGetDeviceGroupPeerMemoryFeaturesKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceGroupPeerMemoryFeaturesKHR, ¶ms);
 }
 
 VkResult WINAPI vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities)
 {
     struct vkGetDeviceGroupPresentCapabilitiesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities;
-    status = UNIX_CALL(vkGetDeviceGroupPresentCapabilitiesKHR, ¶ms);
-    assert(!status && "vkGetDeviceGroupPresentCapabilitiesKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceGroupPresentCapabilitiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR *pModes)
 {
     struct vkGetDeviceGroupSurfacePresentModesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.surface = surface;
     params.pModes = pModes;
-    status = UNIX_CALL(vkGetDeviceGroupSurfacePresentModesKHR, ¶ms);
-    assert(!status && "vkGetDeviceGroupSurfacePresentModesKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceGroupSurfacePresentModesKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDeviceImageMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceImageMemoryRequirements, ¶ms);
-    assert(!status && "vkGetDeviceImageMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetDeviceImageMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetDeviceImageMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDeviceImageMemoryRequirementsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceImageMemoryRequirementsKHR, ¶ms);
-    assert(!status && "vkGetDeviceImageMemoryRequirementsKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceImageMemoryRequirementsKHR, ¶ms);
 }
 
 void WINAPI vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     struct vkGetDeviceImageSparseMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirements, ¶ms);
-    assert(!status && "vkGetDeviceImageSparseMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetDeviceImageSparseMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetDeviceImageSparseMemoryRequirementsKHR(VkDevice device, const VkDeviceImageMemoryRequirements *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     struct vkGetDeviceImageSparseMemoryRequirementsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceImageSparseMemoryRequirementsKHR, ¶ms);
-    assert(!status && "vkGetDeviceImageSparseMemoryRequirementsKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceImageSparseMemoryRequirementsKHR, ¶ms);
 }
 
 void WINAPI vkGetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *pInfo, VkSubresourceLayout2 *pLayout)
 {
     struct vkGetDeviceImageSubresourceLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetDeviceImageSubresourceLayout, ¶ms);
-    assert(!status && "vkGetDeviceImageSubresourceLayout");
+    UNIX_CALL_CHECKED(vkGetDeviceImageSubresourceLayout, ¶ms);
 }
 
 void WINAPI vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfo *pInfo, VkSubresourceLayout2 *pLayout)
 {
     struct vkGetDeviceImageSubresourceLayoutKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetDeviceImageSubresourceLayoutKHR, ¶ms);
-    assert(!status && "vkGetDeviceImageSubresourceLayoutKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceImageSubresourceLayoutKHR, ¶ms);
 }
 
 void WINAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize *pCommittedMemoryInBytes)
 {
     struct vkGetDeviceMemoryCommitment_params params;
-    NTSTATUS status;
     params.device = device;
     params.memory = memory;
     params.pCommittedMemoryInBytes = pCommittedMemoryInBytes;
-    status = UNIX_CALL(vkGetDeviceMemoryCommitment, ¶ms);
-    assert(!status && "vkGetDeviceMemoryCommitment");
+    UNIX_CALL_CHECKED(vkGetDeviceMemoryCommitment, ¶ms);
 }
 
 uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
     struct vkGetDeviceMemoryOpaqueCaptureAddress_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddress, ¶ms);
-    assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddress");
+    UNIX_CALL_CHECKED(vkGetDeviceMemoryOpaqueCaptureAddress, ¶ms);
     return params.result;
 }
 
 uint64_t WINAPI vkGetDeviceMemoryOpaqueCaptureAddressKHR(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo *pInfo)
 {
     struct vkGetDeviceMemoryOpaqueCaptureAddressKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetDeviceMemoryOpaqueCaptureAddressKHR, ¶ms);
-    assert(!status && "vkGetDeviceMemoryOpaqueCaptureAddressKHR");
+    UNIX_CALL_CHECKED(vkGetDeviceMemoryOpaqueCaptureAddressKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT *pVersionInfo, VkAccelerationStructureCompatibilityKHR *pCompatibility)
 {
     struct vkGetDeviceMicromapCompatibilityEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pVersionInfo = pVersionInfo;
     params.pCompatibility = pCompatibility;
-    status = UNIX_CALL(vkGetDeviceMicromapCompatibilityEXT, ¶ms);
-    assert(!status && "vkGetDeviceMicromapCompatibilityEXT");
+    UNIX_CALL_CHECKED(vkGetDeviceMicromapCompatibilityEXT, ¶ms);
 }
 
 void WINAPI vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
 {
     struct vkGetDeviceQueue_params params;
-    NTSTATUS status;
     params.device = device;
     params.queueFamilyIndex = queueFamilyIndex;
     params.queueIndex = queueIndex;
     params.pQueue = pQueue;
-    status = UNIX_CALL(vkGetDeviceQueue, ¶ms);
-    assert(!status && "vkGetDeviceQueue");
+    UNIX_CALL_CHECKED(vkGetDeviceQueue, ¶ms);
 }
 
 void WINAPI vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue)
 {
     struct vkGetDeviceQueue2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pQueueInfo = pQueueInfo;
     params.pQueue = pQueue;
-    status = UNIX_CALL(vkGetDeviceQueue2, ¶ms);
-    assert(!status && "vkGetDeviceQueue2");
+    UNIX_CALL_CHECKED(vkGetDeviceQueue2, ¶ms);
 }
 
 VkResult WINAPI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D *pMaxWorkgroupSize)
 {
     struct vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI_params params;
-    NTSTATUS status;
     params.device = device;
     params.renderpass = renderpass;
     params.pMaxWorkgroupSize = pMaxWorkgroupSize;
-    status = UNIX_CALL(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, ¶ms);
-    assert(!status && "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
+    UNIX_CALL_CHECKED(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetDeviceTensorMemoryRequirementsARM(VkDevice device, const VkDeviceTensorMemoryRequirementsARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetDeviceTensorMemoryRequirementsARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetDeviceTensorMemoryRequirementsARM, ¶ms);
-    assert(!status && "vkGetDeviceTensorMemoryRequirementsARM");
+    UNIX_CALL_CHECKED(vkGetDeviceTensorMemoryRequirementsARM, ¶ms);
 }
 
 VkResult WINAPI vkGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo *pRenderingInfo, VkTilePropertiesQCOM *pProperties)
 {
     struct vkGetDynamicRenderingTilePropertiesQCOM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pRenderingInfo = pRenderingInfo;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetDynamicRenderingTilePropertiesQCOM, ¶ms);
-    assert(!status && "vkGetDynamicRenderingTilePropertiesQCOM");
+    UNIX_CALL_CHECKED(vkGetDynamicRenderingTilePropertiesQCOM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetEncodedVideoSessionParametersKHR(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR *pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR *pFeedbackInfo, size_t *pDataSize, void *pData)
 {
     struct vkGetEncodedVideoSessionParametersKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pVideoSessionParametersInfo = pVideoSessionParametersInfo;
     params.pFeedbackInfo = pFeedbackInfo;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetEncodedVideoSessionParametersKHR, ¶ms);
-    assert(!status && "vkGetEncodedVideoSessionParametersKHR");
+    UNIX_CALL_CHECKED(vkGetEncodedVideoSessionParametersKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetEventStatus(VkDevice device, VkEvent event)
 {
     struct vkGetEventStatus_params params;
-    NTSTATUS status;
     params.device = device;
     params.event = event;
-    status = UNIX_CALL(vkGetEventStatus, ¶ms);
-    assert(!status && "vkGetEventStatus");
+    UNIX_CALL_CHECKED(vkGetEventStatus, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetFenceStatus(VkDevice device, VkFence fence)
 {
     struct vkGetFenceStatus_params params;
-    NTSTATUS status;
     params.device = device;
     params.fence = fence;
-    status = UNIX_CALL(vkGetFenceStatus, ¶ms);
-    assert(!status && "vkGetFenceStatus");
+    UNIX_CALL_CHECKED(vkGetFenceStatus, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
 {
     struct vkGetFenceWin32HandleKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pGetWin32HandleInfo = pGetWin32HandleInfo;
     params.pHandle = pHandle;
-    status = UNIX_CALL(vkGetFenceWin32HandleKHR, ¶ms);
-    assert(!status && "vkGetFenceWin32HandleKHR");
+    UNIX_CALL_CHECKED(vkGetFenceWin32HandleKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t *pPropertiesCount, VkTilePropertiesQCOM *pProperties)
 {
     struct vkGetFramebufferTilePropertiesQCOM_params params;
-    NTSTATUS status;
     params.device = device;
     params.framebuffer = framebuffer;
     params.pPropertiesCount = pPropertiesCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetFramebufferTilePropertiesQCOM, ¶ms);
-    assert(!status && "vkGetFramebufferTilePropertiesQCOM");
+    UNIX_CALL_CHECKED(vkGetFramebufferTilePropertiesQCOM, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetGeneratedCommandsMemoryRequirementsEXT(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetGeneratedCommandsMemoryRequirementsEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsEXT, ¶ms);
-    assert(!status && "vkGetGeneratedCommandsMemoryRequirementsEXT");
+    UNIX_CALL_CHECKED(vkGetGeneratedCommandsMemoryRequirementsEXT, ¶ms);
 }
 
 void WINAPI vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetGeneratedCommandsMemoryRequirementsNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetGeneratedCommandsMemoryRequirementsNV, ¶ms);
-    assert(!status && "vkGetGeneratedCommandsMemoryRequirementsNV");
+    UNIX_CALL_CHECKED(vkGetGeneratedCommandsMemoryRequirementsNV, ¶ms);
 }
 
 VkResult WINAPI vkGetGpaDeviceClockInfoAMD(VkDevice device, VkGpaDeviceGetClockInfoAMD *pInfo)
 {
     struct vkGetGpaDeviceClockInfoAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetGpaDeviceClockInfoAMD, ¶ms);
-    assert(!status && "vkGetGpaDeviceClockInfoAMD");
+    UNIX_CALL_CHECKED(vkGetGpaDeviceClockInfoAMD, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetGpaSessionResultsAMD(VkDevice device, VkGpaSessionAMD gpaSession, uint32_t sampleID, size_t *pSizeInBytes, void *pData)
 {
     struct vkGetGpaSessionResultsAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.gpaSession = gpaSession;
     params.sampleID = sampleID;
     params.pSizeInBytes = pSizeInBytes;
     params.pData = pData;
-    status = UNIX_CALL(vkGetGpaSessionResultsAMD, ¶ms);
-    assert(!status && "vkGetGpaSessionResultsAMD");
+    UNIX_CALL_CHECKED(vkGetGpaSessionResultsAMD, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetGpaSessionStatusAMD(VkDevice device, VkGpaSessionAMD gpaSession)
 {
     struct vkGetGpaSessionStatusAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.gpaSession = gpaSession;
-    status = UNIX_CALL(vkGetGpaSessionStatusAMD, ¶ms);
-    assert(!status && "vkGetGpaSessionStatusAMD");
+    UNIX_CALL_CHECKED(vkGetGpaSessionStatusAMD, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements)
 {
     struct vkGetImageMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetImageMemoryRequirements, ¶ms);
-    assert(!status && "vkGetImageMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetImageMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetImageMemoryRequirements2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetImageMemoryRequirements2, ¶ms);
-    assert(!status && "vkGetImageMemoryRequirements2");
+    UNIX_CALL_CHECKED(vkGetImageMemoryRequirements2, ¶ms);
 }
 
 void WINAPI vkGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetImageMemoryRequirements2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetImageMemoryRequirements2KHR, ¶ms);
-    assert(!status && "vkGetImageMemoryRequirements2KHR");
+    UNIX_CALL_CHECKED(vkGetImageMemoryRequirements2KHR, ¶ms);
 }
 
 VkResult WINAPI vkGetImageOpaqueCaptureDataEXT(VkDevice device, uint32_t imageCount, const VkImage *pImages, VkHostAddressRangeEXT *pDatas)
 {
     struct vkGetImageOpaqueCaptureDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.imageCount = imageCount;
     params.pImages = pImages;
     params.pDatas = pDatas;
-    status = UNIX_CALL(vkGetImageOpaqueCaptureDataEXT, ¶ms);
-    assert(!status && "vkGetImageOpaqueCaptureDataEXT");
+    UNIX_CALL_CHECKED(vkGetImageOpaqueCaptureDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetImageOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT *pInfo, void *pData)
 {
     struct vkGetImageOpaqueCaptureDescriptorDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetImageOpaqueCaptureDescriptorDataEXT, ¶ms);
-    assert(!status && "vkGetImageOpaqueCaptureDescriptorDataEXT");
+    UNIX_CALL_CHECKED(vkGetImageOpaqueCaptureDescriptorDataEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements *pSparseMemoryRequirements)
 {
     struct vkGetImageSparseMemoryRequirements_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
-    status = UNIX_CALL(vkGetImageSparseMemoryRequirements, ¶ms);
-    assert(!status && "vkGetImageSparseMemoryRequirements");
+    UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements, ¶ms);
 }
 
 void WINAPI vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     struct vkGetImageSparseMemoryRequirements2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
-    status = UNIX_CALL(vkGetImageSparseMemoryRequirements2, ¶ms);
-    assert(!status && "vkGetImageSparseMemoryRequirements2");
+    UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements2, ¶ms);
 }
 
 void WINAPI vkGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2 *pInfo, uint32_t *pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2 *pSparseMemoryRequirements)
 {
     struct vkGetImageSparseMemoryRequirements2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSparseMemoryRequirementCount = pSparseMemoryRequirementCount;
     params.pSparseMemoryRequirements = pSparseMemoryRequirements;
-    status = UNIX_CALL(vkGetImageSparseMemoryRequirements2KHR, ¶ms);
-    assert(!status && "vkGetImageSparseMemoryRequirements2KHR");
+    UNIX_CALL_CHECKED(vkGetImageSparseMemoryRequirements2KHR, ¶ms);
 }
 
 void WINAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource, VkSubresourceLayout *pLayout)
 {
     struct vkGetImageSubresourceLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pSubresource = pSubresource;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetImageSubresourceLayout, ¶ms);
-    assert(!status && "vkGetImageSubresourceLayout");
+    UNIX_CALL_CHECKED(vkGetImageSubresourceLayout, ¶ms);
 }
 
 void WINAPI vkGetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout)
 {
     struct vkGetImageSubresourceLayout2_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pSubresource = pSubresource;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetImageSubresourceLayout2, ¶ms);
-    assert(!status && "vkGetImageSubresourceLayout2");
+    UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2, ¶ms);
 }
 
 void WINAPI vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout)
 {
     struct vkGetImageSubresourceLayout2EXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pSubresource = pSubresource;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetImageSubresourceLayout2EXT, ¶ms);
-    assert(!status && "vkGetImageSubresourceLayout2EXT");
+    UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2EXT, ¶ms);
 }
 
 void WINAPI vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2 *pSubresource, VkSubresourceLayout2 *pLayout)
 {
     struct vkGetImageSubresourceLayout2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.image = image;
     params.pSubresource = pSubresource;
     params.pLayout = pLayout;
-    status = UNIX_CALL(vkGetImageSubresourceLayout2KHR, ¶ms);
-    assert(!status && "vkGetImageSubresourceLayout2KHR");
+    UNIX_CALL_CHECKED(vkGetImageSubresourceLayout2KHR, ¶ms);
 }
 
 VkResult WINAPI vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX *pProperties)
 {
     struct vkGetImageViewAddressNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.imageView = imageView;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetImageViewAddressNVX, ¶ms);
-    assert(!status && "vkGetImageViewAddressNVX");
+    UNIX_CALL_CHECKED(vkGetImageViewAddressNVX, ¶ms);
     return params.result;
 }
 
 uint64_t WINAPI vkGetImageViewHandle64NVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
 {
     struct vkGetImageViewHandle64NVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetImageViewHandle64NVX, ¶ms);
-    assert(!status && "vkGetImageViewHandle64NVX");
+    UNIX_CALL_CHECKED(vkGetImageViewHandle64NVX, ¶ms);
     return params.result;
 }
 
 uint32_t WINAPI vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX *pInfo)
 {
     struct vkGetImageViewHandleNVX_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetImageViewHandleNVX, ¶ms);
-    assert(!status && "vkGetImageViewHandleNVX");
+    UNIX_CALL_CHECKED(vkGetImageViewHandleNVX, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetImageViewOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT *pInfo, void *pData)
 {
     struct vkGetImageViewOpaqueCaptureDescriptorDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetImageViewOpaqueCaptureDescriptorDataEXT, ¶ms);
-    assert(!status && "vkGetImageViewOpaqueCaptureDescriptorDataEXT");
+    UNIX_CALL_CHECKED(vkGetImageViewOpaqueCaptureDescriptorDataEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetLatencyTimingsNV(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV *pLatencyMarkerInfo)
 {
     struct vkGetLatencyTimingsNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pLatencyMarkerInfo = pLatencyMarkerInfo;
-    status = UNIX_CALL(vkGetLatencyTimingsNV, ¶ms);
-    assert(!status && "vkGetLatencyTimingsNV");
+    UNIX_CALL_CHECKED(vkGetLatencyTimingsNV, ¶ms);
 }
 
 VkResult WINAPI vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void *pHostPointer, VkMemoryHostPointerPropertiesEXT *pMemoryHostPointerProperties)
 {
     struct vkGetMemoryHostPointerPropertiesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.handleType = handleType;
     params.pHostPointer = pHostPointer;
     params.pMemoryHostPointerProperties = pMemoryHostPointerProperties;
-    status = UNIX_CALL(vkGetMemoryHostPointerPropertiesEXT, ¶ms);
-    assert(!status && "vkGetMemoryHostPointerPropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetMemoryHostPointerPropertiesEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
 {
     struct vkGetMemoryWin32HandleKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pGetWin32HandleInfo = pGetWin32HandleInfo;
     params.pHandle = pHandle;
-    status = UNIX_CALL(vkGetMemoryWin32HandleKHR, ¶ms);
-    assert(!status && "vkGetMemoryWin32HandleKHR");
+    UNIX_CALL_CHECKED(vkGetMemoryWin32HandleKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR *pMemoryWin32HandleProperties)
 {
     struct vkGetMemoryWin32HandlePropertiesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.handleType = handleType;
     params.handle = handle;
     params.pMemoryWin32HandleProperties = pMemoryWin32HandleProperties;
-    status = UNIX_CALL(vkGetMemoryWin32HandlePropertiesKHR, ¶ms);
-    assert(!status && "vkGetMemoryWin32HandlePropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetMemoryWin32HandlePropertiesKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT *pBuildInfo, VkMicromapBuildSizesInfoEXT *pSizeInfo)
 {
     struct vkGetMicromapBuildSizesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.buildType = buildType;
     params.pBuildInfo = pBuildInfo;
     params.pSizeInfo = pSizeInfo;
-    status = UNIX_CALL(vkGetMicromapBuildSizesEXT, ¶ms);
-    assert(!status && "vkGetMicromapBuildSizesEXT");
+    UNIX_CALL_CHECKED(vkGetMicromapBuildSizesEXT, ¶ms);
 }
 
 void WINAPI vkGetPartitionedAccelerationStructuresBuildSizesNV(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV *pInfo, VkAccelerationStructureBuildSizesInfoKHR *pSizeInfo)
 {
     struct vkGetPartitionedAccelerationStructuresBuildSizesNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pSizeInfo = pSizeInfo;
-    status = UNIX_CALL(vkGetPartitionedAccelerationStructuresBuildSizesNV, ¶ms);
-    assert(!status && "vkGetPartitionedAccelerationStructuresBuildSizesNV");
+    UNIX_CALL_CHECKED(vkGetPartitionedAccelerationStructuresBuildSizesNV, ¶ms);
 }
 
 VkResult WINAPI vkGetPastPresentationTimingEXT(VkDevice device, const VkPastPresentationTimingInfoEXT *pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT *pPastPresentationTimingProperties)
 {
     struct vkGetPastPresentationTimingEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPastPresentationTimingInfo = pPastPresentationTimingInfo;
     params.pPastPresentationTimingProperties = pPastPresentationTimingProperties;
-    status = UNIX_CALL(vkGetPastPresentationTimingEXT, ¶ms);
-    assert(!status && "vkGetPastPresentationTimingEXT");
+    UNIX_CALL_CHECKED(vkGetPastPresentationTimingEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL *pValue)
 {
     struct vkGetPerformanceParameterINTEL_params params;
-    NTSTATUS status;
     params.device = device;
     params.parameter = parameter;
     params.pValue = pValue;
-    status = UNIX_CALL(vkGetPerformanceParameterINTEL, ¶ms);
-    assert(!status && "vkGetPerformanceParameterINTEL");
+    UNIX_CALL_CHECKED(vkGetPerformanceParameterINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
 {
     struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pTimeDomainCount = pTimeDomainCount;
     params.pTimeDomains = pTimeDomains;
-    status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainKHR *pTimeDomains)
 {
     struct vkGetPhysicalDeviceCalibrateableTimeDomainsKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pTimeDomainCount = pTimeDomainCount;
     params.pTimeDomains = pTimeDomains;
-    status = UNIX_CALL(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *pProperties)
 {
     struct vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesKHR *pProperties)
 {
     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeMatrixPropertiesNV *pProperties)
 {
     struct vkGetPhysicalDeviceCooperativeMatrixPropertiesNV_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceCooperativeVectorPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkCooperativeVectorPropertiesNV *pProperties)
 {
     struct vkGetPhysicalDeviceCooperativeVectorPropertiesNV_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceCooperativeVectorPropertiesNV, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceCooperativeVectorPropertiesNV");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceCooperativeVectorPropertiesNV, ¶ms);
     return params.result;
 }
 
 VkDeviceSize WINAPI vkGetPhysicalDeviceDescriptorSizeEXT(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType)
 {
     struct vkGetPhysicalDeviceDescriptorSizeEXT_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.descriptorType = descriptorType;
-    status = UNIX_CALL(vkGetPhysicalDeviceDescriptorSizeEXT, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceDescriptorSizeEXT");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceDescriptorSizeEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
 {
     struct vkGetPhysicalDeviceExternalBufferProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalBufferInfo = pExternalBufferInfo;
     params.pExternalBufferProperties = pExternalBufferProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalBufferProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalBufferProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties)
 {
     struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalBufferInfo = pExternalBufferInfo;
     params.pExternalBufferProperties = pExternalBufferProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalBufferPropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalBufferPropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalBufferPropertiesKHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
 {
     struct vkGetPhysicalDeviceExternalFenceProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalFenceInfo = pExternalFenceInfo;
     params.pExternalFenceProperties = pExternalFenceProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalFenceProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalFenceProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalFenceProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties)
 {
     struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalFenceInfo = pExternalFenceInfo;
     params.pExternalFenceProperties = pExternalFenceProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalFencePropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalFencePropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalFencePropertiesKHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
 {
     struct vkGetPhysicalDeviceExternalSemaphoreProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
     params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphoreProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalSemaphoreProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalSemaphoreProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties)
 {
     struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalSemaphoreInfo = pExternalSemaphoreInfo;
     params.pExternalSemaphoreProperties = pExternalSemaphoreProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceExternalTensorPropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM *pExternalTensorInfo, VkExternalTensorPropertiesARM *pExternalTensorProperties)
 {
     struct vkGetPhysicalDeviceExternalTensorPropertiesARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pExternalTensorInfo = pExternalTensorInfo;
     params.pExternalTensorProperties = pExternalTensorProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceExternalTensorPropertiesARM, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceExternalTensorPropertiesARM");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceExternalTensorPropertiesARM, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
 {
     struct vkGetPhysicalDeviceFeatures_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFeatures = pFeatures;
-    status = UNIX_CALL(vkGetPhysicalDeviceFeatures, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFeatures");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     struct vkGetPhysicalDeviceFeatures2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFeatures = pFeatures;
-    status = UNIX_CALL(vkGetPhysicalDeviceFeatures2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFeatures2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures)
 {
     struct vkGetPhysicalDeviceFeatures2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFeatures = pFeatures;
-    status = UNIX_CALL(vkGetPhysicalDeviceFeatures2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFeatures2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFeatures2KHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
 {
     struct vkGetPhysicalDeviceFormatProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.format = format;
     params.pFormatProperties = pFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFormatProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     struct vkGetPhysicalDeviceFormatProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.format = format;
     params.pFormatProperties = pFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFormatProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2 *pFormatProperties)
 {
     struct vkGetPhysicalDeviceFormatProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.format = format;
     params.pFormatProperties = pFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceFormatProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFormatProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFormatProperties2KHR, ¶ms);
 }
 
 VkResult WINAPI vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t *pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR *pFragmentShadingRates)
 {
     struct vkGetPhysicalDeviceFragmentShadingRatesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFragmentShadingRateCount = pFragmentShadingRateCount;
     params.pFragmentShadingRates = pFragmentShadingRates;
-    status = UNIX_CALL(vkGetPhysicalDeviceFragmentShadingRatesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceFragmentShadingRatesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceFragmentShadingRatesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
 {
     struct vkGetPhysicalDeviceImageFormatProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.format = format;
     params.type = type;
@@ -6088,232 +5549,192 @@ VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physic
     params.usage = usage;
     params.flags = flags;
     params.pImageFormatProperties = pImageFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceImageFormatProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pImageFormatInfo = pImageFormatInfo;
     params.pImageFormatProperties = pImageFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceImageFormatProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties)
 {
     struct vkGetPhysicalDeviceImageFormatProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pImageFormatInfo = pImageFormatInfo;
     params.pImageFormatProperties = pImageFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceImageFormatProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceImageFormatProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceImageFormatProperties2KHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
 {
     struct vkGetPhysicalDeviceMemoryProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pMemoryProperties = pMemoryProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceMemoryProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
     struct vkGetPhysicalDeviceMemoryProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pMemoryProperties = pMemoryProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceMemoryProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
 {
     struct vkGetPhysicalDeviceMemoryProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pMemoryProperties = pMemoryProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceMemoryProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceMemoryProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceMemoryProperties2KHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT *pMultisampleProperties)
 {
     struct vkGetPhysicalDeviceMultisamplePropertiesEXT_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.samples = samples;
     params.pMultisampleProperties = pMultisampleProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceMultisamplePropertiesEXT, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceMultisamplePropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceMultisamplePropertiesEXT, ¶ms);
 }
 
 VkResult WINAPI vkGetPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkOpticalFlowImageFormatPropertiesNV *pImageFormatProperties)
 {
     struct vkGetPhysicalDeviceOpticalFlowImageFormatsNV_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo;
     params.pFormatCount = pFormatCount;
     params.pImageFormatProperties = pImageFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceOpticalFlowImageFormatsNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pRectCount, VkRect2D *pRects)
 {
     struct vkGetPhysicalDevicePresentRectanglesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.surface = surface;
     params.pRectCount = pRectCount;
     params.pRects = pRects;
-    status = UNIX_CALL(vkGetPhysicalDevicePresentRectanglesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDevicePresentRectanglesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDevicePresentRectanglesKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
 {
     struct vkGetPhysicalDeviceProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
 {
     struct vkGetPhysicalDeviceProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties)
 {
     struct vkGetPhysicalDeviceProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceProperties2KHR, ¶ms);
 }
 
 VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties, VkBaseOutStructure *pProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties, const VkDataGraphOpticalFlowImageFormatInfoARM *pOpticalFlowImageFormatInfo, uint32_t *pFormatCount, VkDataGraphOpticalFlowImageFormatPropertiesARM *pImageFormatProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties;
     params.pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo;
     params.pFormatCount = pFormatCount;
     params.pImageFormatProperties = pImageFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *pQueueFamilyDataGraphProcessingEngineProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pQueueFamilyDataGraphProcessingEngineInfo = pQueueFamilyDataGraphProcessingEngineInfo;
     params.pQueueFamilyDataGraphProcessingEngineProperties = pQueueFamilyDataGraphProcessingEngineProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, ¶ms);
 }
 
 VkResult WINAPI vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t *pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM *pQueueFamilyDataGraphProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.pQueueFamilyDataGraphPropertyCount = pQueueFamilyDataGraphPropertyCount;
     params.pQueueFamilyDataGraphProperties = pQueueFamilyDataGraphProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR *pPerformanceQueryCreateInfo, uint32_t *pNumPasses)
 {
     struct vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo;
     params.pNumPasses = pNumPasses;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
     params.pQueueFamilyProperties = pQueueFamilyProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
     params.pQueueFamilyProperties = pQueueFamilyProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)
 {
     struct vkGetPhysicalDeviceQueueFamilyProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pQueueFamilyPropertyCount = pQueueFamilyPropertyCount;
     params.pQueueFamilyProperties = pQueueFamilyProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceQueueFamilyProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceQueueFamilyProperties2KHR, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
 {
     struct vkGetPhysicalDeviceSparseImageFormatProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.format = format;
     params.type = type;
@@ -6322,336 +5743,282 @@ void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice phys
     params.tiling = tiling;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     struct vkGetPhysicalDeviceSparseImageFormatProperties2_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFormatInfo = pFormatInfo;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties2, ¶ms);
 }
 
 void WINAPI vkGetPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, VkSparseImageFormatProperties2 *pProperties)
 {
     struct vkGetPhysicalDeviceSparseImageFormatProperties2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pFormatInfo = pFormatInfo;
     params.pPropertyCount = pPropertyCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSparseImageFormatProperties2KHR, ¶ms);
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t *pCombinationCount, VkFramebufferMixedSamplesCombinationNV *pCombinations)
 {
     struct vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pCombinationCount = pCombinationCount;
     params.pCombinations = pCombinations;
-    status = UNIX_CALL(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pSurfaceInfo = pSurfaceInfo;
     params.pSurfaceCapabilities = pSurfaceCapabilities;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilities2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfaceCapabilities2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceCapabilities2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
 {
     struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.surface = surface;
     params.pSurfaceCapabilities = pSurfaceCapabilities;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceCapabilitiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, uint32_t *pSurfaceFormatCount, VkSurfaceFormat2KHR *pSurfaceFormats)
 {
     struct vkGetPhysicalDeviceSurfaceFormats2KHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pSurfaceInfo = pSurfaceInfo;
     params.pSurfaceFormatCount = pSurfaceFormatCount;
     params.pSurfaceFormats = pSurfaceFormats;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormats2KHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfaceFormats2KHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceFormats2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
 {
     struct vkGetPhysicalDeviceSurfaceFormatsKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.surface = surface;
     params.pSurfaceFormatCount = pSurfaceFormatCount;
     params.pSurfaceFormats = pSurfaceFormats;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfaceFormatsKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfaceFormatsKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceFormatsKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes)
 {
     struct vkGetPhysicalDeviceSurfacePresentModesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.surface = surface;
     params.pPresentModeCount = pPresentModeCount;
     params.pPresentModes = pPresentModes;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfacePresentModesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfacePresentModesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfacePresentModesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
 {
     struct vkGetPhysicalDeviceSurfaceSupportKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
     params.surface = surface;
     params.pSupported = pSupported;
-    status = UNIX_CALL(vkGetPhysicalDeviceSurfaceSupportKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceSurfaceSupportKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceSurfaceSupportKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
 {
     struct vkGetPhysicalDeviceToolProperties_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pToolCount = pToolCount;
     params.pToolProperties = pToolProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceToolProperties, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceToolProperties");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceToolProperties, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t *pToolCount, VkPhysicalDeviceToolProperties *pToolProperties)
 {
     struct vkGetPhysicalDeviceToolPropertiesEXT_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pToolCount = pToolCount;
     params.pToolProperties = pToolProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceToolPropertiesEXT, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceToolPropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceToolPropertiesEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR *pVideoProfile, VkVideoCapabilitiesKHR *pCapabilities)
 {
     struct vkGetPhysicalDeviceVideoCapabilitiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pVideoProfile = pVideoProfile;
     params.pCapabilities = pCapabilities;
-    status = UNIX_CALL(vkGetPhysicalDeviceVideoCapabilitiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceVideoCapabilitiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoCapabilitiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR *pQualityLevelProperties)
 {
     struct vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pQualityLevelInfo = pQualityLevelInfo;
     params.pQualityLevelProperties = pQualityLevelProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR *pVideoFormatInfo, uint32_t *pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR *pVideoFormatProperties)
 {
     struct vkGetPhysicalDeviceVideoFormatPropertiesKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.pVideoFormatInfo = pVideoFormatInfo;
     params.pVideoFormatPropertyCount = pVideoFormatPropertyCount;
     params.pVideoFormatProperties = pVideoFormatProperties;
-    status = UNIX_CALL(vkGetPhysicalDeviceVideoFormatPropertiesKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceVideoFormatPropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceVideoFormatPropertiesKHR, ¶ms);
     return params.result;
 }
 
 VkBool32 WINAPI vkGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
 {
     struct vkGetPhysicalDeviceWin32PresentationSupportKHR_params params;
-    NTSTATUS status;
     params.physicalDevice = physicalDevice;
     params.queueFamilyIndex = queueFamilyIndex;
-    status = UNIX_CALL(vkGetPhysicalDeviceWin32PresentationSupportKHR, ¶ms);
-    assert(!status && "vkGetPhysicalDeviceWin32PresentationSupportKHR");
+    UNIX_CALL_CHECKED(vkGetPhysicalDeviceWin32PresentationSupportKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelineBinaryDataKHR(VkDevice device, const VkPipelineBinaryDataInfoKHR *pInfo, VkPipelineBinaryKeyKHR *pPipelineBinaryKey, size_t *pPipelineBinaryDataSize, void *pPipelineBinaryData)
 {
     struct vkGetPipelineBinaryDataKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pPipelineBinaryKey = pPipelineBinaryKey;
     params.pPipelineBinaryDataSize = pPipelineBinaryDataSize;
     params.pPipelineBinaryData = pPipelineBinaryData;
-    status = UNIX_CALL(vkGetPipelineBinaryDataKHR, ¶ms);
-    assert(!status && "vkGetPipelineBinaryDataKHR");
+    UNIX_CALL_CHECKED(vkGetPipelineBinaryDataKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize, void *pData)
 {
     struct vkGetPipelineCacheData_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipelineCache = pipelineCache;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetPipelineCacheData, ¶ms);
-    assert(!status && "vkGetPipelineCacheData");
+    UNIX_CALL_CHECKED(vkGetPipelineCacheData, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR *pInternalRepresentations)
 {
     struct vkGetPipelineExecutableInternalRepresentationsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pExecutableInfo = pExecutableInfo;
     params.pInternalRepresentationCount = pInternalRepresentationCount;
     params.pInternalRepresentations = pInternalRepresentations;
-    status = UNIX_CALL(vkGetPipelineExecutableInternalRepresentationsKHR, ¶ms);
-    assert(!status && "vkGetPipelineExecutableInternalRepresentationsKHR");
+    UNIX_CALL_CHECKED(vkGetPipelineExecutableInternalRepresentationsKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, uint32_t *pExecutableCount, VkPipelineExecutablePropertiesKHR *pProperties)
 {
     struct vkGetPipelineExecutablePropertiesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPipelineInfo = pPipelineInfo;
     params.pExecutableCount = pExecutableCount;
     params.pProperties = pProperties;
-    status = UNIX_CALL(vkGetPipelineExecutablePropertiesKHR, ¶ms);
-    assert(!status && "vkGetPipelineExecutablePropertiesKHR");
+    UNIX_CALL_CHECKED(vkGetPipelineExecutablePropertiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pStatisticCount, VkPipelineExecutableStatisticKHR *pStatistics)
 {
     struct vkGetPipelineExecutableStatisticsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pExecutableInfo = pExecutableInfo;
     params.pStatisticCount = pStatisticCount;
     params.pStatistics = pStatistics;
-    status = UNIX_CALL(vkGetPipelineExecutableStatisticsKHR, ¶ms);
-    assert(!status && "vkGetPipelineExecutableStatisticsKHR");
+    UNIX_CALL_CHECKED(vkGetPipelineExecutableStatisticsKHR, ¶ms);
     return params.result;
 }
 
 VkDeviceAddress WINAPI vkGetPipelineIndirectDeviceAddressNV(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV *pInfo)
 {
     struct vkGetPipelineIndirectDeviceAddressNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetPipelineIndirectDeviceAddressNV, ¶ms);
-    assert(!status && "vkGetPipelineIndirectDeviceAddressNV");
+    UNIX_CALL_CHECKED(vkGetPipelineIndirectDeviceAddressNV, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPipelineIndirectMemoryRequirementsNV(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetPipelineIndirectMemoryRequirementsNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetPipelineIndirectMemoryRequirementsNV, ¶ms);
-    assert(!status && "vkGetPipelineIndirectMemoryRequirementsNV");
+    UNIX_CALL_CHECKED(vkGetPipelineIndirectMemoryRequirementsNV, ¶ms);
 }
 
 VkResult WINAPI vkGetPipelineKeyKHR(VkDevice device, const VkPipelineCreateInfoKHR *pPipelineCreateInfo, VkPipelineBinaryKeyKHR *pPipelineKey)
 {
     struct vkGetPipelineKeyKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPipelineCreateInfo = pPipelineCreateInfo;
     params.pPipelineKey = pPipelineKey;
-    status = UNIX_CALL(vkGetPipelineKeyKHR, ¶ms);
-    assert(!status && "vkGetPipelineKeyKHR");
+    UNIX_CALL_CHECKED(vkGetPipelineKeyKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo, VkBaseOutStructure *pPipelineProperties)
 {
     struct vkGetPipelinePropertiesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pPipelineInfo = pPipelineInfo;
     params.pPipelineProperties = pPipelineProperties;
-    status = UNIX_CALL(vkGetPipelinePropertiesEXT, ¶ms);
-    assert(!status && "vkGetPipelinePropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetPipelinePropertiesEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
 {
     struct vkGetPrivateData_params params;
-    NTSTATUS status;
     params.device = device;
     params.objectType = objectType;
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.pData = pData;
-    status = UNIX_CALL(vkGetPrivateData, ¶ms);
-    assert(!status && "vkGetPrivateData");
+    UNIX_CALL_CHECKED(vkGetPrivateData, ¶ms);
 }
 
 void WINAPI vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t *pData)
 {
     struct vkGetPrivateDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.objectType = objectType;
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.pData = pData;
-    status = UNIX_CALL(vkGetPrivateDataEXT, ¶ms);
-    assert(!status && "vkGetPrivateDataEXT");
+    UNIX_CALL_CHECKED(vkGetPrivateDataEXT, ¶ms);
 }
 
 VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags)
 {
     struct vkGetQueryPoolResults_params params;
-    NTSTATUS status;
     params.device = device;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
@@ -6660,1024 +6027,851 @@ VkResult WINAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, ui
     params.pData = pData;
     params.stride = stride;
     params.flags = flags;
-    status = UNIX_CALL(vkGetQueryPoolResults, ¶ms);
-    assert(!status && "vkGetQueryPoolResults");
+    UNIX_CALL_CHECKED(vkGetQueryPoolResults, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointData2NV *pCheckpointData)
 {
     struct vkGetQueueCheckpointData2NV_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pCheckpointDataCount = pCheckpointDataCount;
     params.pCheckpointData = pCheckpointData;
-    status = UNIX_CALL(vkGetQueueCheckpointData2NV, ¶ms);
-    assert(!status && "vkGetQueueCheckpointData2NV");
+    UNIX_CALL_CHECKED(vkGetQueueCheckpointData2NV, ¶ms);
 }
 
 void WINAPI vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t *pCheckpointDataCount, VkCheckpointDataNV *pCheckpointData)
 {
     struct vkGetQueueCheckpointDataNV_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pCheckpointDataCount = pCheckpointDataCount;
     params.pCheckpointData = pCheckpointData;
-    status = UNIX_CALL(vkGetQueueCheckpointDataNV, ¶ms);
-    assert(!status && "vkGetQueueCheckpointDataNV");
+    UNIX_CALL_CHECKED(vkGetQueueCheckpointDataNV, ¶ms);
 }
 
 VkResult WINAPI vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     struct vkGetRayTracingCaptureReplayShaderGroupHandlesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.firstGroup = firstGroup;
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, ¶ms);
-    assert(!status && "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
+    UNIX_CALL_CHECKED(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     struct vkGetRayTracingShaderGroupHandlesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.firstGroup = firstGroup;
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesKHR, ¶ms);
-    assert(!status && "vkGetRayTracingShaderGroupHandlesKHR");
+    UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupHandlesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetRayTracingShaderGroupHandlesNV(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void *pData)
 {
     struct vkGetRayTracingShaderGroupHandlesNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.firstGroup = firstGroup;
     params.groupCount = groupCount;
     params.dataSize = dataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetRayTracingShaderGroupHandlesNV, ¶ms);
-    assert(!status && "vkGetRayTracingShaderGroupHandlesNV");
+    UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupHandlesNV, ¶ms);
     return params.result;
 }
 
 VkDeviceSize WINAPI vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
 {
     struct vkGetRayTracingShaderGroupStackSizeKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.group = group;
     params.groupShader = groupShader;
-    status = UNIX_CALL(vkGetRayTracingShaderGroupStackSizeKHR, ¶ms);
-    assert(!status && "vkGetRayTracingShaderGroupStackSizeKHR");
+    UNIX_CALL_CHECKED(vkGetRayTracingShaderGroupStackSizeKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity)
 {
     struct vkGetRenderAreaGranularity_params params;
-    NTSTATUS status;
     params.device = device;
     params.renderPass = renderPass;
     params.pGranularity = pGranularity;
-    status = UNIX_CALL(vkGetRenderAreaGranularity, ¶ms);
-    assert(!status && "vkGetRenderAreaGranularity");
+    UNIX_CALL_CHECKED(vkGetRenderAreaGranularity, ¶ms);
 }
 
 void WINAPI vkGetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *pRenderingAreaInfo, VkExtent2D *pGranularity)
 {
     struct vkGetRenderingAreaGranularity_params params;
-    NTSTATUS status;
     params.device = device;
     params.pRenderingAreaInfo = pRenderingAreaInfo;
     params.pGranularity = pGranularity;
-    status = UNIX_CALL(vkGetRenderingAreaGranularity, ¶ms);
-    assert(!status && "vkGetRenderingAreaGranularity");
+    UNIX_CALL_CHECKED(vkGetRenderingAreaGranularity, ¶ms);
 }
 
 void WINAPI vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfo *pRenderingAreaInfo, VkExtent2D *pGranularity)
 {
     struct vkGetRenderingAreaGranularityKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pRenderingAreaInfo = pRenderingAreaInfo;
     params.pGranularity = pGranularity;
-    status = UNIX_CALL(vkGetRenderingAreaGranularityKHR, ¶ms);
-    assert(!status && "vkGetRenderingAreaGranularityKHR");
+    UNIX_CALL_CHECKED(vkGetRenderingAreaGranularityKHR, ¶ms);
 }
 
 VkResult WINAPI vkGetSamplerOpaqueCaptureDescriptorDataEXT(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT *pInfo, void *pData)
 {
     struct vkGetSamplerOpaqueCaptureDescriptorDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetSamplerOpaqueCaptureDescriptorDataEXT, ¶ms);
-    assert(!status && "vkGetSamplerOpaqueCaptureDescriptorDataEXT");
+    UNIX_CALL_CHECKED(vkGetSamplerOpaqueCaptureDescriptorDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     struct vkGetSemaphoreCounterValue_params params;
-    NTSTATUS status;
     params.device = device;
     params.semaphore = semaphore;
     params.pValue = pValue;
-    status = UNIX_CALL(vkGetSemaphoreCounterValue, ¶ms);
-    assert(!status && "vkGetSemaphoreCounterValue");
+    UNIX_CALL_CHECKED(vkGetSemaphoreCounterValue, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetSemaphoreCounterValueKHR(VkDevice device, VkSemaphore semaphore, uint64_t *pValue)
 {
     struct vkGetSemaphoreCounterValueKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.semaphore = semaphore;
     params.pValue = pValue;
-    status = UNIX_CALL(vkGetSemaphoreCounterValueKHR, ¶ms);
-    assert(!status && "vkGetSemaphoreCounterValueKHR");
+    UNIX_CALL_CHECKED(vkGetSemaphoreCounterValueKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR *pGetWin32HandleInfo, HANDLE *pHandle)
 {
     struct vkGetSemaphoreWin32HandleKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pGetWin32HandleInfo = pGetWin32HandleInfo;
     params.pHandle = pHandle;
-    status = UNIX_CALL(vkGetSemaphoreWin32HandleKHR, ¶ms);
-    assert(!status && "vkGetSemaphoreWin32HandleKHR");
+    UNIX_CALL_CHECKED(vkGetSemaphoreWin32HandleKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetShaderBinaryDataEXT(VkDevice device, VkShaderEXT shader, size_t *pDataSize, void *pData)
 {
     struct vkGetShaderBinaryDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.shader = shader;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetShaderBinaryDataEXT, ¶ms);
-    assert(!status && "vkGetShaderBinaryDataEXT");
+    UNIX_CALL_CHECKED(vkGetShaderBinaryDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t *pInfoSize, void *pInfo)
 {
     struct vkGetShaderInfoAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.pipeline = pipeline;
     params.shaderStage = shaderStage;
     params.infoType = infoType;
     params.pInfoSize = pInfoSize;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkGetShaderInfoAMD, ¶ms);
-    assert(!status && "vkGetShaderInfoAMD");
+    UNIX_CALL_CHECKED(vkGetShaderInfoAMD, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetShaderInstrumentationValuesARM(VkDevice device, VkShaderInstrumentationARM instrumentation, uint32_t *pMetricBlockCount, void *pMetricValues, VkShaderInstrumentationValuesFlagsARM flags)
 {
     struct vkGetShaderInstrumentationValuesARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.instrumentation = instrumentation;
     params.pMetricBlockCount = pMetricBlockCount;
     params.pMetricValues = pMetricValues;
     params.flags = flags;
-    status = UNIX_CALL(vkGetShaderInstrumentationValuesARM, ¶ms);
-    assert(!status && "vkGetShaderInstrumentationValuesARM");
+    UNIX_CALL_CHECKED(vkGetShaderInstrumentationValuesARM, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo, VkShaderModuleIdentifierEXT *pIdentifier)
 {
     struct vkGetShaderModuleCreateInfoIdentifierEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pCreateInfo = pCreateInfo;
     params.pIdentifier = pIdentifier;
-    status = UNIX_CALL(vkGetShaderModuleCreateInfoIdentifierEXT, ¶ms);
-    assert(!status && "vkGetShaderModuleCreateInfoIdentifierEXT");
+    UNIX_CALL_CHECKED(vkGetShaderModuleCreateInfoIdentifierEXT, ¶ms);
 }
 
 void WINAPI vkGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT *pIdentifier)
 {
     struct vkGetShaderModuleIdentifierEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.shaderModule = shaderModule;
     params.pIdentifier = pIdentifier;
-    status = UNIX_CALL(vkGetShaderModuleIdentifierEXT, ¶ms);
-    assert(!status && "vkGetShaderModuleIdentifierEXT");
+    UNIX_CALL_CHECKED(vkGetShaderModuleIdentifierEXT, ¶ms);
 }
 
 VkResult WINAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
 {
     struct vkGetSwapchainImagesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pSwapchainImageCount = pSwapchainImageCount;
     params.pSwapchainImages = pSwapchainImages;
-    status = UNIX_CALL(vkGetSwapchainImagesKHR, ¶ms);
-    assert(!status && "vkGetSwapchainImagesKHR");
+    UNIX_CALL_CHECKED(vkGetSwapchainImagesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetSwapchainTimeDomainPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT *pSwapchainTimeDomainProperties, uint64_t *pTimeDomainsCounter)
 {
     struct vkGetSwapchainTimeDomainPropertiesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pSwapchainTimeDomainProperties = pSwapchainTimeDomainProperties;
     params.pTimeDomainsCounter = pTimeDomainsCounter;
-    status = UNIX_CALL(vkGetSwapchainTimeDomainPropertiesEXT, ¶ms);
-    assert(!status && "vkGetSwapchainTimeDomainPropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetSwapchainTimeDomainPropertiesEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetSwapchainTimingPropertiesEXT(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT *pSwapchainTimingProperties, uint64_t *pSwapchainTimingPropertiesCounter)
 {
     struct vkGetSwapchainTimingPropertiesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pSwapchainTimingProperties = pSwapchainTimingProperties;
     params.pSwapchainTimingPropertiesCounter = pSwapchainTimingPropertiesCounter;
-    status = UNIX_CALL(vkGetSwapchainTimingPropertiesEXT, ¶ms);
-    assert(!status && "vkGetSwapchainTimingPropertiesEXT");
+    UNIX_CALL_CHECKED(vkGetSwapchainTimingPropertiesEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkGetTensorMemoryRequirementsARM(VkDevice device, const VkTensorMemoryRequirementsInfoARM *pInfo, VkMemoryRequirements2 *pMemoryRequirements)
 {
     struct vkGetTensorMemoryRequirementsARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetTensorMemoryRequirementsARM, ¶ms);
-    assert(!status && "vkGetTensorMemoryRequirementsARM");
+    UNIX_CALL_CHECKED(vkGetTensorMemoryRequirementsARM, ¶ms);
 }
 
 VkResult WINAPI vkGetTensorOpaqueCaptureDataARM(VkDevice device, uint32_t tensorCount, const VkTensorARM *pTensors, VkHostAddressRangeEXT *pDatas)
 {
     struct vkGetTensorOpaqueCaptureDataARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.tensorCount = tensorCount;
     params.pTensors = pTensors;
     params.pDatas = pDatas;
-    status = UNIX_CALL(vkGetTensorOpaqueCaptureDataARM, ¶ms);
-    assert(!status && "vkGetTensorOpaqueCaptureDataARM");
+    UNIX_CALL_CHECKED(vkGetTensorOpaqueCaptureDataARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetTensorOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM *pInfo, void *pData)
 {
     struct vkGetTensorOpaqueCaptureDescriptorDataARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetTensorOpaqueCaptureDescriptorDataARM, ¶ms);
-    assert(!status && "vkGetTensorOpaqueCaptureDescriptorDataARM");
+    UNIX_CALL_CHECKED(vkGetTensorOpaqueCaptureDescriptorDataARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetTensorViewOpaqueCaptureDescriptorDataARM(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM *pInfo, void *pData)
 {
     struct vkGetTensorViewOpaqueCaptureDescriptorDataARM_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pData = pData;
-    status = UNIX_CALL(vkGetTensorViewOpaqueCaptureDescriptorDataARM, ¶ms);
-    assert(!status && "vkGetTensorViewOpaqueCaptureDescriptorDataARM");
+    UNIX_CALL_CHECKED(vkGetTensorViewOpaqueCaptureDescriptorDataARM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t *pDataSize, void *pData)
 {
     struct vkGetValidationCacheDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.validationCache = validationCache;
     params.pDataSize = pDataSize;
     params.pData = pData;
-    status = UNIX_CALL(vkGetValidationCacheDataEXT, ¶ms);
-    assert(!status && "vkGetValidationCacheDataEXT");
+    UNIX_CALL_CHECKED(vkGetValidationCacheDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t *pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR *pMemoryRequirements)
 {
     struct vkGetVideoSessionMemoryRequirementsKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.videoSession = videoSession;
     params.pMemoryRequirementsCount = pMemoryRequirementsCount;
     params.pMemoryRequirements = pMemoryRequirements;
-    status = UNIX_CALL(vkGetVideoSessionMemoryRequirementsKHR, ¶ms);
-    assert(!status && "vkGetVideoSessionMemoryRequirementsKHR");
+    UNIX_CALL_CHECKED(vkGetVideoSessionMemoryRequirementsKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR *pImportFenceWin32HandleInfo)
 {
     struct vkImportFenceWin32HandleKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pImportFenceWin32HandleInfo = pImportFenceWin32HandleInfo;
-    status = UNIX_CALL(vkImportFenceWin32HandleKHR, ¶ms);
-    assert(!status && "vkImportFenceWin32HandleKHR");
+    UNIX_CALL_CHECKED(vkImportFenceWin32HandleKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR *pImportSemaphoreWin32HandleInfo)
 {
     struct vkImportSemaphoreWin32HandleKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pImportSemaphoreWin32HandleInfo = pImportSemaphoreWin32HandleInfo;
-    status = UNIX_CALL(vkImportSemaphoreWin32HandleKHR, ¶ms);
-    assert(!status && "vkImportSemaphoreWin32HandleKHR");
+    UNIX_CALL_CHECKED(vkImportSemaphoreWin32HandleKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL *pInitializeInfo)
 {
     struct vkInitializePerformanceApiINTEL_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInitializeInfo = pInitializeInfo;
-    status = UNIX_CALL(vkInitializePerformanceApiINTEL, ¶ms);
-    assert(!status && "vkInitializePerformanceApiINTEL");
+    UNIX_CALL_CHECKED(vkInitializePerformanceApiINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange *pMemoryRanges)
 {
     struct vkInvalidateMappedMemoryRanges_params params;
-    NTSTATUS status;
     params.device = device;
     params.memoryRangeCount = memoryRangeCount;
     params.pMemoryRanges = pMemoryRanges;
-    status = UNIX_CALL(vkInvalidateMappedMemoryRanges, ¶ms);
-    assert(!status && "vkInvalidateMappedMemoryRanges");
+    UNIX_CALL_CHECKED(vkInvalidateMappedMemoryRanges, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkLatencySleepNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV *pSleepInfo)
 {
     struct vkLatencySleepNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pSleepInfo = pSleepInfo;
-    status = UNIX_CALL(vkLatencySleepNV, ¶ms);
-    assert(!status && "vkLatencySleepNV");
+    UNIX_CALL_CHECKED(vkLatencySleepNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData)
 {
     struct vkMapMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.memory = memory;
     params.offset = offset;
     params.size = size;
     params.flags = flags;
     params.ppData = ppData;
-    status = UNIX_CALL(vkMapMemory, ¶ms);
-    assert(!status && "vkMapMemory");
+    UNIX_CALL_CHECKED(vkMapMemory, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkMapMemory2(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo, void **ppData)
 {
     struct vkMapMemory2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pMemoryMapInfo = pMemoryMapInfo;
     params.ppData = ppData;
-    status = UNIX_CALL(vkMapMemory2, ¶ms);
-    assert(!status && "vkMapMemory2");
+    UNIX_CALL_CHECKED(vkMapMemory2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkMapMemory2KHR(VkDevice device, const VkMemoryMapInfo *pMemoryMapInfo, void **ppData)
 {
     struct vkMapMemory2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pMemoryMapInfo = pMemoryMapInfo;
     params.ppData = ppData;
-    status = UNIX_CALL(vkMapMemory2KHR, ¶ms);
-    assert(!status && "vkMapMemory2KHR");
+    UNIX_CALL_CHECKED(vkMapMemory2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache *pSrcCaches)
 {
     struct vkMergePipelineCaches_params params;
-    NTSTATUS status;
     params.device = device;
     params.dstCache = dstCache;
     params.srcCacheCount = srcCacheCount;
     params.pSrcCaches = pSrcCaches;
-    status = UNIX_CALL(vkMergePipelineCaches, ¶ms);
-    assert(!status && "vkMergePipelineCaches");
+    UNIX_CALL_CHECKED(vkMergePipelineCaches, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT *pSrcCaches)
 {
     struct vkMergeValidationCachesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.dstCache = dstCache;
     params.srcCacheCount = srcCacheCount;
     params.pSrcCaches = pSrcCaches;
-    status = UNIX_CALL(vkMergeValidationCachesEXT, ¶ms);
-    assert(!status && "vkMergeValidationCachesEXT");
+    UNIX_CALL_CHECKED(vkMergeValidationCachesEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     struct vkQueueBeginDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pLabelInfo = pLabelInfo;
-    status = UNIX_CALL(vkQueueBeginDebugUtilsLabelEXT, ¶ms);
-    assert(!status && "vkQueueBeginDebugUtilsLabelEXT");
+    UNIX_CALL_CHECKED(vkQueueBeginDebugUtilsLabelEXT, ¶ms);
 }
 
 VkResult WINAPI vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo, VkFence fence)
 {
     struct vkQueueBindSparse_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.bindInfoCount = bindInfoCount;
     params.pBindInfo = pBindInfo;
     params.fence = fence;
-    status = UNIX_CALL(vkQueueBindSparse, ¶ms);
-    assert(!status && "vkQueueBindSparse");
+    UNIX_CALL_CHECKED(vkQueueBindSparse, ¶ms);
     return params.result;
 }
 
 void WINAPI vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
 {
     struct vkQueueEndDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.queue = queue;
-    status = UNIX_CALL(vkQueueEndDebugUtilsLabelEXT, ¶ms);
-    assert(!status && "vkQueueEndDebugUtilsLabelEXT");
+    UNIX_CALL_CHECKED(vkQueueEndDebugUtilsLabelEXT, ¶ms);
 }
 
 void WINAPI vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT *pLabelInfo)
 {
     struct vkQueueInsertDebugUtilsLabelEXT_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pLabelInfo = pLabelInfo;
-    status = UNIX_CALL(vkQueueInsertDebugUtilsLabelEXT, ¶ms);
-    assert(!status && "vkQueueInsertDebugUtilsLabelEXT");
+    UNIX_CALL_CHECKED(vkQueueInsertDebugUtilsLabelEXT, ¶ms);
 }
 
 void WINAPI vkQueueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV *pQueueTypeInfo)
 {
     struct vkQueueNotifyOutOfBandNV_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pQueueTypeInfo = pQueueTypeInfo;
-    status = UNIX_CALL(vkQueueNotifyOutOfBandNV, ¶ms);
-    assert(!status && "vkQueueNotifyOutOfBandNV");
+    UNIX_CALL_CHECKED(vkQueueNotifyOutOfBandNV, ¶ms);
 }
 
 VkResult WINAPI vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
 {
     struct vkQueuePresentKHR_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pPresentInfo = pPresentInfo;
-    status = UNIX_CALL(vkQueuePresentKHR, ¶ms);
-    assert(!status && "vkQueuePresentKHR");
+    UNIX_CALL_CHECKED(vkQueuePresentKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueSetPerfHintQCOM(VkQueue queue, const VkPerfHintInfoQCOM *pPerfHintInfo)
 {
     struct vkQueueSetPerfHintQCOM_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.pPerfHintInfo = pPerfHintInfo;
-    status = UNIX_CALL(vkQueueSetPerfHintQCOM, ¶ms);
-    assert(!status && "vkQueueSetPerfHintQCOM");
+    UNIX_CALL_CHECKED(vkQueueSetPerfHintQCOM, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
 {
     struct vkQueueSetPerformanceConfigurationINTEL_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.configuration = configuration;
-    status = UNIX_CALL(vkQueueSetPerformanceConfigurationINTEL, ¶ms);
-    assert(!status && "vkQueueSetPerformanceConfigurationINTEL");
+    UNIX_CALL_CHECKED(vkQueueSetPerformanceConfigurationINTEL, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
 {
     struct vkQueueSubmit_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    status = UNIX_CALL(vkQueueSubmit, ¶ms);
-    assert(!status && "vkQueueSubmit");
+    UNIX_CALL_CHECKED(vkQueueSubmit, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
 {
     struct vkQueueSubmit2_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    status = UNIX_CALL(vkQueueSubmit2, ¶ms);
-    assert(!status && "vkQueueSubmit2");
+    UNIX_CALL_CHECKED(vkQueueSubmit2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 *pSubmits, VkFence fence)
 {
     struct vkQueueSubmit2KHR_params params;
-    NTSTATUS status;
     params.queue = queue;
     params.submitCount = submitCount;
     params.pSubmits = pSubmits;
     params.fence = fence;
-    status = UNIX_CALL(vkQueueSubmit2KHR, ¶ms);
-    assert(!status && "vkQueueSubmit2KHR");
+    UNIX_CALL_CHECKED(vkQueueSubmit2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkQueueWaitIdle(VkQueue queue)
 {
     struct vkQueueWaitIdle_params params;
-    NTSTATUS status;
     params.queue = queue;
-    status = UNIX_CALL(vkQueueWaitIdle, ¶ms);
-    assert(!status && "vkQueueWaitIdle");
+    UNIX_CALL_CHECKED(vkQueueWaitIdle, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkRegisterCustomBorderColorEXT(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT *pBorderColor, VkBool32 requestIndex, uint32_t *pIndex)
 {
     struct vkRegisterCustomBorderColorEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pBorderColor = pBorderColor;
     params.requestIndex = requestIndex;
     params.pIndex = pIndex;
-    status = UNIX_CALL(vkRegisterCustomBorderColorEXT, ¶ms);
-    assert(!status && "vkRegisterCustomBorderColorEXT");
+    UNIX_CALL_CHECKED(vkRegisterCustomBorderColorEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkReleaseCapturedPipelineDataKHR(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR *pInfo, const VkAllocationCallbacks *pAllocator)
 {
     struct vkReleaseCapturedPipelineDataKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
     params.pAllocator = pAllocator;
-    status = UNIX_CALL(vkReleaseCapturedPipelineDataKHR, ¶ms);
-    assert(!status && "vkReleaseCapturedPipelineDataKHR");
+    UNIX_CALL_CHECKED(vkReleaseCapturedPipelineDataKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
 {
     struct vkReleasePerformanceConfigurationINTEL_params params;
-    NTSTATUS status;
     params.device = device;
     params.configuration = configuration;
-    status = UNIX_CALL(vkReleasePerformanceConfigurationINTEL, ¶ms);
-    assert(!status && "vkReleasePerformanceConfigurationINTEL");
+    UNIX_CALL_CHECKED(vkReleasePerformanceConfigurationINTEL, ¶ms);
     return params.result;
 }
 
 void WINAPI vkReleaseProfilingLockKHR(VkDevice device)
 {
     struct vkReleaseProfilingLockKHR_params params;
-    NTSTATUS status;
     params.device = device;
-    status = UNIX_CALL(vkReleaseProfilingLockKHR, ¶ms);
-    assert(!status && "vkReleaseProfilingLockKHR");
+    UNIX_CALL_CHECKED(vkReleaseProfilingLockKHR, ¶ms);
 }
 
 VkResult WINAPI vkReleaseSwapchainImagesEXT(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo)
 {
     struct vkReleaseSwapchainImagesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pReleaseInfo = pReleaseInfo;
-    status = UNIX_CALL(vkReleaseSwapchainImagesEXT, ¶ms);
-    assert(!status && "vkReleaseSwapchainImagesEXT");
+    UNIX_CALL_CHECKED(vkReleaseSwapchainImagesEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkReleaseSwapchainImagesKHR(VkDevice device, const VkReleaseSwapchainImagesInfoKHR *pReleaseInfo)
 {
     struct vkReleaseSwapchainImagesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pReleaseInfo = pReleaseInfo;
-    status = UNIX_CALL(vkReleaseSwapchainImagesKHR, ¶ms);
-    assert(!status && "vkReleaseSwapchainImagesKHR");
+    UNIX_CALL_CHECKED(vkReleaseSwapchainImagesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
 {
     struct vkResetCommandBuffer_params params;
-    NTSTATUS status;
     params.commandBuffer = commandBuffer;
     params.flags = flags;
-    status = UNIX_CALL(vkResetCommandBuffer, ¶ms);
-    assert(!status && "vkResetCommandBuffer");
+    UNIX_CALL_CHECKED(vkResetCommandBuffer, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
 {
     struct vkResetCommandPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.commandPool = commandPool;
     params.flags = flags;
-    status = UNIX_CALL(vkResetCommandPool, ¶ms);
-    assert(!status && "vkResetCommandPool");
+    UNIX_CALL_CHECKED(vkResetCommandPool, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
 {
     struct vkResetDescriptorPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorPool = descriptorPool;
     params.flags = flags;
-    status = UNIX_CALL(vkResetDescriptorPool, ¶ms);
-    assert(!status && "vkResetDescriptorPool");
+    UNIX_CALL_CHECKED(vkResetDescriptorPool, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetEvent(VkDevice device, VkEvent event)
 {
     struct vkResetEvent_params params;
-    NTSTATUS status;
     params.device = device;
     params.event = event;
-    status = UNIX_CALL(vkResetEvent, ¶ms);
-    assert(!status && "vkResetEvent");
+    UNIX_CALL_CHECKED(vkResetEvent, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
 {
     struct vkResetFences_params params;
-    NTSTATUS status;
     params.device = device;
     params.fenceCount = fenceCount;
     params.pFences = pFences;
-    status = UNIX_CALL(vkResetFences, ¶ms);
-    assert(!status && "vkResetFences");
+    UNIX_CALL_CHECKED(vkResetFences, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkResetGpaSessionAMD(VkDevice device, VkGpaSessionAMD gpaSession)
 {
     struct vkResetGpaSessionAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.gpaSession = gpaSession;
-    status = UNIX_CALL(vkResetGpaSessionAMD, ¶ms);
-    assert(!status && "vkResetGpaSessionAMD");
+    UNIX_CALL_CHECKED(vkResetGpaSessionAMD, ¶ms);
     return params.result;
 }
 
 void WINAPI vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     struct vkResetQueryPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
     params.queryCount = queryCount;
-    status = UNIX_CALL(vkResetQueryPool, ¶ms);
-    assert(!status && "vkResetQueryPool");
+    UNIX_CALL_CHECKED(vkResetQueryPool, ¶ms);
 }
 
 void WINAPI vkResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
 {
     struct vkResetQueryPoolEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.queryPool = queryPool;
     params.firstQuery = firstQuery;
     params.queryCount = queryCount;
-    status = UNIX_CALL(vkResetQueryPoolEXT, ¶ms);
-    assert(!status && "vkResetQueryPoolEXT");
+    UNIX_CALL_CHECKED(vkResetQueryPoolEXT, ¶ms);
 }
 
 VkResult WINAPI vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT *pNameInfo)
 {
     struct vkSetDebugUtilsObjectNameEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pNameInfo = pNameInfo;
-    status = UNIX_CALL(vkSetDebugUtilsObjectNameEXT, ¶ms);
-    assert(!status && "vkSetDebugUtilsObjectNameEXT");
+    UNIX_CALL_CHECKED(vkSetDebugUtilsObjectNameEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT *pTagInfo)
 {
     struct vkSetDebugUtilsObjectTagEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.pTagInfo = pTagInfo;
-    status = UNIX_CALL(vkSetDebugUtilsObjectTagEXT, ¶ms);
-    assert(!status && "vkSetDebugUtilsObjectTagEXT");
+    UNIX_CALL_CHECKED(vkSetDebugUtilsObjectTagEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
 {
     struct vkSetDeviceMemoryPriorityEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.memory = memory;
     params.priority = priority;
-    status = UNIX_CALL(vkSetDeviceMemoryPriorityEXT, ¶ms);
-    assert(!status && "vkSetDeviceMemoryPriorityEXT");
+    UNIX_CALL_CHECKED(vkSetDeviceMemoryPriorityEXT, ¶ms);
 }
 
 VkResult WINAPI vkSetEvent(VkDevice device, VkEvent event)
 {
     struct vkSetEvent_params params;
-    NTSTATUS status;
     params.device = device;
     params.event = event;
-    status = UNIX_CALL(vkSetEvent, ¶ms);
-    assert(!status && "vkSetEvent");
+    UNIX_CALL_CHECKED(vkSetEvent, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSetGpaDeviceClockModeAMD(VkDevice device, VkGpaDeviceClockModeInfoAMD *pInfo)
 {
     struct vkSetGpaDeviceClockModeAMD_params params;
-    NTSTATUS status;
     params.device = device;
     params.pInfo = pInfo;
-    status = UNIX_CALL(vkSetGpaDeviceClockModeAMD, ¶ms);
-    assert(!status && "vkSetGpaDeviceClockModeAMD");
+    UNIX_CALL_CHECKED(vkSetGpaDeviceClockModeAMD, ¶ms);
     return params.result;
 }
 
 void WINAPI vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR *pSwapchains, const VkHdrMetadataEXT *pMetadata)
 {
     struct vkSetHdrMetadataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchainCount = swapchainCount;
     params.pSwapchains = pSwapchains;
     params.pMetadata = pMetadata;
-    status = UNIX_CALL(vkSetHdrMetadataEXT, ¶ms);
-    assert(!status && "vkSetHdrMetadataEXT");
+    UNIX_CALL_CHECKED(vkSetHdrMetadataEXT, ¶ms);
 }
 
 void WINAPI vkSetLatencyMarkerNV(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV *pLatencyMarkerInfo)
 {
     struct vkSetLatencyMarkerNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pLatencyMarkerInfo = pLatencyMarkerInfo;
-    status = UNIX_CALL(vkSetLatencyMarkerNV, ¶ms);
-    assert(!status && "vkSetLatencyMarkerNV");
+    UNIX_CALL_CHECKED(vkSetLatencyMarkerNV, ¶ms);
 }
 
 VkResult WINAPI vkSetLatencySleepModeNV(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV *pSleepModeInfo)
 {
     struct vkSetLatencySleepModeNV_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pSleepModeInfo = pSleepModeInfo;
-    status = UNIX_CALL(vkSetLatencySleepModeNV, ¶ms);
-    assert(!status && "vkSetLatencySleepModeNV");
+    UNIX_CALL_CHECKED(vkSetLatencySleepModeNV, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
 {
     struct vkSetPrivateData_params params;
-    NTSTATUS status;
     params.device = device;
     params.objectType = objectType;
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.data = data;
-    status = UNIX_CALL(vkSetPrivateData, ¶ms);
-    assert(!status && "vkSetPrivateData");
+    UNIX_CALL_CHECKED(vkSetPrivateData, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
 {
     struct vkSetPrivateDataEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.objectType = objectType;
     params.objectHandle = objectHandle;
     params.privateDataSlot = privateDataSlot;
     params.data = data;
-    status = UNIX_CALL(vkSetPrivateDataEXT, ¶ms);
-    assert(!status && "vkSetPrivateDataEXT");
+    UNIX_CALL_CHECKED(vkSetPrivateDataEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSetSwapchainPresentTimingQueueSizeEXT(VkDevice device, VkSwapchainKHR swapchain, uint32_t size)
 {
     struct vkSetSwapchainPresentTimingQueueSizeEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.size = size;
-    status = UNIX_CALL(vkSetSwapchainPresentTimingQueueSizeEXT, ¶ms);
-    assert(!status && "vkSetSwapchainPresentTimingQueueSizeEXT");
+    UNIX_CALL_CHECKED(vkSetSwapchainPresentTimingQueueSizeEXT, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
     struct vkSignalSemaphore_params params;
-    NTSTATUS status;
     params.device = device;
     params.pSignalInfo = pSignalInfo;
-    status = UNIX_CALL(vkSignalSemaphore, ¶ms);
-    assert(!status && "vkSignalSemaphore");
+    UNIX_CALL_CHECKED(vkSignalSemaphore, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkSignalSemaphoreKHR(VkDevice device, const VkSemaphoreSignalInfo *pSignalInfo)
 {
     struct vkSignalSemaphoreKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pSignalInfo = pSignalInfo;
-    status = UNIX_CALL(vkSignalSemaphoreKHR, ¶ms);
-    assert(!status && "vkSignalSemaphoreKHR");
+    UNIX_CALL_CHECKED(vkSignalSemaphoreKHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkSubmitDebugUtilsMessageEXT(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData)
 {
     struct vkSubmitDebugUtilsMessageEXT_params params;
-    NTSTATUS status;
     params.instance = instance;
     params.messageSeverity = messageSeverity;
     params.messageTypes = messageTypes;
     params.pCallbackData = pCallbackData;
-    status = UNIX_CALL(vkSubmitDebugUtilsMessageEXT, ¶ms);
-    assert(!status && "vkSubmitDebugUtilsMessageEXT");
+    UNIX_CALL_CHECKED(vkSubmitDebugUtilsMessageEXT, ¶ms);
 }
 
 VkResult WINAPI vkTransitionImageLayout(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo *pTransitions)
 {
     struct vkTransitionImageLayout_params params;
-    NTSTATUS status;
     params.device = device;
     params.transitionCount = transitionCount;
     params.pTransitions = pTransitions;
-    status = UNIX_CALL(vkTransitionImageLayout, ¶ms);
-    assert(!status && "vkTransitionImageLayout");
+    UNIX_CALL_CHECKED(vkTransitionImageLayout, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkTransitionImageLayoutEXT(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo *pTransitions)
 {
     struct vkTransitionImageLayoutEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.transitionCount = transitionCount;
     params.pTransitions = pTransitions;
-    status = UNIX_CALL(vkTransitionImageLayoutEXT, ¶ms);
-    assert(!status && "vkTransitionImageLayoutEXT");
+    UNIX_CALL_CHECKED(vkTransitionImageLayoutEXT, ¶ms);
     return params.result;
 }
 
 void WINAPI vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     struct vkTrimCommandPool_params params;
-    NTSTATUS status;
     params.device = device;
     params.commandPool = commandPool;
     params.flags = flags;
-    status = UNIX_CALL(vkTrimCommandPool, ¶ms);
-    assert(!status && "vkTrimCommandPool");
+    UNIX_CALL_CHECKED(vkTrimCommandPool, ¶ms);
 }
 
 void WINAPI vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
 {
     struct vkTrimCommandPoolKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.commandPool = commandPool;
     params.flags = flags;
-    status = UNIX_CALL(vkTrimCommandPoolKHR, ¶ms);
-    assert(!status && "vkTrimCommandPoolKHR");
+    UNIX_CALL_CHECKED(vkTrimCommandPoolKHR, ¶ms);
 }
 
 void WINAPI vkUninitializePerformanceApiINTEL(VkDevice device)
 {
     struct vkUninitializePerformanceApiINTEL_params params;
-    NTSTATUS status;
     params.device = device;
-    status = UNIX_CALL(vkUninitializePerformanceApiINTEL, ¶ms);
-    assert(!status && "vkUninitializePerformanceApiINTEL");
+    UNIX_CALL_CHECKED(vkUninitializePerformanceApiINTEL, ¶ms);
 }
 
 void WINAPI vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
 {
     struct vkUnmapMemory_params params;
-    NTSTATUS status;
     params.device = device;
     params.memory = memory;
-    status = UNIX_CALL(vkUnmapMemory, ¶ms);
-    assert(!status && "vkUnmapMemory");
+    UNIX_CALL_CHECKED(vkUnmapMemory, ¶ms);
 }
 
 VkResult WINAPI vkUnmapMemory2(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo)
 {
     struct vkUnmapMemory2_params params;
-    NTSTATUS status;
     params.device = device;
     params.pMemoryUnmapInfo = pMemoryUnmapInfo;
-    status = UNIX_CALL(vkUnmapMemory2, ¶ms);
-    assert(!status && "vkUnmapMemory2");
+    UNIX_CALL_CHECKED(vkUnmapMemory2, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkUnmapMemory2KHR(VkDevice device, const VkMemoryUnmapInfo *pMemoryUnmapInfo)
 {
     struct vkUnmapMemory2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pMemoryUnmapInfo = pMemoryUnmapInfo;
-    status = UNIX_CALL(vkUnmapMemory2KHR, ¶ms);
-    assert(!status && "vkUnmapMemory2KHR");
+    UNIX_CALL_CHECKED(vkUnmapMemory2KHR, ¶ms);
     return params.result;
 }
 
 void WINAPI vkUnregisterCustomBorderColorEXT(VkDevice device, uint32_t index)
 {
     struct vkUnregisterCustomBorderColorEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.index = index;
-    status = UNIX_CALL(vkUnregisterCustomBorderColorEXT, ¶ms);
-    assert(!status && "vkUnregisterCustomBorderColorEXT");
+    UNIX_CALL_CHECKED(vkUnregisterCustomBorderColorEXT, ¶ms);
 }
 
 void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
@@ -7693,13 +6887,11 @@ void WINAPI vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet d
 void WINAPI vkUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void *pData)
 {
     struct vkUpdateDescriptorSetWithTemplateKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.descriptorSet = descriptorSet;
     params.descriptorUpdateTemplate = descriptorUpdateTemplate;
     params.pData = pData;
-    status = UNIX_CALL(vkUpdateDescriptorSetWithTemplateKHR, ¶ms);
-    assert(!status && "vkUpdateDescriptorSetWithTemplateKHR");
+    UNIX_CALL_CHECKED(vkUpdateDescriptorSetWithTemplateKHR, ¶ms);
 }
 
 void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies)
@@ -7716,106 +6908,89 @@ void WINAPI vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCoun
 void WINAPI vkUpdateIndirectExecutionSetPipelineEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT *pExecutionSetWrites)
 {
     struct vkUpdateIndirectExecutionSetPipelineEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.indirectExecutionSet = indirectExecutionSet;
     params.executionSetWriteCount = executionSetWriteCount;
     params.pExecutionSetWrites = pExecutionSetWrites;
-    status = UNIX_CALL(vkUpdateIndirectExecutionSetPipelineEXT, ¶ms);
-    assert(!status && "vkUpdateIndirectExecutionSetPipelineEXT");
+    UNIX_CALL_CHECKED(vkUpdateIndirectExecutionSetPipelineEXT, ¶ms);
 }
 
 void WINAPI vkUpdateIndirectExecutionSetShaderEXT(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT *pExecutionSetWrites)
 {
     struct vkUpdateIndirectExecutionSetShaderEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.indirectExecutionSet = indirectExecutionSet;
     params.executionSetWriteCount = executionSetWriteCount;
     params.pExecutionSetWrites = pExecutionSetWrites;
-    status = UNIX_CALL(vkUpdateIndirectExecutionSetShaderEXT, ¶ms);
-    assert(!status && "vkUpdateIndirectExecutionSetShaderEXT");
+    UNIX_CALL_CHECKED(vkUpdateIndirectExecutionSetShaderEXT, ¶ms);
 }
 
 VkResult WINAPI vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR *pUpdateInfo)
 {
     struct vkUpdateVideoSessionParametersKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.videoSessionParameters = videoSessionParameters;
     params.pUpdateInfo = pUpdateInfo;
-    status = UNIX_CALL(vkUpdateVideoSessionParametersKHR, ¶ms);
-    assert(!status && "vkUpdateVideoSessionParametersKHR");
+    UNIX_CALL_CHECKED(vkUpdateVideoSessionParametersKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
 {
     struct vkWaitForFences_params params;
-    NTSTATUS status;
     params.device = device;
     params.fenceCount = fenceCount;
     params.pFences = pFences;
     params.waitAll = waitAll;
     params.timeout = timeout;
-    status = UNIX_CALL(vkWaitForFences, ¶ms);
-    assert(!status && "vkWaitForFences");
+    UNIX_CALL_CHECKED(vkWaitForFences, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWaitForPresent2KHR(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR *pPresentWait2Info)
 {
     struct vkWaitForPresent2KHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.pPresentWait2Info = pPresentWait2Info;
-    status = UNIX_CALL(vkWaitForPresent2KHR, ¶ms);
-    assert(!status && "vkWaitForPresent2KHR");
+    UNIX_CALL_CHECKED(vkWaitForPresent2KHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
 {
     struct vkWaitForPresentKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.swapchain = swapchain;
     params.presentId = presentId;
     params.timeout = timeout;
-    status = UNIX_CALL(vkWaitForPresentKHR, ¶ms);
-    assert(!status && "vkWaitForPresentKHR");
+    UNIX_CALL_CHECKED(vkWaitForPresentKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     struct vkWaitSemaphores_params params;
-    NTSTATUS status;
     params.device = device;
     params.pWaitInfo = pWaitInfo;
     params.timeout = timeout;
-    status = UNIX_CALL(vkWaitSemaphores, ¶ms);
-    assert(!status && "vkWaitSemaphores");
+    UNIX_CALL_CHECKED(vkWaitSemaphores, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWaitSemaphoresKHR(VkDevice device, const VkSemaphoreWaitInfo *pWaitInfo, uint64_t timeout)
 {
     struct vkWaitSemaphoresKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.pWaitInfo = pWaitInfo;
     params.timeout = timeout;
-    status = UNIX_CALL(vkWaitSemaphoresKHR, ¶ms);
-    assert(!status && "vkWaitSemaphoresKHR");
+    UNIX_CALL_CHECKED(vkWaitSemaphoresKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR *pAccelerationStructures, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
 {
     struct vkWriteAccelerationStructuresPropertiesKHR_params params;
-    NTSTATUS status;
     params.device = device;
     params.accelerationStructureCount = accelerationStructureCount;
     params.pAccelerationStructures = pAccelerationStructures;
@@ -7823,15 +6998,13 @@ VkResult WINAPI vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint
     params.dataSize = dataSize;
     params.pData = pData;
     params.stride = stride;
-    status = UNIX_CALL(vkWriteAccelerationStructuresPropertiesKHR, ¶ms);
-    assert(!status && "vkWriteAccelerationStructuresPropertiesKHR");
+    UNIX_CALL_CHECKED(vkWriteAccelerationStructuresPropertiesKHR, ¶ms);
     return params.result;
 }
 
 VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT *pMicromaps, VkQueryType queryType, size_t dataSize, void *pData, size_t stride)
 {
     struct vkWriteMicromapsPropertiesEXT_params params;
-    NTSTATUS status;
     params.device = device;
     params.micromapCount = micromapCount;
     params.pMicromaps = pMicromaps;
@@ -7839,8 +7012,7 @@ VkResult WINAPI vkWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromap
     params.dataSize = dataSize;
     params.pData = pData;
     params.stride = stride;
-    status = UNIX_CALL(vkWriteMicromapsPropertiesEXT, ¶ms);
-    assert(!status && "vkWriteMicromapsPropertiesEXT");
+    UNIX_CALL_CHECKED(vkWriteMicromapsPropertiesEXT, ¶ms);
     return params.result;
 }
 
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 70273a19223..71994e45788 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -884,8 +884,6 @@ class Function(Type):
         thunk += u"{\n"
         thunk += f"    struct {self.name}_params params;\n"
 
-        if not self.is_perf_critical():
-            thunk += u"    NTSTATUS status;\n"
         for p in self.params:
             thunk += f"    params.{p.name} = {p.name};\n"
 
@@ -893,8 +891,7 @@ class Function(Type):
         if self.is_perf_critical():
             thunk += f"    UNIX_CALL({self.name}, ¶ms);\n"
         else:
-            thunk += f"    status = UNIX_CALL({self.name}, ¶ms);\n"
-            thunk += f"    assert(!status && \"{self.name}\");\n"
+            thunk += f"    UNIX_CALL_CHECKED({self.name}, ¶ms);\n"
 
         if self.type != "void":
             thunk += u"    return params.result;\n"
diff --git a/dlls/winevulkan/vulkan_loader.h b/dlls/winevulkan/vulkan_loader.h
index 9066e0329ef..94e52774b77 100644
--- a/dlls/winevulkan/vulkan_loader.h
+++ b/dlls/winevulkan/vulkan_loader.h
@@ -23,7 +23,6 @@
 #include "ntstatus.h"
 #include <stdarg.h>
 #include <stdlib.h>
-#include <assert.h>
 #include "windef.h"
 #include "winbase.h"
 #include "winternl.h"
@@ -145,5 +144,14 @@ struct is_available_device_function_params
 };
 
 #define UNIX_CALL(code, params) WINE_UNIX_CALL(unix_ ## code, params)
+#define UNIX_CALL_CHECKED(code, params)                           \
+    {                                                             \
+        NTSTATUS status = UNIX_CALL(code, params);                \
+        if (status)                                               \
+        {                                                         \
+            ERR("Exception %#lx in Unix call.\n", status);        \
+            ExitProcess(3);                                       \
+        }                                                         \
+    }
 
 #endif /* __WINE_VULKAN_LOADER_H */
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/11164

[Paul Gofman (＠gofman)]

Wine own debug assertion dialogs look not particularly appealing when when Wine is used by end user (e. g., in Proton / SteamOS). Also, whether that is shown or not depends on app controlled error mode. 

It looks more straightforward to just have an ERR with a faulted function name and exit process.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/11164#note_143264

[Rémi Bernon (＠rbernon)]

Do we really want to exit though? I think the original idea was to allow exception to be caught, like it was the unixlib split.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/11164#note_143267

[Paul Gofman (＠gofman)]

Initially after PE split those Unix side crashes got caught as a part of generic handling. The assert (which implies process abort) was added intentionally because we so far we were assuming that Unix side Vulkan driver access violations (or other sort of aborts) are something to be caught. As while in principle the game might continue we so far don't want it to work in this state which is already deeply broken. We had a lot of complains from GPU driver devs when we accidentally caught all those exceptions and games were continuing but exhibiting deeper issues or graphical glitches. Of course there might be a case in theory that something crashes in the userspace side of Vulkan driver on Windows, that get caught but game and then everything works fine. Maybe if we had an example when something like that is needed for compatibility, but AFAIK we don't. And even then such a thing won't necessarily work well; crashing driver on Linux might be leaving broken state which it doesn't on Win
 dows.

So I'd suggest to continue treating native driver crashes as fatal, at least until we need that otherwise for something specific.

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/11164#note_143273

[Rémi Bernon (＠rbernon)]

Rémi Bernon (@rbernon) commented about dlls/winevulkan/vulkan_loader.h:
> };
>
> #define UNIX_CALL(code, params) WINE_UNIX_CALL(unix_ ## code, params)
> +#define UNIX_CALL_CHECKED(code, params)                           \
> +    {                                                             \
> +        NTSTATUS status = UNIX_CALL(code, params);                \
> +        if (status)                                               \
> +        {                                                         \
> +            ERR("Exception %#lx in Unix call.\n", status);        \
> +            ExitProcess(3);                                       \
> +        }                                                         \
> +    }
    do {                                                          \
        NTSTATUS status = UNIX_CALL(code, params);                \
        if (status)                                               \
        {                                                         \
            ERR("Exception %#lx in %s call.\n", status, #code);   \
            ExitProcess(3);                                       \
        }                                                         \
    } while (0)

-- 
https://gitlab.winehq.org/wine/wine/-/merge_requests/11164#note_143318