// Generated by `scripts/generate_vk.js`

#![allow(non_snake_case)]

use std::os::raw::c_char;
use std::mem;
use utils::c_bindings::*;
use utils::vk_convert::get_vk_instance_function_pointer;
use vk::*;

pub struct VkInstanceFunctionTable {
    pub vkDestroyInstance: unsafe extern fn(RawVkInstance, *const c_void),
    pub vkEnumeratePhysicalDevices: unsafe extern fn(RawVkInstance, *mut u32, *mut RawVkPhysicalDevice) -> RawVkResult,
    pub vkGetPhysicalDeviceFeatures: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceFeatures),
    pub vkGetPhysicalDeviceFormatProperties: unsafe extern fn(RawVkPhysicalDevice, RawVkFormat, *mut RawVkFormatProperties),
    pub vkGetPhysicalDeviceImageFormatProperties: unsafe extern fn(RawVkPhysicalDevice, RawVkFormat, RawVkImageType, RawVkImageTiling, RawVkImageUsageFlags, RawVkImageCreateFlags, *mut RawVkImageFormatProperties) -> RawVkResult,
    pub vkGetPhysicalDeviceProperties: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceProperties),
    pub vkGetPhysicalDeviceQueueFamilyProperties: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut RawVkQueueFamilyProperties),
    pub vkGetPhysicalDeviceMemoryProperties: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceMemoryProperties),
    pub vkCreateDevice: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkDeviceCreateInfo, *const c_void, *mut RawVkDevice) -> RawVkResult,
    pub vkDestroyDevice: unsafe extern fn(RawVkDevice, *const c_void),
    pub vkEnumerateDeviceExtensionProperties: unsafe extern fn(RawVkPhysicalDevice, *mut c_char, *mut u32, *mut RawVkExtensionProperties) -> RawVkResult,
    pub vkEnumerateDeviceLayerProperties: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut RawVkLayerProperties) -> RawVkResult,
    pub vkGetDeviceQueue: unsafe extern fn(RawVkDevice, u32, u32, *mut RawVkQueue),
    pub vkQueueSubmit: unsafe extern fn(RawVkQueue, u32, *mut RawVkSubmitInfo, RawVkFence) -> RawVkResult,
    pub vkQueueWaitIdle: unsafe extern fn(RawVkQueue) -> RawVkResult,
    pub vkDeviceWaitIdle: unsafe extern fn(RawVkDevice) -> RawVkResult,
    pub vkAllocateMemory: unsafe extern fn(RawVkDevice, *mut RawVkMemoryAllocateInfo, *const c_void, *mut RawVkDeviceMemory) -> RawVkResult,
    pub vkFreeMemory: unsafe extern fn(RawVkDevice, RawVkDeviceMemory, *const c_void),
    pub vkMapMemory: unsafe extern fn(RawVkDevice, RawVkDeviceMemory, u64, u64, RawVkMemoryMapFlags, *mut *mut c_void) -> RawVkResult,
    pub vkUnmapMemory: unsafe extern fn(RawVkDevice, RawVkDeviceMemory),
    pub vkFlushMappedMemoryRanges: unsafe extern fn(RawVkDevice, u32, *mut RawVkMappedMemoryRange) -> RawVkResult,
    pub vkInvalidateMappedMemoryRanges: unsafe extern fn(RawVkDevice, u32, *mut RawVkMappedMemoryRange) -> RawVkResult,
    pub vkGetDeviceMemoryCommitment: unsafe extern fn(RawVkDevice, RawVkDeviceMemory, *mut u64),
    pub vkBindBufferMemory: unsafe extern fn(RawVkDevice, RawVkBuffer, RawVkDeviceMemory, u64) -> RawVkResult,
    pub vkBindImageMemory: unsafe extern fn(RawVkDevice, RawVkImage, RawVkDeviceMemory, u64) -> RawVkResult,
    pub vkGetBufferMemoryRequirements: unsafe extern fn(RawVkDevice, RawVkBuffer, *mut RawVkMemoryRequirements),
    pub vkGetImageMemoryRequirements: unsafe extern fn(RawVkDevice, RawVkImage, *mut RawVkMemoryRequirements),
    pub vkGetImageSparseMemoryRequirements: unsafe extern fn(RawVkDevice, RawVkImage, *mut u32, *mut RawVkSparseImageMemoryRequirements),
    pub vkGetPhysicalDeviceSparseImageFormatProperties: unsafe extern fn(RawVkPhysicalDevice, RawVkFormat, RawVkImageType, RawVkSampleCountFlags, RawVkImageUsageFlags, RawVkImageTiling, *mut u32, *mut RawVkSparseImageFormatProperties),
    pub vkQueueBindSparse: unsafe extern fn(RawVkQueue, u32, *mut RawVkBindSparseInfo, RawVkFence) -> RawVkResult,
    pub vkCreateFence: unsafe extern fn(RawVkDevice, *mut RawVkFenceCreateInfo, *const c_void, *mut RawVkFence) -> RawVkResult,
    pub vkDestroyFence: unsafe extern fn(RawVkDevice, RawVkFence, *const c_void),
    pub vkResetFences: unsafe extern fn(RawVkDevice, u32, *mut RawVkFence) -> RawVkResult,
    pub vkGetFenceStatus: unsafe extern fn(RawVkDevice, RawVkFence) -> RawVkResult,
    pub vkWaitForFences: unsafe extern fn(RawVkDevice, u32, *mut RawVkFence, u32, u64) -> RawVkResult,
    pub vkCreateSemaphore: unsafe extern fn(RawVkDevice, *mut RawVkSemaphoreCreateInfo, *const c_void, *mut RawVkSemaphore) -> RawVkResult,
    pub vkDestroySemaphore: unsafe extern fn(RawVkDevice, RawVkSemaphore, *const c_void),
    pub vkCreateEvent: unsafe extern fn(RawVkDevice, *mut RawVkEventCreateInfo, *const c_void, *mut RawVkEvent) -> RawVkResult,
    pub vkDestroyEvent: unsafe extern fn(RawVkDevice, RawVkEvent, *const c_void),
    pub vkGetEventStatus: unsafe extern fn(RawVkDevice, RawVkEvent) -> RawVkResult,
    pub vkSetEvent: unsafe extern fn(RawVkDevice, RawVkEvent) -> RawVkResult,
    pub vkResetEvent: unsafe extern fn(RawVkDevice, RawVkEvent) -> RawVkResult,
    pub vkCreateQueryPool: unsafe extern fn(RawVkDevice, *mut RawVkQueryPoolCreateInfo, *const c_void, *mut RawVkQueryPool) -> RawVkResult,
    pub vkDestroyQueryPool: unsafe extern fn(RawVkDevice, RawVkQueryPool, *const c_void),
    pub vkGetQueryPoolResults: unsafe extern fn(RawVkDevice, RawVkQueryPool, u32, u32, usize, *mut c_void, u64, RawVkQueryResultFlags) -> RawVkResult,
    pub vkCreateBuffer: unsafe extern fn(RawVkDevice, *mut RawVkBufferCreateInfo, *const c_void, *mut RawVkBuffer) -> RawVkResult,
    pub vkDestroyBuffer: unsafe extern fn(RawVkDevice, RawVkBuffer, *const c_void),
    pub vkCreateBufferView: unsafe extern fn(RawVkDevice, *mut RawVkBufferViewCreateInfo, *const c_void, *mut RawVkBufferView) -> RawVkResult,
    pub vkDestroyBufferView: unsafe extern fn(RawVkDevice, RawVkBufferView, *const c_void),
    pub vkCreateImage: unsafe extern fn(RawVkDevice, *mut RawVkImageCreateInfo, *const c_void, *mut RawVkImage) -> RawVkResult,
    pub vkDestroyImage: unsafe extern fn(RawVkDevice, RawVkImage, *const c_void),
    pub vkGetImageSubresourceLayout: unsafe extern fn(RawVkDevice, RawVkImage, *mut RawVkImageSubresource, *mut RawVkSubresourceLayout),
    pub vkCreateImageView: unsafe extern fn(RawVkDevice, *mut RawVkImageViewCreateInfo, *const c_void, *mut RawVkImageView) -> RawVkResult,
    pub vkDestroyImageView: unsafe extern fn(RawVkDevice, RawVkImageView, *const c_void),
    pub vkCreateShaderModule: unsafe extern fn(RawVkDevice, *mut RawVkShaderModuleCreateInfo, *const c_void, *mut RawVkShaderModule) -> RawVkResult,
    pub vkDestroyShaderModule: unsafe extern fn(RawVkDevice, RawVkShaderModule, *const c_void),
    pub vkCreatePipelineCache: unsafe extern fn(RawVkDevice, *mut RawVkPipelineCacheCreateInfo, *const c_void, *mut RawVkPipelineCache) -> RawVkResult,
    pub vkDestroyPipelineCache: unsafe extern fn(RawVkDevice, RawVkPipelineCache, *const c_void),
    pub vkGetPipelineCacheData: unsafe extern fn(RawVkDevice, RawVkPipelineCache, *mut usize, *mut c_void) -> RawVkResult,
    pub vkMergePipelineCaches: unsafe extern fn(RawVkDevice, RawVkPipelineCache, u32, *mut RawVkPipelineCache) -> RawVkResult,
    pub vkCreateGraphicsPipelines: unsafe extern fn(RawVkDevice, RawVkPipelineCache, u32, *mut RawVkGraphicsPipelineCreateInfo, *const c_void, *mut RawVkPipeline) -> RawVkResult,
    pub vkCreateComputePipelines: unsafe extern fn(RawVkDevice, RawVkPipelineCache, u32, *mut RawVkComputePipelineCreateInfo, *const c_void, *mut RawVkPipeline) -> RawVkResult,
    pub vkDestroyPipeline: unsafe extern fn(RawVkDevice, RawVkPipeline, *const c_void),
    pub vkCreatePipelineLayout: unsafe extern fn(RawVkDevice, *mut RawVkPipelineLayoutCreateInfo, *const c_void, *mut RawVkPipelineLayout) -> RawVkResult,
    pub vkDestroyPipelineLayout: unsafe extern fn(RawVkDevice, RawVkPipelineLayout, *const c_void),
    pub vkCreateSampler: unsafe extern fn(RawVkDevice, *mut RawVkSamplerCreateInfo, *const c_void, *mut RawVkSampler) -> RawVkResult,
    pub vkDestroySampler: unsafe extern fn(RawVkDevice, RawVkSampler, *const c_void),
    pub vkCreateDescriptorSetLayout: unsafe extern fn(RawVkDevice, *mut RawVkDescriptorSetLayoutCreateInfo, *const c_void, *mut RawVkDescriptorSetLayout) -> RawVkResult,
    pub vkDestroyDescriptorSetLayout: unsafe extern fn(RawVkDevice, RawVkDescriptorSetLayout, *const c_void),
    pub vkCreateDescriptorPool: unsafe extern fn(RawVkDevice, *mut RawVkDescriptorPoolCreateInfo, *const c_void, *mut RawVkDescriptorPool) -> RawVkResult,
    pub vkDestroyDescriptorPool: unsafe extern fn(RawVkDevice, RawVkDescriptorPool, *const c_void),
    pub vkResetDescriptorPool: unsafe extern fn(RawVkDevice, RawVkDescriptorPool, RawVkDescriptorPoolResetFlags) -> RawVkResult,
    pub vkAllocateDescriptorSets: unsafe extern fn(RawVkDevice, *mut RawVkDescriptorSetAllocateInfo, *mut RawVkDescriptorSet) -> RawVkResult,
    pub vkFreeDescriptorSets: unsafe extern fn(RawVkDevice, RawVkDescriptorPool, u32, *mut RawVkDescriptorSet) -> RawVkResult,
    pub vkUpdateDescriptorSets: unsafe extern fn(RawVkDevice, u32, *mut RawVkWriteDescriptorSet, u32, *mut RawVkCopyDescriptorSet),
    pub vkCreateFramebuffer: unsafe extern fn(RawVkDevice, *mut RawVkFramebufferCreateInfo, *const c_void, *mut RawVkFramebuffer) -> RawVkResult,
    pub vkDestroyFramebuffer: unsafe extern fn(RawVkDevice, RawVkFramebuffer, *const c_void),
    pub vkCreateRenderPass: unsafe extern fn(RawVkDevice, *mut RawVkRenderPassCreateInfo, *const c_void, *mut RawVkRenderPass) -> RawVkResult,
    pub vkDestroyRenderPass: unsafe extern fn(RawVkDevice, RawVkRenderPass, *const c_void),
    pub vkGetRenderAreaGranularity: unsafe extern fn(RawVkDevice, RawVkRenderPass, *mut RawVkExtent2D),
    pub vkCreateCommandPool: unsafe extern fn(RawVkDevice, *mut RawVkCommandPoolCreateInfo, *const c_void, *mut RawVkCommandPool) -> RawVkResult,
    pub vkDestroyCommandPool: unsafe extern fn(RawVkDevice, RawVkCommandPool, *const c_void),
    pub vkResetCommandPool: unsafe extern fn(RawVkDevice, RawVkCommandPool, RawVkCommandPoolResetFlags) -> RawVkResult,
    pub vkAllocateCommandBuffers: unsafe extern fn(RawVkDevice, *mut RawVkCommandBufferAllocateInfo, *mut RawVkCommandBuffer) -> RawVkResult,
    pub vkFreeCommandBuffers: unsafe extern fn(RawVkDevice, RawVkCommandPool, u32, *mut RawVkCommandBuffer),
    pub vkBeginCommandBuffer: unsafe extern fn(RawVkCommandBuffer, *mut RawVkCommandBufferBeginInfo) -> RawVkResult,
    pub vkEndCommandBuffer: unsafe extern fn(RawVkCommandBuffer) -> RawVkResult,
    pub vkResetCommandBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkCommandBufferResetFlags) -> RawVkResult,
    pub vkCmdBindPipeline: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineBindPoint, RawVkPipeline),
    pub vkCmdSetViewport: unsafe extern fn(RawVkCommandBuffer, u32, u32, *mut RawVkViewport),
    pub vkCmdSetScissor: unsafe extern fn(RawVkCommandBuffer, u32, u32, *mut RawVkRect2D),
    pub vkCmdSetLineWidth: unsafe extern fn(RawVkCommandBuffer, f32),
    pub vkCmdSetDepthBias: unsafe extern fn(RawVkCommandBuffer, f32, f32, f32),
    pub vkCmdSetBlendConstants: unsafe extern fn(RawVkCommandBuffer, [f32; 4]),
    pub vkCmdSetDepthBounds: unsafe extern fn(RawVkCommandBuffer, f32, f32),
    pub vkCmdSetStencilCompareMask: unsafe extern fn(RawVkCommandBuffer, RawVkStencilFaceFlags, u32),
    pub vkCmdSetStencilWriteMask: unsafe extern fn(RawVkCommandBuffer, RawVkStencilFaceFlags, u32),
    pub vkCmdSetStencilReference: unsafe extern fn(RawVkCommandBuffer, RawVkStencilFaceFlags, u32),
    pub vkCmdBindDescriptorSets: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineBindPoint, RawVkPipelineLayout, u32, u32, *mut RawVkDescriptorSet, u32, *mut u32),
    pub vkCmdBindIndexBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, RawVkIndexType),
    pub vkCmdBindVertexBuffers: unsafe extern fn(RawVkCommandBuffer, u32, u32, *mut RawVkBuffer, *mut u64),
    pub vkCmdDraw: unsafe extern fn(RawVkCommandBuffer, u32, u32, u32, u32),
    pub vkCmdDrawIndexed: unsafe extern fn(RawVkCommandBuffer, u32, u32, u32, i32, u32),
    pub vkCmdDrawIndirect: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, u32, u32),
    pub vkCmdDrawIndexedIndirect: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, u32, u32),
    pub vkCmdDispatch: unsafe extern fn(RawVkCommandBuffer, u32, u32, u32),
    pub vkCmdDispatchIndirect: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64),
    pub vkCmdCopyBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, RawVkBuffer, u32, *mut RawVkBufferCopy),
    pub vkCmdCopyImage: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, RawVkImage, RawVkImageLayout, u32, *mut RawVkImageCopy),
    pub vkCmdBlitImage: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, RawVkImage, RawVkImageLayout, u32, *mut RawVkImageBlit, RawVkFilter),
    pub vkCmdCopyBufferToImage: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, RawVkImage, RawVkImageLayout, u32, *mut RawVkBufferImageCopy),
    pub vkCmdCopyImageToBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, RawVkBuffer, u32, *mut RawVkBufferImageCopy),
    pub vkCmdUpdateBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, u64, *const c_void),
    pub vkCmdFillBuffer: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, u64, u32),
    pub vkCmdClearColorImage: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, *mut RawVkClearColorValue, u32, *mut RawVkImageSubresourceRange),
    pub vkCmdClearDepthStencilImage: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, *mut RawVkClearDepthStencilValue, u32, *mut RawVkImageSubresourceRange),
    pub vkCmdClearAttachments: unsafe extern fn(RawVkCommandBuffer, u32, *mut RawVkClearAttachment, u32, *mut RawVkClearRect),
    pub vkCmdResolveImage: unsafe extern fn(RawVkCommandBuffer, RawVkImage, RawVkImageLayout, RawVkImage, RawVkImageLayout, u32, *mut RawVkImageResolve),
    pub vkCmdSetEvent: unsafe extern fn(RawVkCommandBuffer, RawVkEvent, RawVkPipelineStageFlags),
    pub vkCmdResetEvent: unsafe extern fn(RawVkCommandBuffer, RawVkEvent, RawVkPipelineStageFlags),
    pub vkCmdWaitEvents: unsafe extern fn(RawVkCommandBuffer, u32, *mut RawVkEvent, RawVkPipelineStageFlags, RawVkPipelineStageFlags, u32, *mut RawVkMemoryBarrier, u32, *mut RawVkBufferMemoryBarrier, u32, *mut RawVkImageMemoryBarrier),
    pub vkCmdPipelineBarrier: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineStageFlags, RawVkPipelineStageFlags, RawVkDependencyFlags, u32, *mut RawVkMemoryBarrier, u32, *mut RawVkBufferMemoryBarrier, u32, *mut RawVkImageMemoryBarrier),
    pub vkCmdBeginQuery: unsafe extern fn(RawVkCommandBuffer, RawVkQueryPool, u32, RawVkQueryControlFlags),
    pub vkCmdEndQuery: unsafe extern fn(RawVkCommandBuffer, RawVkQueryPool, u32),
    pub vkCmdResetQueryPool: unsafe extern fn(RawVkCommandBuffer, RawVkQueryPool, u32, u32),
    pub vkCmdWriteTimestamp: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineStageFlags, RawVkQueryPool, u32),
    pub vkCmdCopyQueryPoolResults: unsafe extern fn(RawVkCommandBuffer, RawVkQueryPool, u32, u32, RawVkBuffer, u64, u64, RawVkQueryResultFlags),
    pub vkCmdPushConstants: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineLayout, RawVkShaderStageFlags, u32, u32, *const c_void),
    pub vkCmdBeginRenderPass: unsafe extern fn(RawVkCommandBuffer, *mut RawVkRenderPassBeginInfo, RawVkSubpassContents),
    pub vkCmdNextSubpass: unsafe extern fn(RawVkCommandBuffer, RawVkSubpassContents),
    pub vkCmdEndRenderPass: unsafe extern fn(RawVkCommandBuffer),
    pub vkCmdExecuteCommands: unsafe extern fn(RawVkCommandBuffer, u32, *mut RawVkCommandBuffer),
    pub vkBindBufferMemory2: unsafe extern fn(RawVkDevice, u32, *mut RawVkBindBufferMemoryInfo) -> RawVkResult,
    pub vkBindImageMemory2: unsafe extern fn(RawVkDevice, u32, *mut RawVkBindImageMemoryInfo) -> RawVkResult,
    pub vkGetDeviceGroupPeerMemoryFeatures: unsafe extern fn(RawVkDevice, u32, u32, u32, *mut RawVkPeerMemoryFeatureFlags),
    pub vkCmdSetDeviceMask: unsafe extern fn(RawVkCommandBuffer, u32),
    pub vkCmdDispatchBase: unsafe extern fn(RawVkCommandBuffer, u32, u32, u32, u32, u32, u32),
    pub vkEnumeratePhysicalDeviceGroups: unsafe extern fn(RawVkInstance, *mut u32, *mut RawVkPhysicalDeviceGroupProperties) -> RawVkResult,
    pub vkGetImageMemoryRequirements2: unsafe extern fn(RawVkDevice, *mut RawVkImageMemoryRequirementsInfo2, *mut RawVkMemoryRequirements2),
    pub vkGetBufferMemoryRequirements2: unsafe extern fn(RawVkDevice, *mut RawVkBufferMemoryRequirementsInfo2, *mut RawVkMemoryRequirements2),
    pub vkGetImageSparseMemoryRequirements2: unsafe extern fn(RawVkDevice, *mut RawVkImageSparseMemoryRequirementsInfo2, *mut u32, *mut RawVkSparseImageMemoryRequirements2),
    pub vkGetPhysicalDeviceFeatures2: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceFeatures2),
    pub vkGetPhysicalDeviceProperties2: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceProperties2),
    pub vkGetPhysicalDeviceFormatProperties2: unsafe extern fn(RawVkPhysicalDevice, RawVkFormat, *mut RawVkFormatProperties2),
    pub vkGetPhysicalDeviceImageFormatProperties2: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceImageFormatInfo2, *mut RawVkImageFormatProperties2) -> RawVkResult,
    pub vkGetPhysicalDeviceQueueFamilyProperties2: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut RawVkQueueFamilyProperties2),
    pub vkGetPhysicalDeviceMemoryProperties2: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceMemoryProperties2),
    pub vkGetPhysicalDeviceSparseImageFormatProperties2: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceSparseImageFormatInfo2, *mut u32, *mut RawVkSparseImageFormatProperties2),
    pub vkTrimCommandPool: unsafe extern fn(RawVkDevice, RawVkCommandPool, RawVkCommandPoolTrimFlags),
    pub vkGetDeviceQueue2: unsafe extern fn(RawVkDevice, *mut RawVkDeviceQueueInfo2, *mut RawVkQueue),
    pub vkCreateSamplerYcbcrConversion: unsafe extern fn(RawVkDevice, *mut RawVkSamplerYcbcrConversionCreateInfo, *const c_void, *mut RawVkSamplerYcbcrConversion) -> RawVkResult,
    pub vkDestroySamplerYcbcrConversion: unsafe extern fn(RawVkDevice, RawVkSamplerYcbcrConversion, *const c_void),
    pub vkCreateDescriptorUpdateTemplate: unsafe extern fn(RawVkDevice, *mut RawVkDescriptorUpdateTemplateCreateInfo, *const c_void, *mut RawVkDescriptorUpdateTemplate) -> RawVkResult,
    pub vkDestroyDescriptorUpdateTemplate: unsafe extern fn(RawVkDevice, RawVkDescriptorUpdateTemplate, *const c_void),
    pub vkUpdateDescriptorSetWithTemplate: unsafe extern fn(RawVkDevice, RawVkDescriptorSet, RawVkDescriptorUpdateTemplate, *const c_void),
    pub vkGetPhysicalDeviceExternalBufferProperties: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceExternalBufferInfo, *mut RawVkExternalBufferProperties),
    pub vkGetPhysicalDeviceExternalFenceProperties: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceExternalFenceInfo, *mut RawVkExternalFenceProperties),
    pub vkGetPhysicalDeviceExternalSemaphoreProperties: unsafe extern fn(RawVkPhysicalDevice, *mut RawVkPhysicalDeviceExternalSemaphoreInfo, *mut RawVkExternalSemaphoreProperties),
    pub vkGetDescriptorSetLayoutSupport: unsafe extern fn(RawVkDevice, *mut RawVkDescriptorSetLayoutCreateInfo, *mut RawVkDescriptorSetLayoutSupport),
    pub vkDestroySurfaceKHR: unsafe extern fn(RawVkInstance, khr::RawVkSurface, *const c_void),
    pub vkGetPhysicalDeviceSurfaceSupportKHR: unsafe extern fn(RawVkPhysicalDevice, u32, khr::RawVkSurface, *mut u32) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfaceCapabilitiesKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkSurface, *mut khr::RawVkSurfaceCapabilities) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfaceFormatsKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkSurface, *mut u32, *mut khr::RawVkSurfaceFormat) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfacePresentModesKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkSurface, *mut u32, *mut khr::RawVkPresentMode) -> RawVkResult,
    pub vkCreateSwapchainKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkSwapchainCreateInfo, *const c_void, *mut khr::RawVkSwapchain) -> RawVkResult,
    pub vkDestroySwapchainKHR: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, *const c_void),
    pub vkGetSwapchainImagesKHR: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, *mut u32, *mut RawVkImage) -> RawVkResult,
    pub vkAcquireNextImageKHR: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, u64, RawVkSemaphore, RawVkFence, *mut u32) -> RawVkResult,
    pub vkQueuePresentKHR: unsafe extern fn(RawVkQueue, *mut khr::RawVkPresentInfo) -> RawVkResult,
    pub vkGetDeviceGroupPresentCapabilitiesKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkDeviceGroupPresentCapabilities) -> RawVkResult,
    pub vkGetDeviceGroupSurfacePresentModesKHR: unsafe extern fn(RawVkDevice, khr::RawVkSurface, *mut khr::RawVkDeviceGroupPresentModeFlags) -> RawVkResult,
    pub vkGetPhysicalDevicePresentRectanglesKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkSurface, *mut u32, *mut RawVkRect2D) -> RawVkResult,
    pub vkAcquireNextImage2KHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkAcquireNextImageInfo, *mut u32) -> RawVkResult,
    pub vkGetPhysicalDeviceDisplayPropertiesKHR: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut khr::RawVkDisplayProperties) -> RawVkResult,
    pub vkGetPhysicalDeviceDisplayPlanePropertiesKHR: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut khr::RawVkDisplayPlaneProperties) -> RawVkResult,
    pub vkGetDisplayPlaneSupportedDisplaysKHR: unsafe extern fn(RawVkPhysicalDevice, u32, *mut u32, *mut khr::RawVkDisplay) -> RawVkResult,
    pub vkGetDisplayModePropertiesKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkDisplay, *mut u32, *mut khr::RawVkDisplayModeProperties) -> RawVkResult,
    pub vkCreateDisplayModeKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkDisplay, *mut khr::RawVkDisplayModeCreateInfo, *const c_void, *mut khr::RawVkDisplayMode) -> RawVkResult,
    pub vkGetDisplayPlaneCapabilitiesKHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkDisplayMode, u32, *mut khr::RawVkDisplayPlaneCapabilities) -> RawVkResult,
    pub vkCreateDisplayPlaneSurfaceKHR: unsafe extern fn(RawVkInstance, *mut khr::RawVkDisplaySurfaceCreateInfo, *const c_void, *mut khr::RawVkSurface) -> RawVkResult,
    pub vkCreateSharedSwapchainsKHR: unsafe extern fn(RawVkDevice, u32, *mut khr::RawVkSwapchainCreateInfo, *const c_void, *mut khr::RawVkSwapchain) -> RawVkResult,
    pub vkGetMemoryFdKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkMemoryGetFdInfo, *mut i32) -> RawVkResult,
    pub vkGetMemoryFdPropertiesKHR: unsafe extern fn(RawVkDevice, RawVkExternalMemoryHandleTypeFlags, i32, *mut khr::RawVkMemoryFdProperties) -> RawVkResult,
    pub vkImportSemaphoreFdKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkImportSemaphoreFdInfo) -> RawVkResult,
    pub vkGetSemaphoreFdKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkSemaphoreGetFdInfo, *mut i32) -> RawVkResult,
    pub vkCmdPushDescriptorSetKHR: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineBindPoint, RawVkPipelineLayout, u32, u32, *mut RawVkWriteDescriptorSet),
    pub vkCmdPushDescriptorSetWithTemplateKHR: unsafe extern fn(RawVkCommandBuffer, RawVkDescriptorUpdateTemplate, RawVkPipelineLayout, u32, *const c_void),
    pub vkCreateRenderPass2KHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkRenderPassCreateInfo2, *const c_void, *mut RawVkRenderPass) -> RawVkResult,
    pub vkCmdBeginRenderPass2KHR: unsafe extern fn(RawVkCommandBuffer, *mut RawVkRenderPassBeginInfo, *mut khr::RawVkSubpassBeginInfo),
    pub vkCmdNextSubpass2KHR: unsafe extern fn(RawVkCommandBuffer, *mut khr::RawVkSubpassBeginInfo, *mut khr::RawVkSubpassEndInfo),
    pub vkCmdEndRenderPass2KHR: unsafe extern fn(RawVkCommandBuffer, *mut khr::RawVkSubpassEndInfo),
    pub vkGetSwapchainStatusKHR: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain) -> RawVkResult,
    pub vkImportFenceFdKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkImportFenceFdInfo) -> RawVkResult,
    pub vkGetFenceFdKHR: unsafe extern fn(RawVkDevice, *mut khr::RawVkFenceGetFdInfo, *mut i32) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfaceCapabilities2KHR: unsafe extern fn(RawVkPhysicalDevice, *mut khr::RawVkPhysicalDeviceSurfaceInfo2, *mut khr::RawVkSurfaceCapabilities2) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfaceFormats2KHR: unsafe extern fn(RawVkPhysicalDevice, *mut khr::RawVkPhysicalDeviceSurfaceInfo2, *mut u32, *mut khr::RawVkSurfaceFormat2) -> RawVkResult,
    pub vkGetPhysicalDeviceDisplayProperties2KHR: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut khr::RawVkDisplayProperties2) -> RawVkResult,
    pub vkGetPhysicalDeviceDisplayPlaneProperties2KHR: unsafe extern fn(RawVkPhysicalDevice, *mut u32, *mut khr::RawVkDisplayPlaneProperties2) -> RawVkResult,
    pub vkGetDisplayModeProperties2KHR: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkDisplay, *mut u32, *mut khr::RawVkDisplayModeProperties2) -> RawVkResult,
    pub vkGetDisplayPlaneCapabilities2KHR: unsafe extern fn(RawVkPhysicalDevice, *mut khr::RawVkDisplayPlaneInfo2, *mut khr::RawVkDisplayPlaneCapabilities2) -> RawVkResult,
    pub vkCmdDrawIndirectCountKHR: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, RawVkBuffer, u64, u32, u32),
    pub vkCmdDrawIndexedIndirectCountKHR: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, RawVkBuffer, u64, u32, u32),
    pub vkCreateDebugReportCallbackEXT: unsafe extern fn(RawVkInstance, *mut ext::RawVkDebugReportCallbackCreateInfo, *const c_void, *mut ext::RawVkDebugReportCallback) -> RawVkResult,
    pub vkDestroyDebugReportCallbackEXT: unsafe extern fn(RawVkInstance, ext::RawVkDebugReportCallback, *const c_void),
    pub vkDebugReportMessageEXT: unsafe extern fn(RawVkInstance, ext::RawVkDebugReportFlags, ext::RawVkDebugReportObjectType, u64, usize, i32, *mut c_char, *mut c_char),
    pub vkDebugMarkerSetObjectTagEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkDebugMarkerObjectTagInfo) -> RawVkResult,
    pub vkDebugMarkerSetObjectNameEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkDebugMarkerObjectNameInfo) -> RawVkResult,
    pub vkCmdDebugMarkerBeginEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkDebugMarkerMarkerInfo),
    pub vkCmdDebugMarkerEndEXT: unsafe extern fn(RawVkCommandBuffer),
    pub vkCmdDebugMarkerInsertEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkDebugMarkerMarkerInfo),
    pub vkCmdDrawIndirectCountAMD: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, RawVkBuffer, u64, u32, u32),
    pub vkCmdDrawIndexedIndirectCountAMD: unsafe extern fn(RawVkCommandBuffer, RawVkBuffer, u64, RawVkBuffer, u64, u32, u32),
    pub vkGetShaderInfoAMD: unsafe extern fn(RawVkDevice, RawVkPipeline, RawVkShaderStageFlags, amd::RawVkShaderInfoType, *mut usize, *mut c_void) -> RawVkResult,
    pub vkGetPhysicalDeviceExternalImageFormatPropertiesNV: unsafe extern fn(RawVkPhysicalDevice, RawVkFormat, RawVkImageType, RawVkImageTiling, RawVkImageUsageFlags, RawVkImageCreateFlags, nv::RawVkExternalMemoryHandleTypeFlags, *mut nv::RawVkExternalImageFormatProperties) -> RawVkResult,
    pub vkCmdBeginConditionalRenderingEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkConditionalRenderingBeginInfo),
    pub vkCmdEndConditionalRenderingEXT: unsafe extern fn(RawVkCommandBuffer),
    pub vkCmdProcessCommandsNVX: unsafe extern fn(RawVkCommandBuffer, *mut nvx::RawVkCmdProcessCommandsInfo),
    pub vkCmdReserveSpaceForCommandsNVX: unsafe extern fn(RawVkCommandBuffer, *mut nvx::RawVkCmdReserveSpaceForCommandsInfo),
    pub vkCreateIndirectCommandsLayoutNVX: unsafe extern fn(RawVkDevice, *mut nvx::RawVkIndirectCommandsLayoutCreateInfo, *const c_void, *mut nvx::RawVkIndirectCommandsLayout) -> RawVkResult,
    pub vkDestroyIndirectCommandsLayoutNVX: unsafe extern fn(RawVkDevice, nvx::RawVkIndirectCommandsLayout, *const c_void),
    pub vkCreateObjectTableNVX: unsafe extern fn(RawVkDevice, *mut nvx::RawVkObjectTableCreateInfo, *const c_void, *mut nvx::RawVkObjectTable) -> RawVkResult,
    pub vkDestroyObjectTableNVX: unsafe extern fn(RawVkDevice, nvx::RawVkObjectTable, *const c_void),
    pub vkRegisterObjectsNVX: unsafe extern fn(RawVkDevice, nvx::RawVkObjectTable, u32, *mut *mut nvx::RawVkObjectTableEntry, *mut u32) -> RawVkResult,
    pub vkUnregisterObjectsNVX: unsafe extern fn(RawVkDevice, nvx::RawVkObjectTable, u32, *mut nvx::RawVkObjectEntryType, *mut u32) -> RawVkResult,
    pub vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX: unsafe extern fn(RawVkPhysicalDevice, *mut nvx::RawVkDeviceGeneratedCommandsFeatures, *mut nvx::RawVkDeviceGeneratedCommandsLimits),
    pub vkCmdSetViewportWScalingNV: unsafe extern fn(RawVkCommandBuffer, u32, u32, *mut nv::RawVkViewportWScaling),
    pub vkReleaseDisplayEXT: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkDisplay) -> RawVkResult,
    pub vkGetPhysicalDeviceSurfaceCapabilities2EXT: unsafe extern fn(RawVkPhysicalDevice, khr::RawVkSurface, *mut ext::RawVkSurfaceCapabilities2) -> RawVkResult,
    pub vkDisplayPowerControlEXT: unsafe extern fn(RawVkDevice, khr::RawVkDisplay, *mut ext::RawVkDisplayPowerInfo) -> RawVkResult,
    pub vkRegisterDeviceEventEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkDeviceEventInfo, *const c_void, *mut RawVkFence) -> RawVkResult,
    pub vkRegisterDisplayEventEXT: unsafe extern fn(RawVkDevice, khr::RawVkDisplay, *mut ext::RawVkDisplayEventInfo, *const c_void, *mut RawVkFence) -> RawVkResult,
    pub vkGetSwapchainCounterEXT: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, ext::RawVkSurfaceCounterFlags, *mut u64) -> RawVkResult,
    pub vkGetRefreshCycleDurationGOOGLE: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, *mut google::RawVkRefreshCycleDuration) -> RawVkResult,
    pub vkGetPastPresentationTimingGOOGLE: unsafe extern fn(RawVkDevice, khr::RawVkSwapchain, *mut u32, *mut google::RawVkPastPresentationTiming) -> RawVkResult,
    pub vkCmdSetDiscardRectangleEXT: unsafe extern fn(RawVkCommandBuffer, u32, u32, *mut RawVkRect2D),
    pub vkSetHdrMetadataEXT: unsafe extern fn(RawVkDevice, u32, *mut khr::RawVkSwapchain, *mut ext::RawVkHdrMetadata),
    pub vkSetDebugUtilsObjectNameEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkDebugUtilsObjectNameInfo) -> RawVkResult,
    pub vkSetDebugUtilsObjectTagEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkDebugUtilsObjectTagInfo) -> RawVkResult,
    pub vkQueueBeginDebugUtilsLabelEXT: unsafe extern fn(RawVkQueue, *mut ext::RawVkDebugUtilsLabel),
    pub vkQueueEndDebugUtilsLabelEXT: unsafe extern fn(RawVkQueue),
    pub vkQueueInsertDebugUtilsLabelEXT: unsafe extern fn(RawVkQueue, *mut ext::RawVkDebugUtilsLabel),
    pub vkCmdBeginDebugUtilsLabelEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkDebugUtilsLabel),
    pub vkCmdEndDebugUtilsLabelEXT: unsafe extern fn(RawVkCommandBuffer),
    pub vkCmdInsertDebugUtilsLabelEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkDebugUtilsLabel),
    pub vkCreateDebugUtilsMessengerEXT: unsafe extern fn(RawVkInstance, *mut ext::RawVkDebugUtilsMessengerCreateInfo, *const c_void, *mut ext::RawVkDebugUtilsMessenger) -> RawVkResult,
    pub vkDestroyDebugUtilsMessengerEXT: unsafe extern fn(RawVkInstance, ext::RawVkDebugUtilsMessenger, *const c_void),
    pub vkSubmitDebugUtilsMessageEXT: unsafe extern fn(RawVkInstance, ext::RawVkDebugUtilsMessageSeverityFlags, ext::RawVkDebugUtilsMessageTypeFlags, *mut ext::RawVkDebugUtilsMessengerCallbackData),
    pub vkCmdSetSampleLocationsEXT: unsafe extern fn(RawVkCommandBuffer, *mut ext::RawVkSampleLocationsInfo),
    pub vkGetPhysicalDeviceMultisamplePropertiesEXT: unsafe extern fn(RawVkPhysicalDevice, RawVkSampleCountFlags, *mut ext::RawVkMultisampleProperties),
    pub vkCreateValidationCacheEXT: unsafe extern fn(RawVkDevice, *mut ext::RawVkValidationCacheCreateInfo, *const c_void, *mut ext::RawVkValidationCache) -> RawVkResult,
    pub vkDestroyValidationCacheEXT: unsafe extern fn(RawVkDevice, ext::RawVkValidationCache, *const c_void),
    pub vkMergeValidationCachesEXT: unsafe extern fn(RawVkDevice, ext::RawVkValidationCache, u32, *mut ext::RawVkValidationCache) -> RawVkResult,
    pub vkGetValidationCacheDataEXT: unsafe extern fn(RawVkDevice, ext::RawVkValidationCache, *mut usize, *mut c_void) -> RawVkResult,
    pub vkGetMemoryHostPointerPropertiesEXT: unsafe extern fn(RawVkDevice, RawVkExternalMemoryHandleTypeFlags, *const c_void, *mut ext::RawVkMemoryHostPointerProperties) -> RawVkResult,
    pub vkCmdWriteBufferMarkerAMD: unsafe extern fn(RawVkCommandBuffer, RawVkPipelineStageFlags, RawVkBuffer, u64, u32),
    pub vkCmdSetCheckpointNV: unsafe extern fn(RawVkCommandBuffer, *const c_void),
    pub vkGetQueueCheckpointDataNV: unsafe extern fn(RawVkQueue, *mut u32, *mut nv::RawVkCheckpointData),
}

