[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