impl VkInstanceFunctionTable {
    pub fn new(instance: RawVkInstance) -> Self {
        unsafe {
            Self {
                vkDestroyInstance: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyInstance"); if fn_ptr.is_null() { null_vkDestroyInstance } else { mem::transmute(fn_ptr) } },
                vkEnumeratePhysicalDevices: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkEnumeratePhysicalDevices"); if fn_ptr.is_null() { null_vkEnumeratePhysicalDevices } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceFeatures: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceFeatures"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceFeatures } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceFormatProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceFormatProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceFormatProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceImageFormatProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceImageFormatProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceImageFormatProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceQueueFamilyProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceQueueFamilyProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceQueueFamilyProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceMemoryProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceMemoryProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceMemoryProperties } else { mem::transmute(fn_ptr) } },
                vkCreateDevice: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDevice"); if fn_ptr.is_null() { null_vkCreateDevice } else { mem::transmute(fn_ptr) } },
                vkDestroyDevice: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDevice"); if fn_ptr.is_null() { null_vkDestroyDevice } else { mem::transmute(fn_ptr) } },
                vkEnumerateDeviceExtensionProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkEnumerateDeviceExtensionProperties"); if fn_ptr.is_null() { null_vkEnumerateDeviceExtensionProperties } else { mem::transmute(fn_ptr) } },
                vkEnumerateDeviceLayerProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkEnumerateDeviceLayerProperties"); if fn_ptr.is_null() { null_vkEnumerateDeviceLayerProperties } else { mem::transmute(fn_ptr) } },
                vkGetDeviceQueue: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceQueue"); if fn_ptr.is_null() { null_vkGetDeviceQueue } else { mem::transmute(fn_ptr) } },
                vkQueueSubmit: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueSubmit"); if fn_ptr.is_null() { null_vkQueueSubmit } else { mem::transmute(fn_ptr) } },
                vkQueueWaitIdle: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueWaitIdle"); if fn_ptr.is_null() { null_vkQueueWaitIdle } else { mem::transmute(fn_ptr) } },
                vkDeviceWaitIdle: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDeviceWaitIdle"); if fn_ptr.is_null() { null_vkDeviceWaitIdle } else { mem::transmute(fn_ptr) } },
                vkAllocateMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkAllocateMemory"); if fn_ptr.is_null() { null_vkAllocateMemory } else { mem::transmute(fn_ptr) } },
                vkFreeMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkFreeMemory"); if fn_ptr.is_null() { null_vkFreeMemory } else { mem::transmute(fn_ptr) } },
                vkMapMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkMapMemory"); if fn_ptr.is_null() { null_vkMapMemory } else { mem::transmute(fn_ptr) } },
                vkUnmapMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkUnmapMemory"); if fn_ptr.is_null() { null_vkUnmapMemory } else { mem::transmute(fn_ptr) } },
                vkFlushMappedMemoryRanges: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkFlushMappedMemoryRanges"); if fn_ptr.is_null() { null_vkFlushMappedMemoryRanges } else { mem::transmute(fn_ptr) } },
                vkInvalidateMappedMemoryRanges: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkInvalidateMappedMemoryRanges"); if fn_ptr.is_null() { null_vkInvalidateMappedMemoryRanges } else { mem::transmute(fn_ptr) } },
                vkGetDeviceMemoryCommitment: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceMemoryCommitment"); if fn_ptr.is_null() { null_vkGetDeviceMemoryCommitment } else { mem::transmute(fn_ptr) } },
                vkBindBufferMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkBindBufferMemory"); if fn_ptr.is_null() { null_vkBindBufferMemory } else { mem::transmute(fn_ptr) } },
                vkBindImageMemory: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkBindImageMemory"); if fn_ptr.is_null() { null_vkBindImageMemory } else { mem::transmute(fn_ptr) } },
                vkGetBufferMemoryRequirements: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetBufferMemoryRequirements"); if fn_ptr.is_null() { null_vkGetBufferMemoryRequirements } else { mem::transmute(fn_ptr) } },
                vkGetImageMemoryRequirements: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetImageMemoryRequirements"); if fn_ptr.is_null() { null_vkGetImageMemoryRequirements } else { mem::transmute(fn_ptr) } },
                vkGetImageSparseMemoryRequirements: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetImageSparseMemoryRequirements"); if fn_ptr.is_null() { null_vkGetImageSparseMemoryRequirements } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSparseImageFormatProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSparseImageFormatProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSparseImageFormatProperties } else { mem::transmute(fn_ptr) } },
                vkQueueBindSparse: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueBindSparse"); if fn_ptr.is_null() { null_vkQueueBindSparse } else { mem::transmute(fn_ptr) } },
                vkCreateFence: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateFence"); if fn_ptr.is_null() { null_vkCreateFence } else { mem::transmute(fn_ptr) } },
                vkDestroyFence: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyFence"); if fn_ptr.is_null() { null_vkDestroyFence } else { mem::transmute(fn_ptr) } },
                vkResetFences: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkResetFences"); if fn_ptr.is_null() { null_vkResetFences } else { mem::transmute(fn_ptr) } },
                vkGetFenceStatus: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetFenceStatus"); if fn_ptr.is_null() { null_vkGetFenceStatus } else { mem::transmute(fn_ptr) } },
                vkWaitForFences: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkWaitForFences"); if fn_ptr.is_null() { null_vkWaitForFences } else { mem::transmute(fn_ptr) } },
                vkCreateSemaphore: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateSemaphore"); if fn_ptr.is_null() { null_vkCreateSemaphore } else { mem::transmute(fn_ptr) } },
                vkDestroySemaphore: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroySemaphore"); if fn_ptr.is_null() { null_vkDestroySemaphore } else { mem::transmute(fn_ptr) } },
                vkCreateEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateEvent"); if fn_ptr.is_null() { null_vkCreateEvent } else { mem::transmute(fn_ptr) } },
                vkDestroyEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyEvent"); if fn_ptr.is_null() { null_vkDestroyEvent } else { mem::transmute(fn_ptr) } },
                vkGetEventStatus: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetEventStatus"); if fn_ptr.is_null() { null_vkGetEventStatus } else { mem::transmute(fn_ptr) } },
                vkSetEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkSetEvent"); if fn_ptr.is_null() { null_vkSetEvent } else { mem::transmute(fn_ptr) } },
                vkResetEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkResetEvent"); if fn_ptr.is_null() { null_vkResetEvent } else { mem::transmute(fn_ptr) } },
                vkCreateQueryPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateQueryPool"); if fn_ptr.is_null() { null_vkCreateQueryPool } else { mem::transmute(fn_ptr) } },
                vkDestroyQueryPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyQueryPool"); if fn_ptr.is_null() { null_vkDestroyQueryPool } else { mem::transmute(fn_ptr) } },
                vkGetQueryPoolResults: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetQueryPoolResults"); if fn_ptr.is_null() { null_vkGetQueryPoolResults } else { mem::transmute(fn_ptr) } },
                vkCreateBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateBuffer"); if fn_ptr.is_null() { null_vkCreateBuffer } else { mem::transmute(fn_ptr) } },
                vkDestroyBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyBuffer"); if fn_ptr.is_null() { null_vkDestroyBuffer } else { mem::transmute(fn_ptr) } },
                vkCreateBufferView: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateBufferView"); if fn_ptr.is_null() { null_vkCreateBufferView } else { mem::transmute(fn_ptr) } },
                vkDestroyBufferView: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyBufferView"); if fn_ptr.is_null() { null_vkDestroyBufferView } else { mem::transmute(fn_ptr) } },
                vkCreateImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateImage"); if fn_ptr.is_null() { null_vkCreateImage } else { mem::transmute(fn_ptr) } },
                vkDestroyImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyImage"); if fn_ptr.is_null() { null_vkDestroyImage } else { mem::transmute(fn_ptr) } },
                vkGetImageSubresourceLayout: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetImageSubresourceLayout"); if fn_ptr.is_null() { null_vkGetImageSubresourceLayout } else { mem::transmute(fn_ptr) } },
                vkCreateImageView: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateImageView"); if fn_ptr.is_null() { null_vkCreateImageView } else { mem::transmute(fn_ptr) } },
                vkDestroyImageView: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyImageView"); if fn_ptr.is_null() { null_vkDestroyImageView } else { mem::transmute(fn_ptr) } },
                vkCreateShaderModule: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateShaderModule"); if fn_ptr.is_null() { null_vkCreateShaderModule } else { mem::transmute(fn_ptr) } },
                vkDestroyShaderModule: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyShaderModule"); if fn_ptr.is_null() { null_vkDestroyShaderModule } else { mem::transmute(fn_ptr) } },
                vkCreatePipelineCache: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreatePipelineCache"); if fn_ptr.is_null() { null_vkCreatePipelineCache } else { mem::transmute(fn_ptr) } },
                vkDestroyPipelineCache: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyPipelineCache"); if fn_ptr.is_null() { null_vkDestroyPipelineCache } else { mem::transmute(fn_ptr) } },
                vkGetPipelineCacheData: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPipelineCacheData"); if fn_ptr.is_null() { null_vkGetPipelineCacheData } else { mem::transmute(fn_ptr) } },
                vkMergePipelineCaches: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkMergePipelineCaches"); if fn_ptr.is_null() { null_vkMergePipelineCaches } else { mem::transmute(fn_ptr) } },
                vkCreateGraphicsPipelines: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateGraphicsPipelines"); if fn_ptr.is_null() { null_vkCreateGraphicsPipelines } else { mem::transmute(fn_ptr) } },
                vkCreateComputePipelines: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateComputePipelines"); if fn_ptr.is_null() { null_vkCreateComputePipelines } else { mem::transmute(fn_ptr) } },
                vkDestroyPipeline: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyPipeline"); if fn_ptr.is_null() { null_vkDestroyPipeline } else { mem::transmute(fn_ptr) } },
                vkCreatePipelineLayout: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreatePipelineLayout"); if fn_ptr.is_null() { null_vkCreatePipelineLayout } else { mem::transmute(fn_ptr) } },
                vkDestroyPipelineLayout: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyPipelineLayout"); if fn_ptr.is_null() { null_vkDestroyPipelineLayout } else { mem::transmute(fn_ptr) } },
                vkCreateSampler: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateSampler"); if fn_ptr.is_null() { null_vkCreateSampler } else { mem::transmute(fn_ptr) } },
                vkDestroySampler: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroySampler"); if fn_ptr.is_null() { null_vkDestroySampler } else { mem::transmute(fn_ptr) } },
                vkCreateDescriptorSetLayout: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDescriptorSetLayout"); if fn_ptr.is_null() { null_vkCreateDescriptorSetLayout } else { mem::transmute(fn_ptr) } },
                vkDestroyDescriptorSetLayout: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDescriptorSetLayout"); if fn_ptr.is_null() { null_vkDestroyDescriptorSetLayout } else { mem::transmute(fn_ptr) } },
                vkCreateDescriptorPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDescriptorPool"); if fn_ptr.is_null() { null_vkCreateDescriptorPool } else { mem::transmute(fn_ptr) } },
                vkDestroyDescriptorPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDescriptorPool"); if fn_ptr.is_null() { null_vkDestroyDescriptorPool } else { mem::transmute(fn_ptr) } },
                vkResetDescriptorPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkResetDescriptorPool"); if fn_ptr.is_null() { null_vkResetDescriptorPool } else { mem::transmute(fn_ptr) } },
                vkAllocateDescriptorSets: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkAllocateDescriptorSets"); if fn_ptr.is_null() { null_vkAllocateDescriptorSets } else { mem::transmute(fn_ptr) } },
                vkFreeDescriptorSets: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkFreeDescriptorSets"); if fn_ptr.is_null() { null_vkFreeDescriptorSets } else { mem::transmute(fn_ptr) } },
                vkUpdateDescriptorSets: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkUpdateDescriptorSets"); if fn_ptr.is_null() { null_vkUpdateDescriptorSets } else { mem::transmute(fn_ptr) } },
                vkCreateFramebuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateFramebuffer"); if fn_ptr.is_null() { null_vkCreateFramebuffer } else { mem::transmute(fn_ptr) } },
                vkDestroyFramebuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyFramebuffer"); if fn_ptr.is_null() { null_vkDestroyFramebuffer } else { mem::transmute(fn_ptr) } },
                vkCreateRenderPass: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateRenderPass"); if fn_ptr.is_null() { null_vkCreateRenderPass } else { mem::transmute(fn_ptr) } },
                vkDestroyRenderPass: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyRenderPass"); if fn_ptr.is_null() { null_vkDestroyRenderPass } else { mem::transmute(fn_ptr) } },
                vkGetRenderAreaGranularity: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetRenderAreaGranularity"); if fn_ptr.is_null() { null_vkGetRenderAreaGranularity } else { mem::transmute(fn_ptr) } },
                vkCreateCommandPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateCommandPool"); if fn_ptr.is_null() { null_vkCreateCommandPool } else { mem::transmute(fn_ptr) } },
                vkDestroyCommandPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyCommandPool"); if fn_ptr.is_null() { null_vkDestroyCommandPool } else { mem::transmute(fn_ptr) } },
                vkResetCommandPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkResetCommandPool"); if fn_ptr.is_null() { null_vkResetCommandPool } else { mem::transmute(fn_ptr) } },
                vkAllocateCommandBuffers: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkAllocateCommandBuffers"); if fn_ptr.is_null() { null_vkAllocateCommandBuffers } else { mem::transmute(fn_ptr) } },
                vkFreeCommandBuffers: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkFreeCommandBuffers"); if fn_ptr.is_null() { null_vkFreeCommandBuffers } else { mem::transmute(fn_ptr) } },
                vkBeginCommandBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkBeginCommandBuffer"); if fn_ptr.is_null() { null_vkBeginCommandBuffer } else { mem::transmute(fn_ptr) } },
                vkEndCommandBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkEndCommandBuffer"); if fn_ptr.is_null() { null_vkEndCommandBuffer } else { mem::transmute(fn_ptr) } },
                vkResetCommandBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkResetCommandBuffer"); if fn_ptr.is_null() { null_vkResetCommandBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdBindPipeline: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBindPipeline"); if fn_ptr.is_null() { null_vkCmdBindPipeline } else { mem::transmute(fn_ptr) } },
                vkCmdSetViewport: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetViewport"); if fn_ptr.is_null() { null_vkCmdSetViewport } else { mem::transmute(fn_ptr) } },
                vkCmdSetScissor: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetScissor"); if fn_ptr.is_null() { null_vkCmdSetScissor } else { mem::transmute(fn_ptr) } },
                vkCmdSetLineWidth: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetLineWidth"); if fn_ptr.is_null() { null_vkCmdSetLineWidth } else { mem::transmute(fn_ptr) } },
                vkCmdSetDepthBias: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetDepthBias"); if fn_ptr.is_null() { null_vkCmdSetDepthBias } else { mem::transmute(fn_ptr) } },
                vkCmdSetBlendConstants: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetBlendConstants"); if fn_ptr.is_null() { null_vkCmdSetBlendConstants } else { mem::transmute(fn_ptr) } },
                vkCmdSetDepthBounds: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetDepthBounds"); if fn_ptr.is_null() { null_vkCmdSetDepthBounds } else { mem::transmute(fn_ptr) } },
                vkCmdSetStencilCompareMask: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetStencilCompareMask"); if fn_ptr.is_null() { null_vkCmdSetStencilCompareMask } else { mem::transmute(fn_ptr) } },
                vkCmdSetStencilWriteMask: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetStencilWriteMask"); if fn_ptr.is_null() { null_vkCmdSetStencilWriteMask } else { mem::transmute(fn_ptr) } },
                vkCmdSetStencilReference: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetStencilReference"); if fn_ptr.is_null() { null_vkCmdSetStencilReference } else { mem::transmute(fn_ptr) } },
                vkCmdBindDescriptorSets: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBindDescriptorSets"); if fn_ptr.is_null() { null_vkCmdBindDescriptorSets } else { mem::transmute(fn_ptr) } },
                vkCmdBindIndexBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBindIndexBuffer"); if fn_ptr.is_null() { null_vkCmdBindIndexBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdBindVertexBuffers: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBindVertexBuffers"); if fn_ptr.is_null() { null_vkCmdBindVertexBuffers } else { mem::transmute(fn_ptr) } },
                vkCmdDraw: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDraw"); if fn_ptr.is_null() { null_vkCmdDraw } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndexed: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndexed"); if fn_ptr.is_null() { null_vkCmdDrawIndexed } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndirect: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndirect"); if fn_ptr.is_null() { null_vkCmdDrawIndirect } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndexedIndirect: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndexedIndirect"); if fn_ptr.is_null() { null_vkCmdDrawIndexedIndirect } else { mem::transmute(fn_ptr) } },
                vkCmdDispatch: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDispatch"); if fn_ptr.is_null() { null_vkCmdDispatch } else { mem::transmute(fn_ptr) } },
                vkCmdDispatchIndirect: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDispatchIndirect"); if fn_ptr.is_null() { null_vkCmdDispatchIndirect } else { mem::transmute(fn_ptr) } },
                vkCmdCopyBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdCopyBuffer"); if fn_ptr.is_null() { null_vkCmdCopyBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdCopyImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdCopyImage"); if fn_ptr.is_null() { null_vkCmdCopyImage } else { mem::transmute(fn_ptr) } },
                vkCmdBlitImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBlitImage"); if fn_ptr.is_null() { null_vkCmdBlitImage } else { mem::transmute(fn_ptr) } },
                vkCmdCopyBufferToImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdCopyBufferToImage"); if fn_ptr.is_null() { null_vkCmdCopyBufferToImage } else { mem::transmute(fn_ptr) } },
                vkCmdCopyImageToBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdCopyImageToBuffer"); if fn_ptr.is_null() { null_vkCmdCopyImageToBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdUpdateBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdUpdateBuffer"); if fn_ptr.is_null() { null_vkCmdUpdateBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdFillBuffer: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdFillBuffer"); if fn_ptr.is_null() { null_vkCmdFillBuffer } else { mem::transmute(fn_ptr) } },
                vkCmdClearColorImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdClearColorImage"); if fn_ptr.is_null() { null_vkCmdClearColorImage } else { mem::transmute(fn_ptr) } },
                vkCmdClearDepthStencilImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdClearDepthStencilImage"); if fn_ptr.is_null() { null_vkCmdClearDepthStencilImage } else { mem::transmute(fn_ptr) } },
                vkCmdClearAttachments: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdClearAttachments"); if fn_ptr.is_null() { null_vkCmdClearAttachments } else { mem::transmute(fn_ptr) } },
                vkCmdResolveImage: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdResolveImage"); if fn_ptr.is_null() { null_vkCmdResolveImage } else { mem::transmute(fn_ptr) } },
                vkCmdSetEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetEvent"); if fn_ptr.is_null() { null_vkCmdSetEvent } else { mem::transmute(fn_ptr) } },
                vkCmdResetEvent: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdResetEvent"); if fn_ptr.is_null() { null_vkCmdResetEvent } else { mem::transmute(fn_ptr) } },
                vkCmdWaitEvents: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdWaitEvents"); if fn_ptr.is_null() { null_vkCmdWaitEvents } else { mem::transmute(fn_ptr) } },
                vkCmdPipelineBarrier: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdPipelineBarrier"); if fn_ptr.is_null() { null_vkCmdPipelineBarrier } else { mem::transmute(fn_ptr) } },
                vkCmdBeginQuery: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBeginQuery"); if fn_ptr.is_null() { null_vkCmdBeginQuery } else { mem::transmute(fn_ptr) } },
                vkCmdEndQuery: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdEndQuery"); if fn_ptr.is_null() { null_vkCmdEndQuery } else { mem::transmute(fn_ptr) } },
                vkCmdResetQueryPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdResetQueryPool"); if fn_ptr.is_null() { null_vkCmdResetQueryPool } else { mem::transmute(fn_ptr) } },
                vkCmdWriteTimestamp: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdWriteTimestamp"); if fn_ptr.is_null() { null_vkCmdWriteTimestamp } else { mem::transmute(fn_ptr) } },
                vkCmdCopyQueryPoolResults: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdCopyQueryPoolResults"); if fn_ptr.is_null() { null_vkCmdCopyQueryPoolResults } else { mem::transmute(fn_ptr) } },
                vkCmdPushConstants: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdPushConstants"); if fn_ptr.is_null() { null_vkCmdPushConstants } else { mem::transmute(fn_ptr) } },
                vkCmdBeginRenderPass: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBeginRenderPass"); if fn_ptr.is_null() { null_vkCmdBeginRenderPass } else { mem::transmute(fn_ptr) } },
                vkCmdNextSubpass: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdNextSubpass"); if fn_ptr.is_null() { null_vkCmdNextSubpass } else { mem::transmute(fn_ptr) } },
                vkCmdEndRenderPass: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdEndRenderPass"); if fn_ptr.is_null() { null_vkCmdEndRenderPass } else { mem::transmute(fn_ptr) } },
                vkCmdExecuteCommands: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdExecuteCommands"); if fn_ptr.is_null() { null_vkCmdExecuteCommands } else { mem::transmute(fn_ptr) } },
                vkBindBufferMemory2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkBindBufferMemory2"); if fn_ptr.is_null() { null_vkBindBufferMemory2 } else { mem::transmute(fn_ptr) } },
                vkBindImageMemory2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkBindImageMemory2"); if fn_ptr.is_null() { null_vkBindImageMemory2 } else { mem::transmute(fn_ptr) } },
                vkGetDeviceGroupPeerMemoryFeatures: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceGroupPeerMemoryFeatures"); if fn_ptr.is_null() { null_vkGetDeviceGroupPeerMemoryFeatures } else { mem::transmute(fn_ptr) } },
                vkCmdSetDeviceMask: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetDeviceMask"); if fn_ptr.is_null() { null_vkCmdSetDeviceMask } else { mem::transmute(fn_ptr) } },
                vkCmdDispatchBase: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDispatchBase"); if fn_ptr.is_null() { null_vkCmdDispatchBase } else { mem::transmute(fn_ptr) } },
                vkEnumeratePhysicalDeviceGroups: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkEnumeratePhysicalDeviceGroups"); if fn_ptr.is_null() { null_vkEnumeratePhysicalDeviceGroups } else { mem::transmute(fn_ptr) } },
                vkGetImageMemoryRequirements2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetImageMemoryRequirements2"); if fn_ptr.is_null() { null_vkGetImageMemoryRequirements2 } else { mem::transmute(fn_ptr) } },
                vkGetBufferMemoryRequirements2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetBufferMemoryRequirements2"); if fn_ptr.is_null() { null_vkGetBufferMemoryRequirements2 } else { mem::transmute(fn_ptr) } },
                vkGetImageSparseMemoryRequirements2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetImageSparseMemoryRequirements2"); if fn_ptr.is_null() { null_vkGetImageSparseMemoryRequirements2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceFeatures2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceFeatures2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceFeatures2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceProperties2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceFormatProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceFormatProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceFormatProperties2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceImageFormatProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceImageFormatProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceImageFormatProperties2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceQueueFamilyProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceQueueFamilyProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceQueueFamilyProperties2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceMemoryProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceMemoryProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceMemoryProperties2 } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSparseImageFormatProperties2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSparseImageFormatProperties2 } else { mem::transmute(fn_ptr) } },
                vkTrimCommandPool: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkTrimCommandPool"); if fn_ptr.is_null() { null_vkTrimCommandPool } else { mem::transmute(fn_ptr) } },
                vkGetDeviceQueue2: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceQueue2"); if fn_ptr.is_null() { null_vkGetDeviceQueue2 } else { mem::transmute(fn_ptr) } },
                vkCreateSamplerYcbcrConversion: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateSamplerYcbcrConversion"); if fn_ptr.is_null() { null_vkCreateSamplerYcbcrConversion } else { mem::transmute(fn_ptr) } },
                vkDestroySamplerYcbcrConversion: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroySamplerYcbcrConversion"); if fn_ptr.is_null() { null_vkDestroySamplerYcbcrConversion } else { mem::transmute(fn_ptr) } },
                vkCreateDescriptorUpdateTemplate: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDescriptorUpdateTemplate"); if fn_ptr.is_null() { null_vkCreateDescriptorUpdateTemplate } else { mem::transmute(fn_ptr) } },
                vkDestroyDescriptorUpdateTemplate: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDescriptorUpdateTemplate"); if fn_ptr.is_null() { null_vkDestroyDescriptorUpdateTemplate } else { mem::transmute(fn_ptr) } },
                vkUpdateDescriptorSetWithTemplate: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkUpdateDescriptorSetWithTemplate"); if fn_ptr.is_null() { null_vkUpdateDescriptorSetWithTemplate } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceExternalBufferProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceExternalBufferProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceExternalBufferProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceExternalFenceProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceExternalFenceProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceExternalFenceProperties } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceExternalSemaphoreProperties: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceExternalSemaphoreProperties } else { mem::transmute(fn_ptr) } },
                vkGetDescriptorSetLayoutSupport: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDescriptorSetLayoutSupport"); if fn_ptr.is_null() { null_vkGetDescriptorSetLayoutSupport } else { mem::transmute(fn_ptr) } },
                vkDestroySurfaceKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroySurfaceKHR"); if fn_ptr.is_null() { null_vkDestroySurfaceKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceSupportKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceSupportKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceSupportKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceCapabilitiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceCapabilitiesKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceFormatsKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceFormatsKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfacePresentModesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfacePresentModesKHR } else { mem::transmute(fn_ptr) } },
                vkCreateSwapchainKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateSwapchainKHR"); if fn_ptr.is_null() { null_vkCreateSwapchainKHR } else { mem::transmute(fn_ptr) } },
                vkDestroySwapchainKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroySwapchainKHR"); if fn_ptr.is_null() { null_vkDestroySwapchainKHR } else { mem::transmute(fn_ptr) } },
                vkGetSwapchainImagesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetSwapchainImagesKHR"); if fn_ptr.is_null() { null_vkGetSwapchainImagesKHR } else { mem::transmute(fn_ptr) } },
                vkAcquireNextImageKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkAcquireNextImageKHR"); if fn_ptr.is_null() { null_vkAcquireNextImageKHR } else { mem::transmute(fn_ptr) } },
                vkQueuePresentKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueuePresentKHR"); if fn_ptr.is_null() { null_vkQueuePresentKHR } else { mem::transmute(fn_ptr) } },
                vkGetDeviceGroupPresentCapabilitiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceGroupPresentCapabilitiesKHR"); if fn_ptr.is_null() { null_vkGetDeviceGroupPresentCapabilitiesKHR } else { mem::transmute(fn_ptr) } },
                vkGetDeviceGroupSurfacePresentModesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDeviceGroupSurfacePresentModesKHR"); if fn_ptr.is_null() { null_vkGetDeviceGroupSurfacePresentModesKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDevicePresentRectanglesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDevicePresentRectanglesKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDevicePresentRectanglesKHR } else { mem::transmute(fn_ptr) } },
                vkAcquireNextImage2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkAcquireNextImage2KHR"); if fn_ptr.is_null() { null_vkAcquireNextImage2KHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceDisplayPropertiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceDisplayPropertiesKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceDisplayPlanePropertiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceDisplayPlanePropertiesKHR } else { mem::transmute(fn_ptr) } },
                vkGetDisplayPlaneSupportedDisplaysKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDisplayPlaneSupportedDisplaysKHR"); if fn_ptr.is_null() { null_vkGetDisplayPlaneSupportedDisplaysKHR } else { mem::transmute(fn_ptr) } },
                vkGetDisplayModePropertiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDisplayModePropertiesKHR"); if fn_ptr.is_null() { null_vkGetDisplayModePropertiesKHR } else { mem::transmute(fn_ptr) } },
                vkCreateDisplayModeKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDisplayModeKHR"); if fn_ptr.is_null() { null_vkCreateDisplayModeKHR } else { mem::transmute(fn_ptr) } },
                vkGetDisplayPlaneCapabilitiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDisplayPlaneCapabilitiesKHR"); if fn_ptr.is_null() { null_vkGetDisplayPlaneCapabilitiesKHR } else { mem::transmute(fn_ptr) } },
                vkCreateDisplayPlaneSurfaceKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDisplayPlaneSurfaceKHR"); if fn_ptr.is_null() { null_vkCreateDisplayPlaneSurfaceKHR } else { mem::transmute(fn_ptr) } },
                vkCreateSharedSwapchainsKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateSharedSwapchainsKHR"); if fn_ptr.is_null() { null_vkCreateSharedSwapchainsKHR } else { mem::transmute(fn_ptr) } },
                vkGetMemoryFdKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetMemoryFdKHR"); if fn_ptr.is_null() { null_vkGetMemoryFdKHR } else { mem::transmute(fn_ptr) } },
                vkGetMemoryFdPropertiesKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetMemoryFdPropertiesKHR"); if fn_ptr.is_null() { null_vkGetMemoryFdPropertiesKHR } else { mem::transmute(fn_ptr) } },
                vkImportSemaphoreFdKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkImportSemaphoreFdKHR"); if fn_ptr.is_null() { null_vkImportSemaphoreFdKHR } else { mem::transmute(fn_ptr) } },
                vkGetSemaphoreFdKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetSemaphoreFdKHR"); if fn_ptr.is_null() { null_vkGetSemaphoreFdKHR } else { mem::transmute(fn_ptr) } },
                vkCmdPushDescriptorSetKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdPushDescriptorSetKHR"); if fn_ptr.is_null() { null_vkCmdPushDescriptorSetKHR } else { mem::transmute(fn_ptr) } },
                vkCmdPushDescriptorSetWithTemplateKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdPushDescriptorSetWithTemplateKHR"); if fn_ptr.is_null() { null_vkCmdPushDescriptorSetWithTemplateKHR } else { mem::transmute(fn_ptr) } },
                vkCreateRenderPass2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateRenderPass2KHR"); if fn_ptr.is_null() { null_vkCreateRenderPass2KHR } else { mem::transmute(fn_ptr) } },
                vkCmdBeginRenderPass2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBeginRenderPass2KHR"); if fn_ptr.is_null() { null_vkCmdBeginRenderPass2KHR } else { mem::transmute(fn_ptr) } },
                vkCmdNextSubpass2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdNextSubpass2KHR"); if fn_ptr.is_null() { null_vkCmdNextSubpass2KHR } else { mem::transmute(fn_ptr) } },
                vkCmdEndRenderPass2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdEndRenderPass2KHR"); if fn_ptr.is_null() { null_vkCmdEndRenderPass2KHR } else { mem::transmute(fn_ptr) } },
                vkGetSwapchainStatusKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetSwapchainStatusKHR"); if fn_ptr.is_null() { null_vkGetSwapchainStatusKHR } else { mem::transmute(fn_ptr) } },
                vkImportFenceFdKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkImportFenceFdKHR"); if fn_ptr.is_null() { null_vkImportFenceFdKHR } else { mem::transmute(fn_ptr) } },
                vkGetFenceFdKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetFenceFdKHR"); if fn_ptr.is_null() { null_vkGetFenceFdKHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceCapabilities2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceCapabilities2KHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceFormats2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceFormats2KHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceDisplayProperties2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceDisplayProperties2KHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceDisplayProperties2KHR } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceDisplayPlaneProperties2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceDisplayPlaneProperties2KHR } else { mem::transmute(fn_ptr) } },
                vkGetDisplayModeProperties2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDisplayModeProperties2KHR"); if fn_ptr.is_null() { null_vkGetDisplayModeProperties2KHR } else { mem::transmute(fn_ptr) } },
                vkGetDisplayPlaneCapabilities2KHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetDisplayPlaneCapabilities2KHR"); if fn_ptr.is_null() { null_vkGetDisplayPlaneCapabilities2KHR } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndirectCountKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndirectCountKHR"); if fn_ptr.is_null() { null_vkCmdDrawIndirectCountKHR } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndexedIndirectCountKHR: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndexedIndirectCountKHR"); if fn_ptr.is_null() { null_vkCmdDrawIndexedIndirectCountKHR } else { mem::transmute(fn_ptr) } },
                vkCreateDebugReportCallbackEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDebugReportCallbackEXT"); if fn_ptr.is_null() { null_vkCreateDebugReportCallbackEXT } else { mem::transmute(fn_ptr) } },
                vkDestroyDebugReportCallbackEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDebugReportCallbackEXT"); if fn_ptr.is_null() { null_vkDestroyDebugReportCallbackEXT } else { mem::transmute(fn_ptr) } },
                vkDebugReportMessageEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDebugReportMessageEXT"); if fn_ptr.is_null() { null_vkDebugReportMessageEXT } else { mem::transmute(fn_ptr) } },
                vkDebugMarkerSetObjectTagEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDebugMarkerSetObjectTagEXT"); if fn_ptr.is_null() { null_vkDebugMarkerSetObjectTagEXT } else { mem::transmute(fn_ptr) } },
                vkDebugMarkerSetObjectNameEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDebugMarkerSetObjectNameEXT"); if fn_ptr.is_null() { null_vkDebugMarkerSetObjectNameEXT } else { mem::transmute(fn_ptr) } },
                vkCmdDebugMarkerBeginEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDebugMarkerBeginEXT"); if fn_ptr.is_null() { null_vkCmdDebugMarkerBeginEXT } else { mem::transmute(fn_ptr) } },
                vkCmdDebugMarkerEndEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDebugMarkerEndEXT"); if fn_ptr.is_null() { null_vkCmdDebugMarkerEndEXT } else { mem::transmute(fn_ptr) } },
                vkCmdDebugMarkerInsertEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDebugMarkerInsertEXT"); if fn_ptr.is_null() { null_vkCmdDebugMarkerInsertEXT } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndirectCountAMD: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndirectCountAMD"); if fn_ptr.is_null() { null_vkCmdDrawIndirectCountAMD } else { mem::transmute(fn_ptr) } },
                vkCmdDrawIndexedIndirectCountAMD: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdDrawIndexedIndirectCountAMD"); if fn_ptr.is_null() { null_vkCmdDrawIndexedIndirectCountAMD } else { mem::transmute(fn_ptr) } },
                vkGetShaderInfoAMD: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetShaderInfoAMD"); if fn_ptr.is_null() { null_vkGetShaderInfoAMD } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceExternalImageFormatPropertiesNV: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceExternalImageFormatPropertiesNV } else { mem::transmute(fn_ptr) } },
                vkCmdBeginConditionalRenderingEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBeginConditionalRenderingEXT"); if fn_ptr.is_null() { null_vkCmdBeginConditionalRenderingEXT } else { mem::transmute(fn_ptr) } },
                vkCmdEndConditionalRenderingEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdEndConditionalRenderingEXT"); if fn_ptr.is_null() { null_vkCmdEndConditionalRenderingEXT } else { mem::transmute(fn_ptr) } },
                vkCmdProcessCommandsNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdProcessCommandsNVX"); if fn_ptr.is_null() { null_vkCmdProcessCommandsNVX } else { mem::transmute(fn_ptr) } },
                vkCmdReserveSpaceForCommandsNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdReserveSpaceForCommandsNVX"); if fn_ptr.is_null() { null_vkCmdReserveSpaceForCommandsNVX } else { mem::transmute(fn_ptr) } },
                vkCreateIndirectCommandsLayoutNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateIndirectCommandsLayoutNVX"); if fn_ptr.is_null() { null_vkCreateIndirectCommandsLayoutNVX } else { mem::transmute(fn_ptr) } },
                vkDestroyIndirectCommandsLayoutNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyIndirectCommandsLayoutNVX"); if fn_ptr.is_null() { null_vkDestroyIndirectCommandsLayoutNVX } else { mem::transmute(fn_ptr) } },
                vkCreateObjectTableNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateObjectTableNVX"); if fn_ptr.is_null() { null_vkCreateObjectTableNVX } else { mem::transmute(fn_ptr) } },
                vkDestroyObjectTableNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyObjectTableNVX"); if fn_ptr.is_null() { null_vkDestroyObjectTableNVX } else { mem::transmute(fn_ptr) } },
                vkRegisterObjectsNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkRegisterObjectsNVX"); if fn_ptr.is_null() { null_vkRegisterObjectsNVX } else { mem::transmute(fn_ptr) } },
                vkUnregisterObjectsNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkUnregisterObjectsNVX"); if fn_ptr.is_null() { null_vkUnregisterObjectsNVX } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX } else { mem::transmute(fn_ptr) } },
                vkCmdSetViewportWScalingNV: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetViewportWScalingNV"); if fn_ptr.is_null() { null_vkCmdSetViewportWScalingNV } else { mem::transmute(fn_ptr) } },
                vkReleaseDisplayEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkReleaseDisplayEXT"); if fn_ptr.is_null() { null_vkReleaseDisplayEXT } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceSurfaceCapabilities2EXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceSurfaceCapabilities2EXT } else { mem::transmute(fn_ptr) } },
                vkDisplayPowerControlEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDisplayPowerControlEXT"); if fn_ptr.is_null() { null_vkDisplayPowerControlEXT } else { mem::transmute(fn_ptr) } },
                vkRegisterDeviceEventEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkRegisterDeviceEventEXT"); if fn_ptr.is_null() { null_vkRegisterDeviceEventEXT } else { mem::transmute(fn_ptr) } },
                vkRegisterDisplayEventEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkRegisterDisplayEventEXT"); if fn_ptr.is_null() { null_vkRegisterDisplayEventEXT } else { mem::transmute(fn_ptr) } },
                vkGetSwapchainCounterEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetSwapchainCounterEXT"); if fn_ptr.is_null() { null_vkGetSwapchainCounterEXT } else { mem::transmute(fn_ptr) } },
                vkGetRefreshCycleDurationGOOGLE: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetRefreshCycleDurationGOOGLE"); if fn_ptr.is_null() { null_vkGetRefreshCycleDurationGOOGLE } else { mem::transmute(fn_ptr) } },
                vkGetPastPresentationTimingGOOGLE: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPastPresentationTimingGOOGLE"); if fn_ptr.is_null() { null_vkGetPastPresentationTimingGOOGLE } else { mem::transmute(fn_ptr) } },
                vkCmdSetDiscardRectangleEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetDiscardRectangleEXT"); if fn_ptr.is_null() { null_vkCmdSetDiscardRectangleEXT } else { mem::transmute(fn_ptr) } },
                vkSetHdrMetadataEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkSetHdrMetadataEXT"); if fn_ptr.is_null() { null_vkSetHdrMetadataEXT } else { mem::transmute(fn_ptr) } },
                vkSetDebugUtilsObjectNameEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkSetDebugUtilsObjectNameEXT"); if fn_ptr.is_null() { null_vkSetDebugUtilsObjectNameEXT } else { mem::transmute(fn_ptr) } },
                vkSetDebugUtilsObjectTagEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkSetDebugUtilsObjectTagEXT"); if fn_ptr.is_null() { null_vkSetDebugUtilsObjectTagEXT } else { mem::transmute(fn_ptr) } },
                vkQueueBeginDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueBeginDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkQueueBeginDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkQueueEndDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueEndDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkQueueEndDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkQueueInsertDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkQueueInsertDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkQueueInsertDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkCmdBeginDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdBeginDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkCmdBeginDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkCmdEndDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdEndDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkCmdEndDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkCmdInsertDebugUtilsLabelEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdInsertDebugUtilsLabelEXT"); if fn_ptr.is_null() { null_vkCmdInsertDebugUtilsLabelEXT } else { mem::transmute(fn_ptr) } },
                vkCreateDebugUtilsMessengerEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateDebugUtilsMessengerEXT"); if fn_ptr.is_null() { null_vkCreateDebugUtilsMessengerEXT } else { mem::transmute(fn_ptr) } },
                vkDestroyDebugUtilsMessengerEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyDebugUtilsMessengerEXT"); if fn_ptr.is_null() { null_vkDestroyDebugUtilsMessengerEXT } else { mem::transmute(fn_ptr) } },
                vkSubmitDebugUtilsMessageEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkSubmitDebugUtilsMessageEXT"); if fn_ptr.is_null() { null_vkSubmitDebugUtilsMessageEXT } else { mem::transmute(fn_ptr) } },
                vkCmdSetSampleLocationsEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetSampleLocationsEXT"); if fn_ptr.is_null() { null_vkCmdSetSampleLocationsEXT } else { mem::transmute(fn_ptr) } },
                vkGetPhysicalDeviceMultisamplePropertiesEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT"); if fn_ptr.is_null() { null_vkGetPhysicalDeviceMultisamplePropertiesEXT } else { mem::transmute(fn_ptr) } },
                vkCreateValidationCacheEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCreateValidationCacheEXT"); if fn_ptr.is_null() { null_vkCreateValidationCacheEXT } else { mem::transmute(fn_ptr) } },
                vkDestroyValidationCacheEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkDestroyValidationCacheEXT"); if fn_ptr.is_null() { null_vkDestroyValidationCacheEXT } else { mem::transmute(fn_ptr) } },
                vkMergeValidationCachesEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkMergeValidationCachesEXT"); if fn_ptr.is_null() { null_vkMergeValidationCachesEXT } else { mem::transmute(fn_ptr) } },
                vkGetValidationCacheDataEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetValidationCacheDataEXT"); if fn_ptr.is_null() { null_vkGetValidationCacheDataEXT } else { mem::transmute(fn_ptr) } },
                vkGetMemoryHostPointerPropertiesEXT: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetMemoryHostPointerPropertiesEXT"); if fn_ptr.is_null() { null_vkGetMemoryHostPointerPropertiesEXT } else { mem::transmute(fn_ptr) } },
                vkCmdWriteBufferMarkerAMD: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdWriteBufferMarkerAMD"); if fn_ptr.is_null() { null_vkCmdWriteBufferMarkerAMD } else { mem::transmute(fn_ptr) } },
                vkCmdSetCheckpointNV: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkCmdSetCheckpointNV"); if fn_ptr.is_null() { null_vkCmdSetCheckpointNV } else { mem::transmute(fn_ptr) } },
                vkGetQueueCheckpointDataNV: { let fn_ptr = get_vk_instance_function_pointer(instance, "vkGetQueueCheckpointDataNV"); if fn_ptr.is_null() { null_vkGetQueueCheckpointDataNV } else { mem::transmute(fn_ptr) } },
            }
        }
    }
}

unsafe extern fn null_vkDestroyInstance(instance: RawVkInstance, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyInstance\"");
}
unsafe extern fn null_vkEnumeratePhysicalDevices(instance: RawVkInstance, physical_device_count: *mut u32, physical_devices: *mut RawVkPhysicalDevice) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkEnumeratePhysicalDevices\"");
}
unsafe extern fn null_vkGetPhysicalDeviceFeatures(physical_device: RawVkPhysicalDevice, features: *mut RawVkPhysicalDeviceFeatures) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceFeatures\"");
}
unsafe extern fn null_vkGetPhysicalDeviceFormatProperties(physical_device: RawVkPhysicalDevice, format: RawVkFormat, format_properties: *mut RawVkFormatProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceFormatProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceImageFormatProperties(physical_device: RawVkPhysicalDevice, format: RawVkFormat, type_: RawVkImageType, tiling: RawVkImageTiling, usage: RawVkImageUsageFlags, flags: RawVkImageCreateFlags, image_format_properties: *mut RawVkImageFormatProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceImageFormatProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceProperties(physical_device: RawVkPhysicalDevice, properties: *mut RawVkPhysicalDeviceProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceQueueFamilyProperties(physical_device: RawVkPhysicalDevice, queue_family_property_count: *mut u32, queue_family_properties: *mut RawVkQueueFamilyProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceQueueFamilyProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceMemoryProperties(physical_device: RawVkPhysicalDevice, memory_properties: *mut RawVkPhysicalDeviceMemoryProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceMemoryProperties\"");
}
unsafe extern fn null_vkCreateDevice(physical_device: RawVkPhysicalDevice, create_info: *mut RawVkDeviceCreateInfo, allocator: *const c_void, device: *mut RawVkDevice) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDevice\"");
}
unsafe extern fn null_vkDestroyDevice(device: RawVkDevice, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDevice\"");
}
unsafe extern fn null_vkEnumerateDeviceExtensionProperties(physical_device: RawVkPhysicalDevice, layer_name: *mut c_char, property_count: *mut u32, properties: *mut RawVkExtensionProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkEnumerateDeviceExtensionProperties\"");
}
unsafe extern fn null_vkEnumerateDeviceLayerProperties(physical_device: RawVkPhysicalDevice, property_count: *mut u32, properties: *mut RawVkLayerProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkEnumerateDeviceLayerProperties\"");
}
unsafe extern fn null_vkGetDeviceQueue(device: RawVkDevice, queue_family_index: u32, queue_index: u32, queue: *mut RawVkQueue) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceQueue\"");
}
unsafe extern fn null_vkQueueSubmit(queue: RawVkQueue, submit_count: u32, submits: *mut RawVkSubmitInfo, fence: RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueSubmit\"");
}
unsafe extern fn null_vkQueueWaitIdle(queue: RawVkQueue) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueWaitIdle\"");
}
unsafe extern fn null_vkDeviceWaitIdle(device: RawVkDevice) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDeviceWaitIdle\"");
}
unsafe extern fn null_vkAllocateMemory(device: RawVkDevice, allocate_info: *mut RawVkMemoryAllocateInfo, allocator: *const c_void, memory: *mut RawVkDeviceMemory) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkAllocateMemory\"");
}
unsafe extern fn null_vkFreeMemory(device: RawVkDevice, memory: RawVkDeviceMemory, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkFreeMemory\"");
}
unsafe extern fn null_vkMapMemory(device: RawVkDevice, memory: RawVkDeviceMemory, offset: u64, size: u64, flags: RawVkMemoryMapFlags, data: *mut *mut c_void) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkMapMemory\"");
}
unsafe extern fn null_vkUnmapMemory(device: RawVkDevice, memory: RawVkDeviceMemory) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkUnmapMemory\"");
}
unsafe extern fn null_vkFlushMappedMemoryRanges(device: RawVkDevice, memory_range_count: u32, memory_ranges: *mut RawVkMappedMemoryRange) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkFlushMappedMemoryRanges\"");
}
unsafe extern fn null_vkInvalidateMappedMemoryRanges(device: RawVkDevice, memory_range_count: u32, memory_ranges: *mut RawVkMappedMemoryRange) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkInvalidateMappedMemoryRanges\"");
}
unsafe extern fn null_vkGetDeviceMemoryCommitment(device: RawVkDevice, memory: RawVkDeviceMemory, committed_memory_in_bytes: *mut u64) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceMemoryCommitment\"");
}
unsafe extern fn null_vkBindBufferMemory(device: RawVkDevice, buffer: RawVkBuffer, memory: RawVkDeviceMemory, memory_offset: u64) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkBindBufferMemory\"");
}
unsafe extern fn null_vkBindImageMemory(device: RawVkDevice, image: RawVkImage, memory: RawVkDeviceMemory, memory_offset: u64) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkBindImageMemory\"");
}
unsafe extern fn null_vkGetBufferMemoryRequirements(device: RawVkDevice, buffer: RawVkBuffer, memory_requirements: *mut RawVkMemoryRequirements) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetBufferMemoryRequirements\"");
}
unsafe extern fn null_vkGetImageMemoryRequirements(device: RawVkDevice, image: RawVkImage, memory_requirements: *mut RawVkMemoryRequirements) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetImageMemoryRequirements\"");
}
unsafe extern fn null_vkGetImageSparseMemoryRequirements(device: RawVkDevice, image: RawVkImage, sparse_memory_requirement_count: *mut u32, sparse_memory_requirements: *mut RawVkSparseImageMemoryRequirements) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetImageSparseMemoryRequirements\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSparseImageFormatProperties(physical_device: RawVkPhysicalDevice, format: RawVkFormat, type_: RawVkImageType, samples: RawVkSampleCountFlags, usage: RawVkImageUsageFlags, tiling: RawVkImageTiling, property_count: *mut u32, properties: *mut RawVkSparseImageFormatProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSparseImageFormatProperties\"");
}
unsafe extern fn null_vkQueueBindSparse(queue: RawVkQueue, bind_info_count: u32, bind_info: *mut RawVkBindSparseInfo, fence: RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueBindSparse\"");
}
unsafe extern fn null_vkCreateFence(device: RawVkDevice, create_info: *mut RawVkFenceCreateInfo, allocator: *const c_void, fence: *mut RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateFence\"");
}
unsafe extern fn null_vkDestroyFence(device: RawVkDevice, fence: RawVkFence, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyFence\"");
}
unsafe extern fn null_vkResetFences(device: RawVkDevice, fence_count: u32, fences: *mut RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkResetFences\"");
}
unsafe extern fn null_vkGetFenceStatus(device: RawVkDevice, fence: RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetFenceStatus\"");
}
unsafe extern fn null_vkWaitForFences(device: RawVkDevice, fence_count: u32, fences: *mut RawVkFence, wait_all: u32, timeout: u64) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkWaitForFences\"");
}
unsafe extern fn null_vkCreateSemaphore(device: RawVkDevice, create_info: *mut RawVkSemaphoreCreateInfo, allocator: *const c_void, semaphore: *mut RawVkSemaphore) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateSemaphore\"");
}
unsafe extern fn null_vkDestroySemaphore(device: RawVkDevice, semaphore: RawVkSemaphore, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroySemaphore\"");
}
unsafe extern fn null_vkCreateEvent(device: RawVkDevice, create_info: *mut RawVkEventCreateInfo, allocator: *const c_void, event: *mut RawVkEvent) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateEvent\"");
}
unsafe extern fn null_vkDestroyEvent(device: RawVkDevice, event: RawVkEvent, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyEvent\"");
}
unsafe extern fn null_vkGetEventStatus(device: RawVkDevice, event: RawVkEvent) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetEventStatus\"");
}
unsafe extern fn null_vkSetEvent(device: RawVkDevice, event: RawVkEvent) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkSetEvent\"");
}
unsafe extern fn null_vkResetEvent(device: RawVkDevice, event: RawVkEvent) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkResetEvent\"");
}
unsafe extern fn null_vkCreateQueryPool(device: RawVkDevice, create_info: *mut RawVkQueryPoolCreateInfo, allocator: *const c_void, query_pool: *mut RawVkQueryPool) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateQueryPool\"");
}
unsafe extern fn null_vkDestroyQueryPool(device: RawVkDevice, query_pool: RawVkQueryPool, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyQueryPool\"");
}
unsafe extern fn null_vkGetQueryPoolResults(device: RawVkDevice, query_pool: RawVkQueryPool, first_query: u32, query_count: u32, data_size: usize, data: *mut c_void, stride: u64, flags: RawVkQueryResultFlags) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetQueryPoolResults\"");
}
unsafe extern fn null_vkCreateBuffer(device: RawVkDevice, create_info: *mut RawVkBufferCreateInfo, allocator: *const c_void, buffer: *mut RawVkBuffer) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateBuffer\"");
}
unsafe extern fn null_vkDestroyBuffer(device: RawVkDevice, buffer: RawVkBuffer, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyBuffer\"");
}
unsafe extern fn null_vkCreateBufferView(device: RawVkDevice, create_info: *mut RawVkBufferViewCreateInfo, allocator: *const c_void, view: *mut RawVkBufferView) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateBufferView\"");
}
unsafe extern fn null_vkDestroyBufferView(device: RawVkDevice, buffer_view: RawVkBufferView, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyBufferView\"");
}
unsafe extern fn null_vkCreateImage(device: RawVkDevice, create_info: *mut RawVkImageCreateInfo, allocator: *const c_void, image: *mut RawVkImage) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateImage\"");
}
unsafe extern fn null_vkDestroyImage(device: RawVkDevice, image: RawVkImage, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyImage\"");
}
unsafe extern fn null_vkGetImageSubresourceLayout(device: RawVkDevice, image: RawVkImage, subresource: *mut RawVkImageSubresource, layout: *mut RawVkSubresourceLayout) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetImageSubresourceLayout\"");
}
unsafe extern fn null_vkCreateImageView(device: RawVkDevice, create_info: *mut RawVkImageViewCreateInfo, allocator: *const c_void, view: *mut RawVkImageView) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateImageView\"");
}
unsafe extern fn null_vkDestroyImageView(device: RawVkDevice, image_view: RawVkImageView, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyImageView\"");
}
unsafe extern fn null_vkCreateShaderModule(device: RawVkDevice, create_info: *mut RawVkShaderModuleCreateInfo, allocator: *const c_void, shader_module: *mut RawVkShaderModule) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateShaderModule\"");
}
unsafe extern fn null_vkDestroyShaderModule(device: RawVkDevice, shader_module: RawVkShaderModule, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyShaderModule\"");
}
unsafe extern fn null_vkCreatePipelineCache(device: RawVkDevice, create_info: *mut RawVkPipelineCacheCreateInfo, allocator: *const c_void, pipeline_cache: *mut RawVkPipelineCache) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreatePipelineCache\"");
}
unsafe extern fn null_vkDestroyPipelineCache(device: RawVkDevice, pipeline_cache: RawVkPipelineCache, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyPipelineCache\"");
}
unsafe extern fn null_vkGetPipelineCacheData(device: RawVkDevice, pipeline_cache: RawVkPipelineCache, data_size: *mut usize, data: *mut c_void) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPipelineCacheData\"");
}
unsafe extern fn null_vkMergePipelineCaches(device: RawVkDevice, dst_cache: RawVkPipelineCache, src_cache_count: u32, src_caches: *mut RawVkPipelineCache) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkMergePipelineCaches\"");
}
unsafe extern fn null_vkCreateGraphicsPipelines(device: RawVkDevice, pipeline_cache: RawVkPipelineCache, create_info_count: u32, create_infos: *mut RawVkGraphicsPipelineCreateInfo, allocator: *const c_void, pipelines: *mut RawVkPipeline) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateGraphicsPipelines\"");
}
unsafe extern fn null_vkCreateComputePipelines(device: RawVkDevice, pipeline_cache: RawVkPipelineCache, create_info_count: u32, create_infos: *mut RawVkComputePipelineCreateInfo, allocator: *const c_void, pipelines: *mut RawVkPipeline) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateComputePipelines\"");
}
unsafe extern fn null_vkDestroyPipeline(device: RawVkDevice, pipeline: RawVkPipeline, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyPipeline\"");
}
unsafe extern fn null_vkCreatePipelineLayout(device: RawVkDevice, create_info: *mut RawVkPipelineLayoutCreateInfo, allocator: *const c_void, pipeline_layout: *mut RawVkPipelineLayout) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreatePipelineLayout\"");
}
unsafe extern fn null_vkDestroyPipelineLayout(device: RawVkDevice, pipeline_layout: RawVkPipelineLayout, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyPipelineLayout\"");
}
unsafe extern fn null_vkCreateSampler(device: RawVkDevice, create_info: *mut RawVkSamplerCreateInfo, allocator: *const c_void, sampler: *mut RawVkSampler) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateSampler\"");
}
unsafe extern fn null_vkDestroySampler(device: RawVkDevice, sampler: RawVkSampler, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroySampler\"");
}
unsafe extern fn null_vkCreateDescriptorSetLayout(device: RawVkDevice, create_info: *mut RawVkDescriptorSetLayoutCreateInfo, allocator: *const c_void, set_layout: *mut RawVkDescriptorSetLayout) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDescriptorSetLayout\"");
}
unsafe extern fn null_vkDestroyDescriptorSetLayout(device: RawVkDevice, descriptor_set_layout: RawVkDescriptorSetLayout, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDescriptorSetLayout\"");
}
unsafe extern fn null_vkCreateDescriptorPool(device: RawVkDevice, create_info: *mut RawVkDescriptorPoolCreateInfo, allocator: *const c_void, descriptor_pool: *mut RawVkDescriptorPool) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDescriptorPool\"");
}
unsafe extern fn null_vkDestroyDescriptorPool(device: RawVkDevice, descriptor_pool: RawVkDescriptorPool, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDescriptorPool\"");
}
unsafe extern fn null_vkResetDescriptorPool(device: RawVkDevice, descriptor_pool: RawVkDescriptorPool, flags: RawVkDescriptorPoolResetFlags) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkResetDescriptorPool\"");
}
unsafe extern fn null_vkAllocateDescriptorSets(device: RawVkDevice, allocate_info: *mut RawVkDescriptorSetAllocateInfo, descriptor_sets: *mut RawVkDescriptorSet) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkAllocateDescriptorSets\"");
}
unsafe extern fn null_vkFreeDescriptorSets(device: RawVkDevice, descriptor_pool: RawVkDescriptorPool, descriptor_set_count: u32, descriptor_sets: *mut RawVkDescriptorSet) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkFreeDescriptorSets\"");
}
unsafe extern fn null_vkUpdateDescriptorSets(device: RawVkDevice, descriptor_write_count: u32, descriptor_writes: *mut RawVkWriteDescriptorSet, descriptor_copy_count: u32, descriptor_copies: *mut RawVkCopyDescriptorSet) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkUpdateDescriptorSets\"");
}
unsafe extern fn null_vkCreateFramebuffer(device: RawVkDevice, create_info: *mut RawVkFramebufferCreateInfo, allocator: *const c_void, framebuffer: *mut RawVkFramebuffer) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateFramebuffer\"");
}
unsafe extern fn null_vkDestroyFramebuffer(device: RawVkDevice, framebuffer: RawVkFramebuffer, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyFramebuffer\"");
}
unsafe extern fn null_vkCreateRenderPass(device: RawVkDevice, create_info: *mut RawVkRenderPassCreateInfo, allocator: *const c_void, render_pass: *mut RawVkRenderPass) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateRenderPass\"");
}
unsafe extern fn null_vkDestroyRenderPass(device: RawVkDevice, render_pass: RawVkRenderPass, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyRenderPass\"");
}
unsafe extern fn null_vkGetRenderAreaGranularity(device: RawVkDevice, render_pass: RawVkRenderPass, granularity: *mut RawVkExtent2D) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetRenderAreaGranularity\"");
}
unsafe extern fn null_vkCreateCommandPool(device: RawVkDevice, create_info: *mut RawVkCommandPoolCreateInfo, allocator: *const c_void, command_pool: *mut RawVkCommandPool) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateCommandPool\"");
}
unsafe extern fn null_vkDestroyCommandPool(device: RawVkDevice, command_pool: RawVkCommandPool, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyCommandPool\"");
}
unsafe extern fn null_vkResetCommandPool(device: RawVkDevice, command_pool: RawVkCommandPool, flags: RawVkCommandPoolResetFlags) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkResetCommandPool\"");
}
unsafe extern fn null_vkAllocateCommandBuffers(device: RawVkDevice, allocate_info: *mut RawVkCommandBufferAllocateInfo, command_buffers: *mut RawVkCommandBuffer) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkAllocateCommandBuffers\"");
}
unsafe extern fn null_vkFreeCommandBuffers(device: RawVkDevice, command_pool: RawVkCommandPool, command_buffer_count: u32, command_buffers: *mut RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkFreeCommandBuffers\"");
}
unsafe extern fn null_vkBeginCommandBuffer(command_buffer: RawVkCommandBuffer, begin_info: *mut RawVkCommandBufferBeginInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkBeginCommandBuffer\"");
}
unsafe extern fn null_vkEndCommandBuffer(command_buffer: RawVkCommandBuffer) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkEndCommandBuffer\"");
}
unsafe extern fn null_vkResetCommandBuffer(command_buffer: RawVkCommandBuffer, flags: RawVkCommandBufferResetFlags) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkResetCommandBuffer\"");
}
unsafe extern fn null_vkCmdBindPipeline(command_buffer: RawVkCommandBuffer, pipeline_bind_point: RawVkPipelineBindPoint, pipeline: RawVkPipeline) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBindPipeline\"");
}
unsafe extern fn null_vkCmdSetViewport(command_buffer: RawVkCommandBuffer, first_viewport: u32, viewport_count: u32, viewports: *mut RawVkViewport) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetViewport\"");
}
unsafe extern fn null_vkCmdSetScissor(command_buffer: RawVkCommandBuffer, first_scissor: u32, scissor_count: u32, scissors: *mut RawVkRect2D) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetScissor\"");
}
unsafe extern fn null_vkCmdSetLineWidth(command_buffer: RawVkCommandBuffer, line_width: f32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetLineWidth\"");
}
unsafe extern fn null_vkCmdSetDepthBias(command_buffer: RawVkCommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetDepthBias\"");
}
unsafe extern fn null_vkCmdSetBlendConstants(command_buffer: RawVkCommandBuffer, blend_constants: [f32; 4]) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetBlendConstants\"");
}
unsafe extern fn null_vkCmdSetDepthBounds(command_buffer: RawVkCommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetDepthBounds\"");
}
unsafe extern fn null_vkCmdSetStencilCompareMask(command_buffer: RawVkCommandBuffer, face_mask: RawVkStencilFaceFlags, compare_mask: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetStencilCompareMask\"");
}
unsafe extern fn null_vkCmdSetStencilWriteMask(command_buffer: RawVkCommandBuffer, face_mask: RawVkStencilFaceFlags, write_mask: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetStencilWriteMask\"");
}
unsafe extern fn null_vkCmdSetStencilReference(command_buffer: RawVkCommandBuffer, face_mask: RawVkStencilFaceFlags, reference: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetStencilReference\"");
}
unsafe extern fn null_vkCmdBindDescriptorSets(command_buffer: RawVkCommandBuffer, pipeline_bind_point: RawVkPipelineBindPoint, layout: RawVkPipelineLayout, first_set: u32, descriptor_set_count: u32, descriptor_sets: *mut RawVkDescriptorSet, dynamic_offset_count: u32, dynamic_offsets: *mut u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBindDescriptorSets\"");
}
unsafe extern fn null_vkCmdBindIndexBuffer(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, index_type: RawVkIndexType) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBindIndexBuffer\"");
}
unsafe extern fn null_vkCmdBindVertexBuffers(command_buffer: RawVkCommandBuffer, first_binding: u32, binding_count: u32, buffers: *mut RawVkBuffer, offsets: *mut u64) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBindVertexBuffers\"");
}
unsafe extern fn null_vkCmdDraw(command_buffer: RawVkCommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDraw\"");
}
unsafe extern fn null_vkCmdDrawIndexed(command_buffer: RawVkCommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndexed\"");
}
unsafe extern fn null_vkCmdDrawIndirect(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndirect\"");
}
unsafe extern fn null_vkCmdDrawIndexedIndirect(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndexedIndirect\"");
}
unsafe extern fn null_vkCmdDispatch(command_buffer: RawVkCommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDispatch\"");
}
unsafe extern fn null_vkCmdDispatchIndirect(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDispatchIndirect\"");
}
unsafe extern fn null_vkCmdCopyBuffer(command_buffer: RawVkCommandBuffer, src_buffer: RawVkBuffer, dst_buffer: RawVkBuffer, region_count: u32, regions: *mut RawVkBufferCopy) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdCopyBuffer\"");
}
unsafe extern fn null_vkCmdCopyImage(command_buffer: RawVkCommandBuffer, src_image: RawVkImage, src_image_layout: RawVkImageLayout, dst_image: RawVkImage, dst_image_layout: RawVkImageLayout, region_count: u32, regions: *mut RawVkImageCopy) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdCopyImage\"");
}
unsafe extern fn null_vkCmdBlitImage(command_buffer: RawVkCommandBuffer, src_image: RawVkImage, src_image_layout: RawVkImageLayout, dst_image: RawVkImage, dst_image_layout: RawVkImageLayout, region_count: u32, regions: *mut RawVkImageBlit, filter: RawVkFilter) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBlitImage\"");
}
unsafe extern fn null_vkCmdCopyBufferToImage(command_buffer: RawVkCommandBuffer, src_buffer: RawVkBuffer, dst_image: RawVkImage, dst_image_layout: RawVkImageLayout, region_count: u32, regions: *mut RawVkBufferImageCopy) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdCopyBufferToImage\"");
}
unsafe extern fn null_vkCmdCopyImageToBuffer(command_buffer: RawVkCommandBuffer, src_image: RawVkImage, src_image_layout: RawVkImageLayout, dst_buffer: RawVkBuffer, region_count: u32, regions: *mut RawVkBufferImageCopy) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdCopyImageToBuffer\"");
}
unsafe extern fn null_vkCmdUpdateBuffer(command_buffer: RawVkCommandBuffer, dst_buffer: RawVkBuffer, dst_offset: u64, data_size: u64, data: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdUpdateBuffer\"");
}
unsafe extern fn null_vkCmdFillBuffer(command_buffer: RawVkCommandBuffer, dst_buffer: RawVkBuffer, dst_offset: u64, size: u64, data: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdFillBuffer\"");
}
unsafe extern fn null_vkCmdClearColorImage(command_buffer: RawVkCommandBuffer, image: RawVkImage, image_layout: RawVkImageLayout, color: *mut RawVkClearColorValue, range_count: u32, ranges: *mut RawVkImageSubresourceRange) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdClearColorImage\"");
}
unsafe extern fn null_vkCmdClearDepthStencilImage(command_buffer: RawVkCommandBuffer, image: RawVkImage, image_layout: RawVkImageLayout, depth_stencil: *mut RawVkClearDepthStencilValue, range_count: u32, ranges: *mut RawVkImageSubresourceRange) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdClearDepthStencilImage\"");
}
unsafe extern fn null_vkCmdClearAttachments(command_buffer: RawVkCommandBuffer, attachment_count: u32, attachments: *mut RawVkClearAttachment, rect_count: u32, rects: *mut RawVkClearRect) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdClearAttachments\"");
}
unsafe extern fn null_vkCmdResolveImage(command_buffer: RawVkCommandBuffer, src_image: RawVkImage, src_image_layout: RawVkImageLayout, dst_image: RawVkImage, dst_image_layout: RawVkImageLayout, region_count: u32, regions: *mut RawVkImageResolve) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdResolveImage\"");
}
unsafe extern fn null_vkCmdSetEvent(command_buffer: RawVkCommandBuffer, event: RawVkEvent, stage_mask: RawVkPipelineStageFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetEvent\"");
}
unsafe extern fn null_vkCmdResetEvent(command_buffer: RawVkCommandBuffer, event: RawVkEvent, stage_mask: RawVkPipelineStageFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdResetEvent\"");
}
unsafe extern fn null_vkCmdWaitEvents(command_buffer: RawVkCommandBuffer, event_count: u32, events: *mut RawVkEvent, src_stage_mask: RawVkPipelineStageFlags, dst_stage_mask: RawVkPipelineStageFlags, memory_barrier_count: u32, memory_barriers: *mut RawVkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *mut RawVkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *mut RawVkImageMemoryBarrier) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdWaitEvents\"");
}
unsafe extern fn null_vkCmdPipelineBarrier(command_buffer: RawVkCommandBuffer, src_stage_mask: RawVkPipelineStageFlags, dst_stage_mask: RawVkPipelineStageFlags, dependency_flags: RawVkDependencyFlags, memory_barrier_count: u32, memory_barriers: *mut RawVkMemoryBarrier, buffer_memory_barrier_count: u32, buffer_memory_barriers: *mut RawVkBufferMemoryBarrier, image_memory_barrier_count: u32, image_memory_barriers: *mut RawVkImageMemoryBarrier) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdPipelineBarrier\"");
}
unsafe extern fn null_vkCmdBeginQuery(command_buffer: RawVkCommandBuffer, query_pool: RawVkQueryPool, query: u32, flags: RawVkQueryControlFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBeginQuery\"");
}
unsafe extern fn null_vkCmdEndQuery(command_buffer: RawVkCommandBuffer, query_pool: RawVkQueryPool, query: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdEndQuery\"");
}
unsafe extern fn null_vkCmdResetQueryPool(command_buffer: RawVkCommandBuffer, query_pool: RawVkQueryPool, first_query: u32, query_count: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdResetQueryPool\"");
}
unsafe extern fn null_vkCmdWriteTimestamp(command_buffer: RawVkCommandBuffer, pipeline_stage: RawVkPipelineStageFlags, query_pool: RawVkQueryPool, query: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdWriteTimestamp\"");
}
unsafe extern fn null_vkCmdCopyQueryPoolResults(command_buffer: RawVkCommandBuffer, query_pool: RawVkQueryPool, first_query: u32, query_count: u32, dst_buffer: RawVkBuffer, dst_offset: u64, stride: u64, flags: RawVkQueryResultFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdCopyQueryPoolResults\"");
}
unsafe extern fn null_vkCmdPushConstants(command_buffer: RawVkCommandBuffer, layout: RawVkPipelineLayout, stage_flags: RawVkShaderStageFlags, offset: u32, size: u32, values: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdPushConstants\"");
}
unsafe extern fn null_vkCmdBeginRenderPass(command_buffer: RawVkCommandBuffer, render_pass_begin: *mut RawVkRenderPassBeginInfo, contents: RawVkSubpassContents) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBeginRenderPass\"");
}
unsafe extern fn null_vkCmdNextSubpass(command_buffer: RawVkCommandBuffer, contents: RawVkSubpassContents) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdNextSubpass\"");
}
unsafe extern fn null_vkCmdEndRenderPass(command_buffer: RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdEndRenderPass\"");
}
unsafe extern fn null_vkCmdExecuteCommands(command_buffer: RawVkCommandBuffer, command_buffer_count: u32, command_buffers: *mut RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdExecuteCommands\"");
}
unsafe extern fn null_vkBindBufferMemory2(device: RawVkDevice, bind_info_count: u32, bind_infos: *mut RawVkBindBufferMemoryInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkBindBufferMemory2\"");
}
unsafe extern fn null_vkBindImageMemory2(device: RawVkDevice, bind_info_count: u32, bind_infos: *mut RawVkBindImageMemoryInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkBindImageMemory2\"");
}
unsafe extern fn null_vkGetDeviceGroupPeerMemoryFeatures(device: RawVkDevice, heap_index: u32, local_device_index: u32, remote_device_index: u32, peer_memory_features: *mut RawVkPeerMemoryFeatureFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceGroupPeerMemoryFeatures\"");
}
unsafe extern fn null_vkCmdSetDeviceMask(command_buffer: RawVkCommandBuffer, device_mask: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetDeviceMask\"");
}
unsafe extern fn null_vkCmdDispatchBase(command_buffer: RawVkCommandBuffer, base_group_x: u32, base_group_y: u32, base_group_z: u32, group_count_x: u32, group_count_y: u32, group_count_z: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDispatchBase\"");
}
unsafe extern fn null_vkEnumeratePhysicalDeviceGroups(instance: RawVkInstance, physical_device_group_count: *mut u32, physical_device_group_properties: *mut RawVkPhysicalDeviceGroupProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkEnumeratePhysicalDeviceGroups\"");
}
unsafe extern fn null_vkGetImageMemoryRequirements2(device: RawVkDevice, info: *mut RawVkImageMemoryRequirementsInfo2, memory_requirements: *mut RawVkMemoryRequirements2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetImageMemoryRequirements2\"");
}
unsafe extern fn null_vkGetBufferMemoryRequirements2(device: RawVkDevice, info: *mut RawVkBufferMemoryRequirementsInfo2, memory_requirements: *mut RawVkMemoryRequirements2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetBufferMemoryRequirements2\"");
}
unsafe extern fn null_vkGetImageSparseMemoryRequirements2(device: RawVkDevice, info: *mut RawVkImageSparseMemoryRequirementsInfo2, sparse_memory_requirement_count: *mut u32, sparse_memory_requirements: *mut RawVkSparseImageMemoryRequirements2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetImageSparseMemoryRequirements2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceFeatures2(physical_device: RawVkPhysicalDevice, features: *mut RawVkPhysicalDeviceFeatures2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceFeatures2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceProperties2(physical_device: RawVkPhysicalDevice, properties: *mut RawVkPhysicalDeviceProperties2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceProperties2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceFormatProperties2(physical_device: RawVkPhysicalDevice, format: RawVkFormat, format_properties: *mut RawVkFormatProperties2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceFormatProperties2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceImageFormatProperties2(physical_device: RawVkPhysicalDevice, image_format_info: *mut RawVkPhysicalDeviceImageFormatInfo2, image_format_properties: *mut RawVkImageFormatProperties2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceImageFormatProperties2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceQueueFamilyProperties2(physical_device: RawVkPhysicalDevice, queue_family_property_count: *mut u32, queue_family_properties: *mut RawVkQueueFamilyProperties2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceQueueFamilyProperties2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceMemoryProperties2(physical_device: RawVkPhysicalDevice, memory_properties: *mut RawVkPhysicalDeviceMemoryProperties2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceMemoryProperties2\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device: RawVkPhysicalDevice, format_info: *mut RawVkPhysicalDeviceSparseImageFormatInfo2, property_count: *mut u32, properties: *mut RawVkSparseImageFormatProperties2) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSparseImageFormatProperties2\"");
}
unsafe extern fn null_vkTrimCommandPool(device: RawVkDevice, command_pool: RawVkCommandPool, flags: RawVkCommandPoolTrimFlags) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkTrimCommandPool\"");
}
unsafe extern fn null_vkGetDeviceQueue2(device: RawVkDevice, queue_info: *mut RawVkDeviceQueueInfo2, queue: *mut RawVkQueue) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceQueue2\"");
}
unsafe extern fn null_vkCreateSamplerYcbcrConversion(device: RawVkDevice, create_info: *mut RawVkSamplerYcbcrConversionCreateInfo, allocator: *const c_void, ycbcr_conversion: *mut RawVkSamplerYcbcrConversion) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateSamplerYcbcrConversion\"");
}
unsafe extern fn null_vkDestroySamplerYcbcrConversion(device: RawVkDevice, ycbcr_conversion: RawVkSamplerYcbcrConversion, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroySamplerYcbcrConversion\"");
}
unsafe extern fn null_vkCreateDescriptorUpdateTemplate(device: RawVkDevice, create_info: *mut RawVkDescriptorUpdateTemplateCreateInfo, allocator: *const c_void, descriptor_update_template: *mut RawVkDescriptorUpdateTemplate) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDescriptorUpdateTemplate\"");
}
unsafe extern fn null_vkDestroyDescriptorUpdateTemplate(device: RawVkDevice, descriptor_update_template: RawVkDescriptorUpdateTemplate, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDescriptorUpdateTemplate\"");
}
unsafe extern fn null_vkUpdateDescriptorSetWithTemplate(device: RawVkDevice, descriptor_set: RawVkDescriptorSet, descriptor_update_template: RawVkDescriptorUpdateTemplate, data: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkUpdateDescriptorSetWithTemplate\"");
}
unsafe extern fn null_vkGetPhysicalDeviceExternalBufferProperties(physical_device: RawVkPhysicalDevice, external_buffer_info: *mut RawVkPhysicalDeviceExternalBufferInfo, external_buffer_properties: *mut RawVkExternalBufferProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceExternalBufferProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceExternalFenceProperties(physical_device: RawVkPhysicalDevice, external_fence_info: *mut RawVkPhysicalDeviceExternalFenceInfo, external_fence_properties: *mut RawVkExternalFenceProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceExternalFenceProperties\"");
}
unsafe extern fn null_vkGetPhysicalDeviceExternalSemaphoreProperties(physical_device: RawVkPhysicalDevice, external_semaphore_info: *mut RawVkPhysicalDeviceExternalSemaphoreInfo, external_semaphore_properties: *mut RawVkExternalSemaphoreProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceExternalSemaphoreProperties\"");
}
unsafe extern fn null_vkGetDescriptorSetLayoutSupport(device: RawVkDevice, create_info: *mut RawVkDescriptorSetLayoutCreateInfo, support: *mut RawVkDescriptorSetLayoutSupport) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDescriptorSetLayoutSupport\"");
}
unsafe extern fn null_vkDestroySurfaceKHR(instance: RawVkInstance, surface: khr::RawVkSurface, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroySurfaceKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceSupportKHR(physical_device: RawVkPhysicalDevice, queue_family_index: u32, surface: khr::RawVkSurface, supported: *mut u32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceSupportKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device: RawVkPhysicalDevice, surface: khr::RawVkSurface, surface_capabilities: *mut khr::RawVkSurfaceCapabilities) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device: RawVkPhysicalDevice, surface: khr::RawVkSurface, surface_format_count: *mut u32, surface_formats: *mut khr::RawVkSurfaceFormat) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceFormatsKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device: RawVkPhysicalDevice, surface: khr::RawVkSurface, present_mode_count: *mut u32, present_modes: *mut khr::RawVkPresentMode) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfacePresentModesKHR\"");
}
unsafe extern fn null_vkCreateSwapchainKHR(device: RawVkDevice, create_info: *mut khr::RawVkSwapchainCreateInfo, allocator: *const c_void, swapchain: *mut khr::RawVkSwapchain) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateSwapchainKHR\"");
}
unsafe extern fn null_vkDestroySwapchainKHR(device: RawVkDevice, swapchain: khr::RawVkSwapchain, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroySwapchainKHR\"");
}
unsafe extern fn null_vkGetSwapchainImagesKHR(device: RawVkDevice, swapchain: khr::RawVkSwapchain, swapchain_image_count: *mut u32, swapchain_images: *mut RawVkImage) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetSwapchainImagesKHR\"");
}
unsafe extern fn null_vkAcquireNextImageKHR(device: RawVkDevice, swapchain: khr::RawVkSwapchain, timeout: u64, semaphore: RawVkSemaphore, fence: RawVkFence, image_index: *mut u32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkAcquireNextImageKHR\"");
}
unsafe extern fn null_vkQueuePresentKHR(queue: RawVkQueue, present_info: *mut khr::RawVkPresentInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueuePresentKHR\"");
}
unsafe extern fn null_vkGetDeviceGroupPresentCapabilitiesKHR(device: RawVkDevice, device_group_present_capabilities: *mut khr::RawVkDeviceGroupPresentCapabilities) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceGroupPresentCapabilitiesKHR\"");
}
unsafe extern fn null_vkGetDeviceGroupSurfacePresentModesKHR(device: RawVkDevice, surface: khr::RawVkSurface, modes: *mut khr::RawVkDeviceGroupPresentModeFlags) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDeviceGroupSurfacePresentModesKHR\"");
}
unsafe extern fn null_vkGetPhysicalDevicePresentRectanglesKHR(physical_device: RawVkPhysicalDevice, surface: khr::RawVkSurface, rect_count: *mut u32, rects: *mut RawVkRect2D) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDevicePresentRectanglesKHR\"");
}
unsafe extern fn null_vkAcquireNextImage2KHR(device: RawVkDevice, acquire_info: *mut khr::RawVkAcquireNextImageInfo, image_index: *mut u32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkAcquireNextImage2KHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceDisplayPropertiesKHR(physical_device: RawVkPhysicalDevice, property_count: *mut u32, properties: *mut khr::RawVkDisplayProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceDisplayPropertiesKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physical_device: RawVkPhysicalDevice, property_count: *mut u32, properties: *mut khr::RawVkDisplayPlaneProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\"");
}
unsafe extern fn null_vkGetDisplayPlaneSupportedDisplaysKHR(physical_device: RawVkPhysicalDevice, plane_index: u32, display_count: *mut u32, displays: *mut khr::RawVkDisplay) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDisplayPlaneSupportedDisplaysKHR\"");
}
unsafe extern fn null_vkGetDisplayModePropertiesKHR(physical_device: RawVkPhysicalDevice, display: khr::RawVkDisplay, property_count: *mut u32, properties: *mut khr::RawVkDisplayModeProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDisplayModePropertiesKHR\"");
}
unsafe extern fn null_vkCreateDisplayModeKHR(physical_device: RawVkPhysicalDevice, display: khr::RawVkDisplay, create_info: *mut khr::RawVkDisplayModeCreateInfo, allocator: *const c_void, mode: *mut khr::RawVkDisplayMode) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDisplayModeKHR\"");
}
unsafe extern fn null_vkGetDisplayPlaneCapabilitiesKHR(physical_device: RawVkPhysicalDevice, mode: khr::RawVkDisplayMode, plane_index: u32, capabilities: *mut khr::RawVkDisplayPlaneCapabilities) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDisplayPlaneCapabilitiesKHR\"");
}
unsafe extern fn null_vkCreateDisplayPlaneSurfaceKHR(instance: RawVkInstance, create_info: *mut khr::RawVkDisplaySurfaceCreateInfo, allocator: *const c_void, surface: *mut khr::RawVkSurface) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDisplayPlaneSurfaceKHR\"");
}
unsafe extern fn null_vkCreateSharedSwapchainsKHR(device: RawVkDevice, swapchain_count: u32, create_infos: *mut khr::RawVkSwapchainCreateInfo, allocator: *const c_void, swapchains: *mut khr::RawVkSwapchain) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateSharedSwapchainsKHR\"");
}
unsafe extern fn null_vkGetMemoryFdKHR(device: RawVkDevice, get_fd_info: *mut khr::RawVkMemoryGetFdInfo, fd: *mut i32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetMemoryFdKHR\"");
}
unsafe extern fn null_vkGetMemoryFdPropertiesKHR(device: RawVkDevice, handle_type: RawVkExternalMemoryHandleTypeFlags, fd: i32, memory_fd_properties: *mut khr::RawVkMemoryFdProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetMemoryFdPropertiesKHR\"");
}
unsafe extern fn null_vkImportSemaphoreFdKHR(device: RawVkDevice, import_semaphore_fd_info: *mut khr::RawVkImportSemaphoreFdInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkImportSemaphoreFdKHR\"");
}
unsafe extern fn null_vkGetSemaphoreFdKHR(device: RawVkDevice, get_fd_info: *mut khr::RawVkSemaphoreGetFdInfo, fd: *mut i32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetSemaphoreFdKHR\"");
}
unsafe extern fn null_vkCmdPushDescriptorSetKHR(command_buffer: RawVkCommandBuffer, pipeline_bind_point: RawVkPipelineBindPoint, layout: RawVkPipelineLayout, set: u32, descriptor_write_count: u32, descriptor_writes: *mut RawVkWriteDescriptorSet) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdPushDescriptorSetKHR\"");
}
unsafe extern fn null_vkCmdPushDescriptorSetWithTemplateKHR(command_buffer: RawVkCommandBuffer, descriptor_update_template: RawVkDescriptorUpdateTemplate, layout: RawVkPipelineLayout, set: u32, data: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdPushDescriptorSetWithTemplateKHR\"");
}
unsafe extern fn null_vkCreateRenderPass2KHR(device: RawVkDevice, create_info: *mut khr::RawVkRenderPassCreateInfo2, allocator: *const c_void, render_pass: *mut RawVkRenderPass) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateRenderPass2KHR\"");
}
unsafe extern fn null_vkCmdBeginRenderPass2KHR(command_buffer: RawVkCommandBuffer, render_pass_begin: *mut RawVkRenderPassBeginInfo, subpass_begin_info: *mut khr::RawVkSubpassBeginInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBeginRenderPass2KHR\"");
}
unsafe extern fn null_vkCmdNextSubpass2KHR(command_buffer: RawVkCommandBuffer, subpass_begin_info: *mut khr::RawVkSubpassBeginInfo, subpass_end_info: *mut khr::RawVkSubpassEndInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdNextSubpass2KHR\"");
}
unsafe extern fn null_vkCmdEndRenderPass2KHR(command_buffer: RawVkCommandBuffer, subpass_end_info: *mut khr::RawVkSubpassEndInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdEndRenderPass2KHR\"");
}
unsafe extern fn null_vkGetSwapchainStatusKHR(device: RawVkDevice, swapchain: khr::RawVkSwapchain) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetSwapchainStatusKHR\"");
}
unsafe extern fn null_vkImportFenceFdKHR(device: RawVkDevice, import_fence_fd_info: *mut khr::RawVkImportFenceFdInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkImportFenceFdKHR\"");
}
unsafe extern fn null_vkGetFenceFdKHR(device: RawVkDevice, get_fd_info: *mut khr::RawVkFenceGetFdInfo, fd: *mut i32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetFenceFdKHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physical_device: RawVkPhysicalDevice, surface_info: *mut khr::RawVkPhysicalDeviceSurfaceInfo2, surface_capabilities: *mut khr::RawVkSurfaceCapabilities2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceCapabilities2KHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceFormats2KHR(physical_device: RawVkPhysicalDevice, surface_info: *mut khr::RawVkPhysicalDeviceSurfaceInfo2, surface_format_count: *mut u32, surface_formats: *mut khr::RawVkSurfaceFormat2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceFormats2KHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceDisplayProperties2KHR(physical_device: RawVkPhysicalDevice, property_count: *mut u32, properties: *mut khr::RawVkDisplayProperties2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceDisplayProperties2KHR\"");
}
unsafe extern fn null_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physical_device: RawVkPhysicalDevice, property_count: *mut u32, properties: *mut khr::RawVkDisplayPlaneProperties2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\"");
}
unsafe extern fn null_vkGetDisplayModeProperties2KHR(physical_device: RawVkPhysicalDevice, display: khr::RawVkDisplay, property_count: *mut u32, properties: *mut khr::RawVkDisplayModeProperties2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDisplayModeProperties2KHR\"");
}
unsafe extern fn null_vkGetDisplayPlaneCapabilities2KHR(physical_device: RawVkPhysicalDevice, display_plane_info: *mut khr::RawVkDisplayPlaneInfo2, capabilities: *mut khr::RawVkDisplayPlaneCapabilities2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetDisplayPlaneCapabilities2KHR\"");
}
unsafe extern fn null_vkCmdDrawIndirectCountKHR(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, count_buffer: RawVkBuffer, count_buffer_offset: u64, max_draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndirectCountKHR\"");
}
unsafe extern fn null_vkCmdDrawIndexedIndirectCountKHR(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, count_buffer: RawVkBuffer, count_buffer_offset: u64, max_draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndexedIndirectCountKHR\"");
}
unsafe extern fn null_vkCreateDebugReportCallbackEXT(instance: RawVkInstance, create_info: *mut ext::RawVkDebugReportCallbackCreateInfo, allocator: *const c_void, callback: *mut ext::RawVkDebugReportCallback) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDebugReportCallbackEXT\"");
}
unsafe extern fn null_vkDestroyDebugReportCallbackEXT(instance: RawVkInstance, callback: ext::RawVkDebugReportCallback, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDebugReportCallbackEXT\"");
}
unsafe extern fn null_vkDebugReportMessageEXT(instance: RawVkInstance, flags: ext::RawVkDebugReportFlags, object_type: ext::RawVkDebugReportObjectType, object: u64, location: usize, message_code: i32, layer_prefix: *mut c_char, message: *mut c_char) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDebugReportMessageEXT\"");
}
unsafe extern fn null_vkDebugMarkerSetObjectTagEXT(device: RawVkDevice, tag_info: *mut ext::RawVkDebugMarkerObjectTagInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDebugMarkerSetObjectTagEXT\"");
}
unsafe extern fn null_vkDebugMarkerSetObjectNameEXT(device: RawVkDevice, name_info: *mut ext::RawVkDebugMarkerObjectNameInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDebugMarkerSetObjectNameEXT\"");
}
unsafe extern fn null_vkCmdDebugMarkerBeginEXT(command_buffer: RawVkCommandBuffer, marker_info: *mut ext::RawVkDebugMarkerMarkerInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDebugMarkerBeginEXT\"");
}
unsafe extern fn null_vkCmdDebugMarkerEndEXT(command_buffer: RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDebugMarkerEndEXT\"");
}
unsafe extern fn null_vkCmdDebugMarkerInsertEXT(command_buffer: RawVkCommandBuffer, marker_info: *mut ext::RawVkDebugMarkerMarkerInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDebugMarkerInsertEXT\"");
}
unsafe extern fn null_vkCmdDrawIndirectCountAMD(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, count_buffer: RawVkBuffer, count_buffer_offset: u64, max_draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndirectCountAMD\"");
}
unsafe extern fn null_vkCmdDrawIndexedIndirectCountAMD(command_buffer: RawVkCommandBuffer, buffer: RawVkBuffer, offset: u64, count_buffer: RawVkBuffer, count_buffer_offset: u64, max_draw_count: u32, stride: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdDrawIndexedIndirectCountAMD\"");
}
unsafe extern fn null_vkGetShaderInfoAMD(device: RawVkDevice, pipeline: RawVkPipeline, shader_stage: RawVkShaderStageFlags, info_type: amd::RawVkShaderInfoType, info_size: *mut usize, info: *mut c_void) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetShaderInfoAMD\"");
}
unsafe extern fn null_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physical_device: RawVkPhysicalDevice, format: RawVkFormat, type_: RawVkImageType, tiling: RawVkImageTiling, usage: RawVkImageUsageFlags, flags: RawVkImageCreateFlags, external_handle_type: nv::RawVkExternalMemoryHandleTypeFlags, external_image_format_properties: *mut nv::RawVkExternalImageFormatProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\"");
}
unsafe extern fn null_vkCmdBeginConditionalRenderingEXT(command_buffer: RawVkCommandBuffer, conditional_rendering_begin: *mut ext::RawVkConditionalRenderingBeginInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBeginConditionalRenderingEXT\"");
}
unsafe extern fn null_vkCmdEndConditionalRenderingEXT(command_buffer: RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdEndConditionalRenderingEXT\"");
}
unsafe extern fn null_vkCmdProcessCommandsNVX(command_buffer: RawVkCommandBuffer, process_commands_info: *mut nvx::RawVkCmdProcessCommandsInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdProcessCommandsNVX\"");
}
unsafe extern fn null_vkCmdReserveSpaceForCommandsNVX(command_buffer: RawVkCommandBuffer, reserve_space_info: *mut nvx::RawVkCmdReserveSpaceForCommandsInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdReserveSpaceForCommandsNVX\"");
}
unsafe extern fn null_vkCreateIndirectCommandsLayoutNVX(device: RawVkDevice, create_info: *mut nvx::RawVkIndirectCommandsLayoutCreateInfo, allocator: *const c_void, indirect_commands_layout: *mut nvx::RawVkIndirectCommandsLayout) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateIndirectCommandsLayoutNVX\"");
}
unsafe extern fn null_vkDestroyIndirectCommandsLayoutNVX(device: RawVkDevice, indirect_commands_layout: nvx::RawVkIndirectCommandsLayout, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyIndirectCommandsLayoutNVX\"");
}
unsafe extern fn null_vkCreateObjectTableNVX(device: RawVkDevice, create_info: *mut nvx::RawVkObjectTableCreateInfo, allocator: *const c_void, object_table: *mut nvx::RawVkObjectTable) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateObjectTableNVX\"");
}
unsafe extern fn null_vkDestroyObjectTableNVX(device: RawVkDevice, object_table: nvx::RawVkObjectTable, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyObjectTableNVX\"");
}
unsafe extern fn null_vkRegisterObjectsNVX(device: RawVkDevice, object_table: nvx::RawVkObjectTable, object_count: u32, object_table_entries: *mut *mut nvx::RawVkObjectTableEntry, object_indices: *mut u32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkRegisterObjectsNVX\"");
}
unsafe extern fn null_vkUnregisterObjectsNVX(device: RawVkDevice, object_table: nvx::RawVkObjectTable, object_count: u32, object_entry_types: *mut nvx::RawVkObjectEntryType, object_indices: *mut u32) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkUnregisterObjectsNVX\"");
}
unsafe extern fn null_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(physical_device: RawVkPhysicalDevice, features: *mut nvx::RawVkDeviceGeneratedCommandsFeatures, limits: *mut nvx::RawVkDeviceGeneratedCommandsLimits) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX\"");
}
unsafe extern fn null_vkCmdSetViewportWScalingNV(command_buffer: RawVkCommandBuffer, first_viewport: u32, viewport_count: u32, viewport_wscalings: *mut nv::RawVkViewportWScaling) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetViewportWScalingNV\"");
}
unsafe extern fn null_vkReleaseDisplayEXT(physical_device: RawVkPhysicalDevice, display: khr::RawVkDisplay) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkReleaseDisplayEXT\"");
}
unsafe extern fn null_vkGetPhysicalDeviceSurfaceCapabilities2EXT(physical_device: RawVkPhysicalDevice, surface: khr::RawVkSurface, surface_capabilities: *mut ext::RawVkSurfaceCapabilities2) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceSurfaceCapabilities2EXT\"");
}
unsafe extern fn null_vkDisplayPowerControlEXT(device: RawVkDevice, display: khr::RawVkDisplay, display_power_info: *mut ext::RawVkDisplayPowerInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDisplayPowerControlEXT\"");
}
unsafe extern fn null_vkRegisterDeviceEventEXT(device: RawVkDevice, device_event_info: *mut ext::RawVkDeviceEventInfo, allocator: *const c_void, fence: *mut RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkRegisterDeviceEventEXT\"");
}
unsafe extern fn null_vkRegisterDisplayEventEXT(device: RawVkDevice, display: khr::RawVkDisplay, display_event_info: *mut ext::RawVkDisplayEventInfo, allocator: *const c_void, fence: *mut RawVkFence) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkRegisterDisplayEventEXT\"");
}
unsafe extern fn null_vkGetSwapchainCounterEXT(device: RawVkDevice, swapchain: khr::RawVkSwapchain, counter: ext::RawVkSurfaceCounterFlags, counter_value: *mut u64) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetSwapchainCounterEXT\"");
}
unsafe extern fn null_vkGetRefreshCycleDurationGOOGLE(device: RawVkDevice, swapchain: khr::RawVkSwapchain, display_timing_properties: *mut google::RawVkRefreshCycleDuration) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetRefreshCycleDurationGOOGLE\"");
}
unsafe extern fn null_vkGetPastPresentationTimingGOOGLE(device: RawVkDevice, swapchain: khr::RawVkSwapchain, presentation_timing_count: *mut u32, presentation_timings: *mut google::RawVkPastPresentationTiming) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPastPresentationTimingGOOGLE\"");
}
unsafe extern fn null_vkCmdSetDiscardRectangleEXT(command_buffer: RawVkCommandBuffer, first_discard_rectangle: u32, discard_rectangle_count: u32, discard_rectangles: *mut RawVkRect2D) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetDiscardRectangleEXT\"");
}
unsafe extern fn null_vkSetHdrMetadataEXT(device: RawVkDevice, swapchain_count: u32, swapchains: *mut khr::RawVkSwapchain, metadata: *mut ext::RawVkHdrMetadata) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkSetHdrMetadataEXT\"");
}
unsafe extern fn null_vkSetDebugUtilsObjectNameEXT(device: RawVkDevice, name_info: *mut ext::RawVkDebugUtilsObjectNameInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkSetDebugUtilsObjectNameEXT\"");
}
unsafe extern fn null_vkSetDebugUtilsObjectTagEXT(device: RawVkDevice, tag_info: *mut ext::RawVkDebugUtilsObjectTagInfo) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkSetDebugUtilsObjectTagEXT\"");
}
unsafe extern fn null_vkQueueBeginDebugUtilsLabelEXT(queue: RawVkQueue, label_info: *mut ext::RawVkDebugUtilsLabel) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueBeginDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkQueueEndDebugUtilsLabelEXT(queue: RawVkQueue) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueEndDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkQueueInsertDebugUtilsLabelEXT(queue: RawVkQueue, label_info: *mut ext::RawVkDebugUtilsLabel) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkQueueInsertDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkCmdBeginDebugUtilsLabelEXT(command_buffer: RawVkCommandBuffer, label_info: *mut ext::RawVkDebugUtilsLabel) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdBeginDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkCmdEndDebugUtilsLabelEXT(command_buffer: RawVkCommandBuffer) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdEndDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkCmdInsertDebugUtilsLabelEXT(command_buffer: RawVkCommandBuffer, label_info: *mut ext::RawVkDebugUtilsLabel) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdInsertDebugUtilsLabelEXT\"");
}
unsafe extern fn null_vkCreateDebugUtilsMessengerEXT(instance: RawVkInstance, create_info: *mut ext::RawVkDebugUtilsMessengerCreateInfo, allocator: *const c_void, messenger: *mut ext::RawVkDebugUtilsMessenger) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateDebugUtilsMessengerEXT\"");
}
unsafe extern fn null_vkDestroyDebugUtilsMessengerEXT(instance: RawVkInstance, messenger: ext::RawVkDebugUtilsMessenger, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyDebugUtilsMessengerEXT\"");
}
unsafe extern fn null_vkSubmitDebugUtilsMessageEXT(instance: RawVkInstance, message_severity: ext::RawVkDebugUtilsMessageSeverityFlags, message_types: ext::RawVkDebugUtilsMessageTypeFlags, callback_data: *mut ext::RawVkDebugUtilsMessengerCallbackData) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkSubmitDebugUtilsMessageEXT\"");
}
unsafe extern fn null_vkCmdSetSampleLocationsEXT(command_buffer: RawVkCommandBuffer, sample_locations_info: *mut ext::RawVkSampleLocationsInfo) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetSampleLocationsEXT\"");
}
unsafe extern fn null_vkGetPhysicalDeviceMultisamplePropertiesEXT(physical_device: RawVkPhysicalDevice, samples: RawVkSampleCountFlags, multisample_properties: *mut ext::RawVkMultisampleProperties) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetPhysicalDeviceMultisamplePropertiesEXT\"");
}
unsafe extern fn null_vkCreateValidationCacheEXT(device: RawVkDevice, create_info: *mut ext::RawVkValidationCacheCreateInfo, allocator: *const c_void, validation_cache: *mut ext::RawVkValidationCache) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCreateValidationCacheEXT\"");
}
unsafe extern fn null_vkDestroyValidationCacheEXT(device: RawVkDevice, validation_cache: ext::RawVkValidationCache, allocator: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkDestroyValidationCacheEXT\"");
}
unsafe extern fn null_vkMergeValidationCachesEXT(device: RawVkDevice, dst_cache: ext::RawVkValidationCache, src_cache_count: u32, src_caches: *mut ext::RawVkValidationCache) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkMergeValidationCachesEXT\"");
}
unsafe extern fn null_vkGetValidationCacheDataEXT(device: RawVkDevice, validation_cache: ext::RawVkValidationCache, data_size: *mut usize, data: *mut c_void) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetValidationCacheDataEXT\"");
}
unsafe extern fn null_vkGetMemoryHostPointerPropertiesEXT(device: RawVkDevice, handle_type: RawVkExternalMemoryHandleTypeFlags, host_pointer: *const c_void, memory_host_pointer_properties: *mut ext::RawVkMemoryHostPointerProperties) -> RawVkResult {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetMemoryHostPointerPropertiesEXT\"");
}
unsafe extern fn null_vkCmdWriteBufferMarkerAMD(command_buffer: RawVkCommandBuffer, pipeline_stage: RawVkPipelineStageFlags, dst_buffer: RawVkBuffer, dst_offset: u64, marker: u32) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdWriteBufferMarkerAMD\"");
}
unsafe extern fn null_vkCmdSetCheckpointNV(command_buffer: RawVkCommandBuffer, checkpoint_marker: *const c_void) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkCmdSetCheckpointNV\"");
}
unsafe extern fn null_vkGetQueueCheckpointDataNV(queue: RawVkQueue, checkpoint_data_count: *mut u32, checkpoint_data: *mut nv::RawVkCheckpointData) {
    panic!("\"vkGetInstanceProcAddr\" returned NULL for \"vkGetQueueCheckpointDataNV\"");
}