xref: /third_party/vk-gl-cts/build/external/vulkancts/framework/vulkan/vkNullDriverImpl.inl

/* WARNING: This is auto-generated file. Do not modify, since changes will
 * be lost! Modify the generating script instead.
 * This file was generated by /scripts/gen_framework.py
 */

VKAPI_ATTR VkResult VKAPI_CALL createInstance (const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pInstance = allocateHandle<Instance, VkInstance>(pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDevice (VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pDevice = allocateHandle<Device, VkDevice>(physicalDevice, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createFence (VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pFence = allocateNonDispHandle<Fence, VkFence>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createSemaphore (VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSemaphore = allocateNonDispHandle<Semaphore, VkSemaphore>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createEvent (VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pEvent = allocateNonDispHandle<Event, VkEvent>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createQueryPool (VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pQueryPool = allocateNonDispHandle<QueryPool, VkQueryPool>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createBuffer (VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pBuffer = allocateNonDispHandle<Buffer, VkBuffer>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createBufferView (VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pView = allocateNonDispHandle<BufferView, VkBufferView>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createImage (VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pImage = allocateNonDispHandle<Image, VkImage>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createImageView (VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pView = allocateNonDispHandle<ImageView, VkImageView>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createShaderModule (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pShaderModule = allocateNonDispHandle<ShaderModule, VkShaderModule>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createPipelineCache (VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pPipelineCache = allocateNonDispHandle<PipelineCache, VkPipelineCache>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createPipelineLayout (VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pPipelineLayout = allocateNonDispHandle<PipelineLayout, VkPipelineLayout>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createSampler (VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSampler = allocateNonDispHandle<Sampler, VkSampler>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDescriptorSetLayout (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSetLayout = allocateNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDescriptorPool (VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pDescriptorPool = allocateNonDispHandle<DescriptorPool, VkDescriptorPool>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createFramebuffer (VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pFramebuffer = allocateNonDispHandle<Framebuffer, VkFramebuffer>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createRenderPass (VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createCommandPool (VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pCommandPool = allocateNonDispHandle<CommandPool, VkCommandPool>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createOHOSSurfaceOpenHarmony (VkInstance instance, const VkOHOSSurfaceCreateInfoOpenHarmony* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDisplayPlaneSurfaceKHR (VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createSwapchainKHR (VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSwapchain = allocateNonDispHandle<SwapchainKHR, VkSwapchainKHR>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createViSurfaceNN (VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createWaylandSurfaceKHR (VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createXlibSurfaceKHR (VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createXcbSurfaceKHR (VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createImagePipeSurfaceFUCHSIA (VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createStreamDescriptorSurfaceGGP (VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createScreenSurfaceQNX (VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDebugReportCallbackEXT (VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pCallback = allocateNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createIndirectCommandsLayoutNV (VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pIndirectCommandsLayout = allocateNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDescriptorUpdateTemplate (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pDescriptorUpdateTemplate = allocateNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createIOSSurfaceMVK (VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createMacOSSurfaceMVK (VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createMetalSurfaceEXT (VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createSamplerYcbcrConversion (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pYcbcrConversion = allocateNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createValidationCacheEXT (VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pValidationCache = allocateNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDebugUtilsMessengerEXT (VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pMessenger = allocateNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createRenderPass2 (VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pRenderPass = allocateNonDispHandle<RenderPass, VkRenderPass>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureNV (VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createHeadlessSurfaceEXT (VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSurface = allocateNonDispHandle<SurfaceKHR, VkSurfaceKHR>(instance, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createAccelerationStructureKHR (VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pAccelerationStructure = allocateNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createDeferredOperationKHR (VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pDeferredOperation = allocateNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(device, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createPrivateDataSlot (VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pPrivateDataSlot = allocateNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionKHR (VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pVideoSession = allocateNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createVideoSessionParametersKHR (VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pVideoSessionParameters = allocateNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createCuModuleNVX (VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pModule = allocateNonDispHandle<CuModuleNVX, VkCuModuleNVX>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createCuFunctionNVX (VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pFunction = allocateNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createBufferCollectionFUCHSIA (VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pCollection = allocateNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createMicromapEXT (VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pMicromap = allocateNonDispHandle<MicromapEXT, VkMicromapEXT>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR VkResult VKAPI_CALL createOpticalFlowSessionNV (VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession)
{
	DE_UNREF(pAllocator);
	VK_NULL_RETURN((*pSession = allocateNonDispHandle<OpticalFlowSessionNV, VkOpticalFlowSessionNV>(device, pCreateInfo, pAllocator)));
}

VKAPI_ATTR void VKAPI_CALL destroyInstance (VkInstance instance, const VkAllocationCallbacks* pAllocator)
{
	freeHandle<Instance, VkInstance>(instance, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDevice (VkDevice device, const VkAllocationCallbacks* pAllocator)
{
	freeHandle<Device, VkDevice>(device, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL freeMemory (VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<DeviceMemory, VkDeviceMemory>(memory, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyFence (VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Fence, VkFence>(fence, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroySemaphore (VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Semaphore, VkSemaphore>(semaphore, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyEvent (VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Event, VkEvent>(event, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyQueryPool (VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<QueryPool, VkQueryPool>(queryPool, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyBuffer (VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Buffer, VkBuffer>(buffer, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyBufferView (VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<BufferView, VkBufferView>(bufferView, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyImage (VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Image, VkImage>(image, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyImageView (VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<ImageView, VkImageView>(imageView, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyShaderModule (VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<ShaderModule, VkShaderModule>(shaderModule, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyPipelineCache (VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<PipelineCache, VkPipelineCache>(pipelineCache, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyPipeline (VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Pipeline, VkPipeline>(pipeline, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyPipelineLayout (VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<PipelineLayout, VkPipelineLayout>(pipelineLayout, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroySampler (VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Sampler, VkSampler>(sampler, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDescriptorSetLayout (VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<DescriptorSetLayout, VkDescriptorSetLayout>(descriptorSetLayout, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDescriptorPool (VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<DescriptorPool, VkDescriptorPool>(descriptorPool, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyFramebuffer (VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<Framebuffer, VkFramebuffer>(framebuffer, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyRenderPass (VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<RenderPass, VkRenderPass>(renderPass, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyCommandPool (VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<CommandPool, VkCommandPool>(commandPool, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroySurfaceKHR (VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(instance);
	freeNonDispHandle<SurfaceKHR, VkSurfaceKHR>(surface, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroySwapchainKHR (VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<SwapchainKHR, VkSwapchainKHR>(swapchain, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDebugReportCallbackEXT (VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(instance);
	freeNonDispHandle<DebugReportCallbackEXT, VkDebugReportCallbackEXT>(callback, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyIndirectCommandsLayoutNV (VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<IndirectCommandsLayoutNV, VkIndirectCommandsLayoutNV>(indirectCommandsLayout, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDescriptorUpdateTemplate (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<DescriptorUpdateTemplate, VkDescriptorUpdateTemplate>(descriptorUpdateTemplate, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroySamplerYcbcrConversion (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<SamplerYcbcrConversion, VkSamplerYcbcrConversion>(ycbcrConversion, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyValidationCacheEXT (VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<ValidationCacheEXT, VkValidationCacheEXT>(validationCache, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDebugUtilsMessengerEXT (VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(instance);
	freeNonDispHandle<DebugUtilsMessengerEXT, VkDebugUtilsMessengerEXT>(messenger, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureKHR (VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<AccelerationStructureKHR, VkAccelerationStructureKHR>(accelerationStructure, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyAccelerationStructureNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<AccelerationStructureNV, VkAccelerationStructureNV>(accelerationStructure, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyDeferredOperationKHR (VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<DeferredOperationKHR, VkDeferredOperationKHR>(operation, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyPrivateDataSlot (VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<PrivateDataSlot, VkPrivateDataSlot>(privateDataSlot, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyVideoSessionKHR (VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<VideoSessionKHR, VkVideoSessionKHR>(videoSession, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<VideoSessionParametersKHR, VkVideoSessionParametersKHR>(videoSessionParameters, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyCuModuleNVX (VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<CuModuleNVX, VkCuModuleNVX>(module, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyCuFunctionNVX (VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<CuFunctionNVX, VkCuFunctionNVX>(function, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyBufferCollectionFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<BufferCollectionFUCHSIA, VkBufferCollectionFUCHSIA>(collection, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyMicromapEXT (VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<MicromapEXT, VkMicromapEXT>(micromap, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL destroyOpticalFlowSessionNV (VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator)
{
	DE_UNREF(device);
	freeNonDispHandle<OpticalFlowSessionNV, VkOpticalFlowSessionNV>(session, pAllocator);
}

VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceVersion (uint32_t* pApiVersion)
{
	DE_UNREF(pApiVersion);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL enumerateInstanceLayerProperties (uint32_t* pPropertyCount, VkLayerProperties* pProperties)
{
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL enumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL queueSubmit (VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
	DE_UNREF(queue);
	DE_UNREF(submitCount);
	DE_UNREF(pSubmits);
	DE_UNREF(fence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL queueWaitIdle (VkQueue queue)
{
	DE_UNREF(queue);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL deviceWaitIdle (VkDevice device)
{
	DE_UNREF(device);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL flushMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
	DE_UNREF(device);
	DE_UNREF(memoryRangeCount);
	DE_UNREF(pMemoryRanges);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL invalidateMappedMemoryRanges (VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
	DE_UNREF(device);
	DE_UNREF(memoryRangeCount);
	DE_UNREF(pMemoryRanges);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getDeviceMemoryCommitment (VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
{
	DE_UNREF(device);
	DE_UNREF(memory);
	DE_UNREF(pCommittedMemoryInBytes);
}

VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory (VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
	DE_UNREF(device);
	DE_UNREF(buffer);
	DE_UNREF(memory);
	DE_UNREF(memoryOffset);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory (VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
	DE_UNREF(device);
	DE_UNREF(image);
	DE_UNREF(memory);
	DE_UNREF(memoryOffset);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements (VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(image);
	DE_UNREF(pSparseMemoryRequirementCount);
	DE_UNREF(pSparseMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(format);
	DE_UNREF(type);
	DE_UNREF(samples);
	DE_UNREF(usage);
	DE_UNREF(tiling);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL queueBindSparse (VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
{
	DE_UNREF(queue);
	DE_UNREF(bindInfoCount);
	DE_UNREF(pBindInfo);
	DE_UNREF(fence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL resetFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences)
{
	DE_UNREF(device);
	DE_UNREF(fenceCount);
	DE_UNREF(pFences);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getFenceStatus (VkDevice device, VkFence fence)
{
	DE_UNREF(device);
	DE_UNREF(fence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL waitForFences (VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
{
	DE_UNREF(device);
	DE_UNREF(fenceCount);
	DE_UNREF(pFences);
	DE_UNREF(waitAll);
	DE_UNREF(timeout);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getEventStatus (VkDevice device, VkEvent event)
{
	DE_UNREF(device);
	DE_UNREF(event);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setEvent (VkDevice device, VkEvent event)
{
	DE_UNREF(device);
	DE_UNREF(event);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL resetEvent (VkDevice device, VkEvent event)
{
	DE_UNREF(device);
	DE_UNREF(event);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getQueryPoolResults (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
{
	DE_UNREF(device);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
	DE_UNREF(queryCount);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	DE_UNREF(stride);
	DE_UNREF(flags);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL resetQueryPool (VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
	DE_UNREF(device);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
	DE_UNREF(queryCount);
}

VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout (VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
{
	DE_UNREF(device);
	DE_UNREF(image);
	DE_UNREF(pSubresource);
	DE_UNREF(pLayout);
}

VKAPI_ATTR VkResult VKAPI_CALL getPipelineCacheData (VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pipelineCache);
	DE_UNREF(pDataSize);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL mergePipelineCaches (VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
{
	DE_UNREF(device);
	DE_UNREF(dstCache);
	DE_UNREF(srcCacheCount);
	DE_UNREF(pSrcCaches);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI (VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
{
	DE_UNREF(device);
	DE_UNREF(renderpass);
	DE_UNREF(pMaxWorkgroupSize);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL updateDescriptorSets (VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
	DE_UNREF(device);
	DE_UNREF(descriptorWriteCount);
	DE_UNREF(pDescriptorWrites);
	DE_UNREF(descriptorCopyCount);
	DE_UNREF(pDescriptorCopies);
}

VKAPI_ATTR void VKAPI_CALL getRenderAreaGranularity (VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
{
	DE_UNREF(device);
	DE_UNREF(renderPass);
	DE_UNREF(pGranularity);
}

VKAPI_ATTR VkResult VKAPI_CALL resetCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
{
	DE_UNREF(device);
	DE_UNREF(commandPool);
	DE_UNREF(flags);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL beginCommandBuffer (VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pBeginInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL endCommandBuffer (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL resetCommandBuffer (VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(flags);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdBindPipeline (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(pipeline);
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewport (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstViewport);
	DE_UNREF(viewportCount);
	DE_UNREF(pViewports);
}

VKAPI_ATTR void VKAPI_CALL cmdSetScissor (VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstScissor);
	DE_UNREF(scissorCount);
	DE_UNREF(pScissors);
}

VKAPI_ATTR void VKAPI_CALL cmdSetLineWidth (VkCommandBuffer commandBuffer, float lineWidth)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(lineWidth);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthBias (VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthBiasConstantFactor);
	DE_UNREF(depthBiasClamp);
	DE_UNREF(depthBiasSlopeFactor);
}

VKAPI_ATTR void VKAPI_CALL cmdSetBlendConstants (VkCommandBuffer commandBuffer, const float blendConstants[4])
{
	DE_UNREF(commandBuffer);
	DE_UNREF(blendConstants);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthBounds (VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(minDepthBounds);
	DE_UNREF(maxDepthBounds);
}

VKAPI_ATTR void VKAPI_CALL cmdSetStencilCompareMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(faceMask);
	DE_UNREF(compareMask);
}

VKAPI_ATTR void VKAPI_CALL cmdSetStencilWriteMask (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(faceMask);
	DE_UNREF(writeMask);
}

VKAPI_ATTR void VKAPI_CALL cmdSetStencilReference (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(faceMask);
	DE_UNREF(reference);
}

VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorSets (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(layout);
	DE_UNREF(firstSet);
	DE_UNREF(descriptorSetCount);
	DE_UNREF(pDescriptorSets);
	DE_UNREF(dynamicOffsetCount);
	DE_UNREF(pDynamicOffsets);
}

VKAPI_ATTR void VKAPI_CALL cmdBindIndexBuffer (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(indexType);
}

VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstBinding);
	DE_UNREF(bindingCount);
	DE_UNREF(pBuffers);
	DE_UNREF(pOffsets);
}

VKAPI_ATTR void VKAPI_CALL cmdDraw (VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(vertexCount);
	DE_UNREF(instanceCount);
	DE_UNREF(firstVertex);
	DE_UNREF(firstInstance);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndexed (VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(indexCount);
	DE_UNREF(instanceCount);
	DE_UNREF(firstIndex);
	DE_UNREF(vertexOffset);
	DE_UNREF(firstInstance);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMultiEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(drawCount);
	DE_UNREF(pVertexInfo);
	DE_UNREF(instanceCount);
	DE_UNREF(firstInstance);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMultiIndexedEXT (VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(drawCount);
	DE_UNREF(pIndexInfo);
	DE_UNREF(instanceCount);
	DE_UNREF(firstInstance);
	DE_UNREF(stride);
	DE_UNREF(pVertexOffset);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(drawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(drawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDispatch (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(groupCountX);
	DE_UNREF(groupCountY);
	DE_UNREF(groupCountZ);
}

VKAPI_ATTR void VKAPI_CALL cmdDispatchIndirect (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
}

VKAPI_ATTR void VKAPI_CALL cmdSubpassShadingHUAWEI (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcBuffer);
	DE_UNREF(dstBuffer);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcImage);
	DE_UNREF(srcImageLayout);
	DE_UNREF(dstImage);
	DE_UNREF(dstImageLayout);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdBlitImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcImage);
	DE_UNREF(srcImageLayout);
	DE_UNREF(dstImage);
	DE_UNREF(dstImageLayout);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
	DE_UNREF(filter);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage (VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcBuffer);
	DE_UNREF(dstImage);
	DE_UNREF(dstImageLayout);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcImage);
	DE_UNREF(srcImageLayout);
	DE_UNREF(dstBuffer);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryIndirectNV (VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(copyBufferAddress);
	DE_UNREF(copyCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToImageIndirectNV (VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(copyBufferAddress);
	DE_UNREF(copyCount);
	DE_UNREF(stride);
	DE_UNREF(dstImage);
	DE_UNREF(dstImageLayout);
	DE_UNREF(pImageSubresources);
}

VKAPI_ATTR void VKAPI_CALL cmdUpdateBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(dstBuffer);
	DE_UNREF(dstOffset);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
}

VKAPI_ATTR void VKAPI_CALL cmdFillBuffer (VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(dstBuffer);
	DE_UNREF(dstOffset);
	DE_UNREF(size);
	DE_UNREF(data);
}

VKAPI_ATTR void VKAPI_CALL cmdClearColorImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(image);
	DE_UNREF(imageLayout);
	DE_UNREF(pColor);
	DE_UNREF(rangeCount);
	DE_UNREF(pRanges);
}

VKAPI_ATTR void VKAPI_CALL cmdClearDepthStencilImage (VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(image);
	DE_UNREF(imageLayout);
	DE_UNREF(pDepthStencil);
	DE_UNREF(rangeCount);
	DE_UNREF(pRanges);
}

VKAPI_ATTR void VKAPI_CALL cmdClearAttachments (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(attachmentCount);
	DE_UNREF(pAttachments);
	DE_UNREF(rectCount);
	DE_UNREF(pRects);
}

VKAPI_ATTR void VKAPI_CALL cmdResolveImage (VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcImage);
	DE_UNREF(srcImageLayout);
	DE_UNREF(dstImage);
	DE_UNREF(dstImageLayout);
	DE_UNREF(regionCount);
	DE_UNREF(pRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdSetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(event);
	DE_UNREF(stageMask);
}

VKAPI_ATTR void VKAPI_CALL cmdResetEvent (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(event);
	DE_UNREF(stageMask);
}

VKAPI_ATTR void VKAPI_CALL cmdWaitEvents (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(eventCount);
	DE_UNREF(pEvents);
	DE_UNREF(srcStageMask);
	DE_UNREF(dstStageMask);
	DE_UNREF(memoryBarrierCount);
	DE_UNREF(pMemoryBarriers);
	DE_UNREF(bufferMemoryBarrierCount);
	DE_UNREF(pBufferMemoryBarriers);
	DE_UNREF(imageMemoryBarrierCount);
	DE_UNREF(pImageMemoryBarriers);
}

VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier (VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(srcStageMask);
	DE_UNREF(dstStageMask);
	DE_UNREF(dependencyFlags);
	DE_UNREF(memoryBarrierCount);
	DE_UNREF(pMemoryBarriers);
	DE_UNREF(bufferMemoryBarrierCount);
	DE_UNREF(pBufferMemoryBarriers);
	DE_UNREF(imageMemoryBarrierCount);
	DE_UNREF(pImageMemoryBarriers);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(query);
	DE_UNREF(flags);
}

VKAPI_ATTR void VKAPI_CALL cmdEndQuery (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(query);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginConditionalRenderingEXT (VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pConditionalRenderingBegin);
}

VKAPI_ATTR void VKAPI_CALL cmdEndConditionalRenderingEXT (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL cmdResetQueryPool (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
	DE_UNREF(queryCount);
}

VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineStage);
	DE_UNREF(queryPool);
	DE_UNREF(query);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyQueryPoolResults (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
	DE_UNREF(queryCount);
	DE_UNREF(dstBuffer);
	DE_UNREF(dstOffset);
	DE_UNREF(stride);
	DE_UNREF(flags);
}

VKAPI_ATTR void VKAPI_CALL cmdPushConstants (VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(layout);
	DE_UNREF(stageFlags);
	DE_UNREF(offset);
	DE_UNREF(size);
	DE_UNREF(pValues);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pRenderPassBegin);
	DE_UNREF(contents);
}

VKAPI_ATTR void VKAPI_CALL cmdNextSubpass (VkCommandBuffer commandBuffer, VkSubpassContents contents)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(contents);
}

VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL cmdExecuteCommands (VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(commandBufferCount);
	DE_UNREF(pCommandBuffers);
}

VKAPI_ATTR VkResult VKAPI_CALL getOHOSNativeBufferPropertiesOpenHarmony (VkDevice device, const struct OH_NativeBuffer* buffer, VkOHOSNativeBufferPropertiesOpenHarmony* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(buffer);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlanePropertiesKHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneSupportedDisplaysKHR (VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(planeIndex);
	DE_UNREF(pDisplayCount);
	DE_UNREF(pDisplays);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDisplayModePropertiesKHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(display);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(mode);
	DE_UNREF(planeIndex);
	DE_UNREF(pCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(surface);
	DE_UNREF(pSupported);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilitiesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(surface);
	DE_UNREF(pSurfaceCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormatsKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(surface);
	DE_UNREF(pSurfaceFormatCount);
	DE_UNREF(pSurfaceFormats);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(surface);
	DE_UNREF(pPresentModeCount);
	DE_UNREF(pPresentModes);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getSwapchainImagesKHR (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(pSwapchainImageCount);
	DE_UNREF(pSwapchainImages);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquireNextImageKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(timeout);
	DE_UNREF(semaphore);
	DE_UNREF(fence);
	DE_UNREF(pImageIndex);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
{
	DE_UNREF(queue);
	DE_UNREF(pPresentInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWaylandPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::WaylandDisplayPtr display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	return VK_SUCCESS;
}

VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXlibPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XlibDisplayPtr dpy, pt::XlibVisualID visualID)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(dpy);
	DE_UNREF(visualID);
	return VK_SUCCESS;
}

VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceXcbPresentationSupportKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::XcbConnectionPtr connection, pt::XcbVisualid visual_id)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(connection);
	DE_UNREF(visual_id);
	return VK_SUCCESS;
}

VKAPI_ATTR VkBool32 VKAPI_CALL getPhysicalDeviceScreenPresentationSupportQNX (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, pt::QNXScreenWindowPtr window)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(window);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL debugReportMessageEXT (VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage)
{
	DE_UNREF(instance);
	DE_UNREF(flags);
	DE_UNREF(objectType);
	DE_UNREF(object);
	DE_UNREF(location);
	DE_UNREF(messageCode);
	DE_UNREF(pLayerPrefix);
	DE_UNREF(pMessage);
}

VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
	DE_UNREF(device);
	DE_UNREF(pNameInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
	DE_UNREF(device);
	DE_UNREF(pTagInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pMarkerInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerEndEXT (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL cmdDebugMarkerInsertEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pMarkerInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceExternalImageFormatPropertiesNV (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(format);
	DE_UNREF(type);
	DE_UNREF(tiling);
	DE_UNREF(usage);
	DE_UNREF(flags);
	DE_UNREF(externalHandleType);
	DE_UNREF(pExternalImageFormatProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleNV (VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, pt::Win32Handle* pHandle)
{
	DE_UNREF(device);
	DE_UNREF(memory);
	DE_UNREF(handleType);
	DE_UNREF(pHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdExecuteGeneratedCommandsNV (VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(isPreprocessed);
	DE_UNREF(pGeneratedCommandsInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdPreprocessGeneratedCommandsNV (VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pGeneratedCommandsInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdBindPipelineShaderGroupNV (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(pipeline);
	DE_UNREF(groupIndex);
}

VKAPI_ATTR void VKAPI_CALL getGeneratedCommandsMemoryRequirementsNV (VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pFeatures);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pProperties);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFormatProperties2 (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(format);
	DE_UNREF(pFormatProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pImageFormatInfo);
	DE_UNREF(pImageFormatProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties2 (VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pQueueFamilyPropertyCount);
	DE_UNREF(pQueueFamilyProperties);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMemoryProperties2 (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pMemoryProperties);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceSparseImageFormatProperties2 (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pFormatInfo);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
}

VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(layout);
	DE_UNREF(set);
	DE_UNREF(descriptorWriteCount);
	DE_UNREF(pDescriptorWrites);
}

VKAPI_ATTR void VKAPI_CALL trimCommandPool (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
	DE_UNREF(device);
	DE_UNREF(commandPool);
	DE_UNREF(flags);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pExternalBufferInfo);
	DE_UNREF(pExternalBufferProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
{
	DE_UNREF(device);
	DE_UNREF(pGetWin32HandleInfo);
	DE_UNREF(pHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
	DE_UNREF(device);
	DE_UNREF(handleType);
	DE_UNREF(handle);
	DE_UNREF(pMemoryWin32HandleProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
{
	DE_UNREF(device);
	DE_UNREF(pGetFdInfo);
	DE_UNREF(pFd);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryFdPropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
	DE_UNREF(device);
	DE_UNREF(handleType);
	DE_UNREF(fd);
	DE_UNREF(pMemoryFdProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandleFUCHSIA (VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
{
	DE_UNREF(device);
	DE_UNREF(pGetZirconHandleInfo);
	DE_UNREF(pZirconHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryZirconHandlePropertiesFUCHSIA (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
{
	DE_UNREF(device);
	DE_UNREF(handleType);
	DE_UNREF(zirconHandle);
	DE_UNREF(pMemoryZirconHandleProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryRemoteAddressNV (VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
{
	DE_UNREF(device);
	DE_UNREF(pMemoryGetRemoteAddressInfo);
	DE_UNREF(pAddress);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalSemaphoreProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pExternalSemaphoreInfo);
	DE_UNREF(pExternalSemaphoreProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreWin32HandleKHR (VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
{
	DE_UNREF(device);
	DE_UNREF(pGetWin32HandleInfo);
	DE_UNREF(pHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreWin32HandleKHR (VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
	DE_UNREF(device);
	DE_UNREF(pImportSemaphoreWin32HandleInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
{
	DE_UNREF(device);
	DE_UNREF(pGetFdInfo);
	DE_UNREF(pFd);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreFdKHR (VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
	DE_UNREF(device);
	DE_UNREF(pImportSemaphoreFdInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, pt::zx_handle_t* pZirconHandle)
{
	DE_UNREF(device);
	DE_UNREF(pGetZirconHandleInfo);
	DE_UNREF(pZirconHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL importSemaphoreZirconHandleFUCHSIA (VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
{
	DE_UNREF(device);
	DE_UNREF(pImportSemaphoreZirconHandleInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalFenceProperties (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pExternalFenceInfo);
	DE_UNREF(pExternalFenceProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle)
{
	DE_UNREF(device);
	DE_UNREF(pGetWin32HandleInfo);
	DE_UNREF(pHandle);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
	DE_UNREF(device);
	DE_UNREF(pImportFenceWin32HandleInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
{
	DE_UNREF(device);
	DE_UNREF(pGetFdInfo);
	DE_UNREF(pFd);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
	DE_UNREF(device);
	DE_UNREF(pImportFenceFdInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL releaseDisplayEXT (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquireXlibDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, VkDisplayKHR display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(dpy);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getRandROutputDisplayEXT (VkPhysicalDevice physicalDevice, pt::XlibDisplayPtr dpy, pt::RROutput rrOutput, VkDisplayKHR* pDisplay)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(dpy);
	DE_UNREF(rrOutput);
	DE_UNREF(pDisplay);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquireWinrtDisplayNV (VkPhysicalDevice physicalDevice, VkDisplayKHR display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getWinrtDisplayNV (VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(deviceRelativeId);
	DE_UNREF(pDisplay);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL displayPowerControlEXT (VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
	DE_UNREF(device);
	DE_UNREF(display);
	DE_UNREF(pDisplayPowerInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL registerDeviceEventEXT (VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
	DE_UNREF(device);
	DE_UNREF(pDeviceEventInfo);
	DE_UNREF(pAllocator);
	DE_UNREF(pFence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL registerDisplayEventEXT (VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
	DE_UNREF(device);
	DE_UNREF(display);
	DE_UNREF(pDisplayEventInfo);
	DE_UNREF(pAllocator);
	DE_UNREF(pFence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getSwapchainCounterEXT (VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(counter);
	DE_UNREF(pCounterValue);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2EXT (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(surface);
	DE_UNREF(pSurfaceCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceGroups (VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
	DE_UNREF(instance);
	DE_UNREF(pPhysicalDeviceGroupCount);
	DE_UNREF(pPhysicalDeviceGroupProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getDeviceGroupPeerMemoryFeatures (VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
	DE_UNREF(device);
	DE_UNREF(heapIndex);
	DE_UNREF(localDeviceIndex);
	DE_UNREF(remoteDeviceIndex);
	DE_UNREF(pPeerMemoryFeatures);
}

VKAPI_ATTR VkResult VKAPI_CALL bindBufferMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
{
	DE_UNREF(device);
	DE_UNREF(bindInfoCount);
	DE_UNREF(pBindInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL bindImageMemory2 (VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
{
	DE_UNREF(device);
	DE_UNREF(bindInfoCount);
	DE_UNREF(pBindInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetDeviceMask (VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(deviceMask);
}

VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupPresentCapabilitiesKHR (VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
	DE_UNREF(device);
	DE_UNREF(pDeviceGroupPresentCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModesKHR (VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
{
	DE_UNREF(device);
	DE_UNREF(surface);
	DE_UNREF(pModes);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex)
{
	DE_UNREF(device);
	DE_UNREF(pAcquireInfo);
	DE_UNREF(pImageIndex);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdDispatchBase (VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(baseGroupX);
	DE_UNREF(baseGroupY);
	DE_UNREF(baseGroupZ);
	DE_UNREF(groupCountX);
	DE_UNREF(groupCountY);
	DE_UNREF(groupCountZ);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDevicePresentRectanglesKHR (VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(surface);
	DE_UNREF(pRectCount);
	DE_UNREF(pRects);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL updateDescriptorSetWithTemplate (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
{
	DE_UNREF(device);
	DE_UNREF(descriptorSet);
	DE_UNREF(descriptorUpdateTemplate);
	DE_UNREF(pData);
}

VKAPI_ATTR void VKAPI_CALL cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(descriptorUpdateTemplate);
	DE_UNREF(layout);
	DE_UNREF(set);
	DE_UNREF(pData);
}

VKAPI_ATTR void VKAPI_CALL setHdrMetadataEXT (VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
{
	DE_UNREF(device);
	DE_UNREF(swapchainCount);
	DE_UNREF(pSwapchains);
	DE_UNREF(pMetadata);
}

VKAPI_ATTR VkResult VKAPI_CALL getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getRefreshCycleDurationGOOGLE (VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(pDisplayTimingProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPastPresentationTimingGOOGLE (VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(pPresentationTimingCount);
	DE_UNREF(pPresentationTimings);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstViewport);
	DE_UNREF(viewportCount);
	DE_UNREF(pViewportWScalings);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDiscardRectangleEXT (VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstDiscardRectangle);
	DE_UNREF(discardRectangleCount);
	DE_UNREF(pDiscardRectangles);
}

VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEXT (VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pSampleLocationsInfo);
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceMultisamplePropertiesEXT (VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(samples);
	DE_UNREF(pMultisampleProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pSurfaceInfo);
	DE_UNREF(pSurfaceCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pSurfaceInfo);
	DE_UNREF(pSurfaceFormatCount);
	DE_UNREF(pSurfaceFormats);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceDisplayPlaneProperties2KHR (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDisplayModeProperties2KHR (VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(display);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDisplayPlaneCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pDisplayPlaneInfo);
	DE_UNREF(pCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2 (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2 (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getImageSparseMemoryRequirements2 (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pSparseMemoryRequirementCount);
	DE_UNREF(pSparseMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getDeviceBufferMemoryRequirements (VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getDeviceImageMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getDeviceImageSparseMemoryRequirements (VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pSparseMemoryRequirementCount);
	DE_UNREF(pSparseMemoryRequirements);
}

VKAPI_ATTR void VKAPI_CALL getDeviceQueue2 (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
{
	DE_UNREF(device);
	DE_UNREF(pQueueInfo);
	DE_UNREF(pQueue);
}

VKAPI_ATTR VkResult VKAPI_CALL getValidationCacheDataEXT (VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(validationCache);
	DE_UNREF(pDataSize);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL mergeValidationCachesEXT (VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
{
	DE_UNREF(device);
	DE_UNREF(dstCache);
	DE_UNREF(srcCacheCount);
	DE_UNREF(pSrcCaches);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutSupport (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
{
	DE_UNREF(device);
	DE_UNREF(pCreateInfo);
	DE_UNREF(pSupport);
}

VKAPI_ATTR VkResult VKAPI_CALL getSwapchainGrallocUsageOpenHarmony (VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage)
{
	DE_UNREF(device);
	DE_UNREF(format);
	DE_UNREF(imageUsage);
	DE_UNREF(grallocUsage);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setNativeFenceFdOpenHarmony (VkDevice device, int32_t nativeFenceFd, VkSemaphore semaphore, VkFence fence)
{
	DE_UNREF(device);
	DE_UNREF(nativeFenceFd);
	DE_UNREF(semaphore);
	DE_UNREF(fence);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getNativeFenceFdOpenHarmony (VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int32_t* pNativeFenceFd)
{
	DE_UNREF(queue);
	DE_UNREF(waitSemaphoreCount);
	DE_UNREF(pWaitSemaphores);
	DE_UNREF(image);
	DE_UNREF(pNativeFenceFd);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getShaderInfoAMD (VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pipeline);
	DE_UNREF(shaderStage);
	DE_UNREF(infoType);
	DE_UNREF(pInfoSize);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL setLocalDimmingAMD (VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
{
	DE_UNREF(device);
	DE_UNREF(swapChain);
	DE_UNREF(localDimmingEnable);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCalibrateableTimeDomainsEXT (VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pTimeDomainCount);
	DE_UNREF(pTimeDomains);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getCalibratedTimestampsEXT (VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
{
	DE_UNREF(device);
	DE_UNREF(timestampCount);
	DE_UNREF(pTimestampInfos);
	DE_UNREF(pTimestamps);
	DE_UNREF(pMaxDeviation);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectNameEXT (VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
	DE_UNREF(device);
	DE_UNREF(pNameInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setDebugUtilsObjectTagEXT (VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
	DE_UNREF(device);
	DE_UNREF(pTagInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL queueBeginDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
	DE_UNREF(queue);
	DE_UNREF(pLabelInfo);
}

VKAPI_ATTR void VKAPI_CALL queueEndDebugUtilsLabelEXT (VkQueue queue)
{
	DE_UNREF(queue);
}

VKAPI_ATTR void VKAPI_CALL queueInsertDebugUtilsLabelEXT (VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
	DE_UNREF(queue);
	DE_UNREF(pLabelInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pLabelInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdEndDebugUtilsLabelEXT (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL cmdInsertDebugUtilsLabelEXT (VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pLabelInfo);
}

VKAPI_ATTR void VKAPI_CALL submitDebugUtilsMessageEXT (VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
	DE_UNREF(instance);
	DE_UNREF(messageSeverity);
	DE_UNREF(messageTypes);
	DE_UNREF(pCallbackData);
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryHostPointerPropertiesEXT (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
	DE_UNREF(device);
	DE_UNREF(handleType);
	DE_UNREF(pHostPointer);
	DE_UNREF(pMemoryHostPointerProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarkerAMD (VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineStage);
	DE_UNREF(dstBuffer);
	DE_UNREF(dstOffset);
	DE_UNREF(marker);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginRenderPass2 (VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pRenderPassBegin);
	DE_UNREF(pSubpassBeginInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdNextSubpass2 (VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pSubpassBeginInfo);
	DE_UNREF(pSubpassEndInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdEndRenderPass2 (VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pSubpassEndInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL getSemaphoreCounterValue (VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
{
	DE_UNREF(device);
	DE_UNREF(semaphore);
	DE_UNREF(pValue);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL waitSemaphores (VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
{
	DE_UNREF(device);
	DE_UNREF(pWaitInfo);
	DE_UNREF(timeout);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL signalSemaphore (VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
{
	DE_UNREF(device);
	DE_UNREF(pSignalInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getAndroidHardwareBufferPropertiesANDROID (VkDevice device, const struct pt::AndroidHardwareBufferPtr buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(buffer);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getMemoryOHOSNativeBufferOpenHarmony (VkDevice device, const VkMemoryGetOHOSNativeBufferInfoOpenHarmony* pInfo, struct OH_NativeBuffer** pBuffer)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pBuffer);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(countBuffer);
	DE_UNREF(countBufferOffset);
	DE_UNREF(maxDrawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndexedIndirectCount (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(countBuffer);
	DE_UNREF(countBufferOffset);
	DE_UNREF(maxDrawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCheckpointNV (VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCheckpointMarker);
}

VKAPI_ATTR void VKAPI_CALL getQueueCheckpointDataNV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
{
	DE_UNREF(queue);
	DE_UNREF(pCheckpointDataCount);
	DE_UNREF(pCheckpointData);
}

VKAPI_ATTR void VKAPI_CALL cmdBindTransformFeedbackBuffersEXT (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstBinding);
	DE_UNREF(bindingCount);
	DE_UNREF(pBuffers);
	DE_UNREF(pOffsets);
	DE_UNREF(pSizes);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstCounterBuffer);
	DE_UNREF(counterBufferCount);
	DE_UNREF(pCounterBuffers);
	DE_UNREF(pCounterBufferOffsets);
}

VKAPI_ATTR void VKAPI_CALL cmdEndTransformFeedbackEXT (VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstCounterBuffer);
	DE_UNREF(counterBufferCount);
	DE_UNREF(pCounterBuffers);
	DE_UNREF(pCounterBufferOffsets);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(query);
	DE_UNREF(flags);
	DE_UNREF(index);
}

VKAPI_ATTR void VKAPI_CALL cmdEndQueryIndexedEXT (VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(queryPool);
	DE_UNREF(query);
	DE_UNREF(index);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawIndirectByteCountEXT (VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(instanceCount);
	DE_UNREF(firstInstance);
	DE_UNREF(counterBuffer);
	DE_UNREF(counterBufferOffset);
	DE_UNREF(counterOffset);
	DE_UNREF(vertexStride);
}

VKAPI_ATTR void VKAPI_CALL cmdSetExclusiveScissorNV (VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstExclusiveScissor);
	DE_UNREF(exclusiveScissorCount);
	DE_UNREF(pExclusiveScissors);
}

VKAPI_ATTR void VKAPI_CALL cmdBindShadingRateImageNV (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(imageView);
	DE_UNREF(imageLayout);
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewportShadingRatePaletteNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstViewport);
	DE_UNREF(viewportCount);
	DE_UNREF(pShadingRatePalettes);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoarseSampleOrderNV (VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(sampleOrderType);
	DE_UNREF(customSampleOrderCount);
	DE_UNREF(pCustomSampleOrders);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksNV (VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(taskCount);
	DE_UNREF(firstTask);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(drawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountNV (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(countBuffer);
	DE_UNREF(countBufferOffset);
	DE_UNREF(maxDrawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksEXT (VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(groupCountX);
	DE_UNREF(groupCountY);
	DE_UNREF(groupCountZ);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectEXT (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(drawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdDrawMeshTasksIndirectCountEXT (VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(buffer);
	DE_UNREF(offset);
	DE_UNREF(countBuffer);
	DE_UNREF(countBufferOffset);
	DE_UNREF(maxDrawCount);
	DE_UNREF(stride);
}

VKAPI_ATTR VkResult VKAPI_CALL compileDeferredNV (VkDevice device, VkPipeline pipeline, uint32_t shader)
{
	DE_UNREF(device);
	DE_UNREF(pipeline);
	DE_UNREF(shader);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdBindInvocationMaskHUAWEI (VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(imageView);
	DE_UNREF(imageLayout);
}

VKAPI_ATTR void VKAPI_CALL getAccelerationStructureMemoryRequirementsNV (VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pMemoryRequirements);
}

VKAPI_ATTR VkResult VKAPI_CALL bindAccelerationStructureMemoryNV (VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
{
	DE_UNREF(device);
	DE_UNREF(bindInfoCount);
	DE_UNREF(pBindInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureNV (VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(dst);
	DE_UNREF(src);
	DE_UNREF(mode);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyAccelerationStructureToMemoryKHR (VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyAccelerationStructureToMemoryKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToAccelerationStructureKHR (VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToAccelerationStructureKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesKHR (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(accelerationStructureCount);
	DE_UNREF(pAccelerationStructures);
	DE_UNREF(queryType);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
}

VKAPI_ATTR void VKAPI_CALL cmdWriteAccelerationStructuresPropertiesNV (VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(accelerationStructureCount);
	DE_UNREF(pAccelerationStructures);
	DE_UNREF(queryType);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
}

VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructureNV (VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
	DE_UNREF(instanceData);
	DE_UNREF(instanceOffset);
	DE_UNREF(update);
	DE_UNREF(dst);
	DE_UNREF(src);
	DE_UNREF(scratch);
	DE_UNREF(scratchOffset);
}

VKAPI_ATTR VkResult VKAPI_CALL writeAccelerationStructuresPropertiesKHR (VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
{
	DE_UNREF(device);
	DE_UNREF(accelerationStructureCount);
	DE_UNREF(pAccelerationStructures);
	DE_UNREF(queryType);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	DE_UNREF(stride);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdTraceRaysKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pRaygenShaderBindingTable);
	DE_UNREF(pMissShaderBindingTable);
	DE_UNREF(pHitShaderBindingTable);
	DE_UNREF(pCallableShaderBindingTable);
	DE_UNREF(width);
	DE_UNREF(height);
	DE_UNREF(depth);
}

VKAPI_ATTR void VKAPI_CALL cmdTraceRaysNV (VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(raygenShaderBindingTableBuffer);
	DE_UNREF(raygenShaderBindingOffset);
	DE_UNREF(missShaderBindingTableBuffer);
	DE_UNREF(missShaderBindingOffset);
	DE_UNREF(missShaderBindingStride);
	DE_UNREF(hitShaderBindingTableBuffer);
	DE_UNREF(hitShaderBindingOffset);
	DE_UNREF(hitShaderBindingStride);
	DE_UNREF(callableShaderBindingTableBuffer);
	DE_UNREF(callableShaderBindingOffset);
	DE_UNREF(callableShaderBindingStride);
	DE_UNREF(width);
	DE_UNREF(height);
	DE_UNREF(depth);
}

VKAPI_ATTR VkResult VKAPI_CALL getRayTracingShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pipeline);
	DE_UNREF(firstGroup);
	DE_UNREF(groupCount);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getRayTracingCaptureReplayShaderGroupHandlesKHR (VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pipeline);
	DE_UNREF(firstGroup);
	DE_UNREF(groupCount);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getAccelerationStructureHandleNV (VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(accelerationStructure);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceCooperativeMatrixPropertiesNV (VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPropertyCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirectKHR (VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pRaygenShaderBindingTable);
	DE_UNREF(pMissShaderBindingTable);
	DE_UNREF(pHitShaderBindingTable);
	DE_UNREF(pCallableShaderBindingTable);
	DE_UNREF(indirectDeviceAddress);
}

VKAPI_ATTR void VKAPI_CALL cmdTraceRaysIndirect2KHR (VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(indirectDeviceAddress);
}

VKAPI_ATTR void VKAPI_CALL getDeviceAccelerationStructureCompatibilityKHR (VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
	DE_UNREF(device);
	DE_UNREF(pVersionInfo);
	DE_UNREF(pCompatibility);
}

VKAPI_ATTR VkDeviceSize VKAPI_CALL getRayTracingShaderGroupStackSizeKHR (VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
{
	DE_UNREF(device);
	DE_UNREF(pipeline);
	DE_UNREF(group);
	DE_UNREF(groupShader);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetRayTracingPipelineStackSizeKHR (VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineStackSize);
}

VKAPI_ATTR uint32_t VKAPI_CALL getImageViewHandleNVX (VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getImageViewAddressNVX (VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(imageView);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSurfacePresentModes2EXT (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pSurfaceInfo);
	DE_UNREF(pPresentModeCount);
	DE_UNREF(pPresentModes);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDeviceGroupSurfacePresentModes2EXT (VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes)
{
	DE_UNREF(device);
	DE_UNREF(pSurfaceInfo);
	DE_UNREF(pModes);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquireFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL releaseFullScreenExclusiveModeEXT (VkDevice device, VkSwapchainKHR swapchain)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR (VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(queueFamilyIndex);
	DE_UNREF(pCounterCount);
	DE_UNREF(pCounters);
	DE_UNREF(pCounterDescriptions);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR (VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pPerformanceQueryCreateInfo);
	DE_UNREF(pNumPasses);
}

VKAPI_ATTR VkResult VKAPI_CALL acquireProfilingLockKHR (VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL releaseProfilingLockKHR (VkDevice device)
{
	DE_UNREF(device);
}

VKAPI_ATTR VkResult VKAPI_CALL getImageDrmFormatModifierPropertiesEXT (VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(image);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR uint64_t VKAPI_CALL getBufferOpaqueCaptureAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkDeviceAddress VKAPI_CALL getBufferDeviceAddress (VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV (VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pCombinationCount);
	DE_UNREF(pCombinations);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL initializePerformanceApiINTEL (VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInitializeInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL uninitializePerformanceApiINTEL (VkDevice device)
{
	DE_UNREF(device);
}

VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pMarkerInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceStreamMarkerINTEL (VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pMarkerInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL cmdSetPerformanceOverrideINTEL (VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pOverrideInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL acquirePerformanceConfigurationINTEL (VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
{
	DE_UNREF(device);
	DE_UNREF(pAcquireInfo);
	DE_UNREF(pConfiguration);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL releasePerformanceConfigurationINTEL (VkDevice device, VkPerformanceConfigurationINTEL configuration)
{
	DE_UNREF(device);
	DE_UNREF(configuration);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL queueSetPerformanceConfigurationINTEL (VkQueue queue, VkPerformanceConfigurationINTEL configuration)
{
	DE_UNREF(queue);
	DE_UNREF(configuration);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPerformanceParameterINTEL (VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
{
	DE_UNREF(device);
	DE_UNREF(parameter);
	DE_UNREF(pValue);
	return VK_SUCCESS;
}

VKAPI_ATTR uint64_t VKAPI_CALL getDeviceMemoryOpaqueCaptureAddress (VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutablePropertiesKHR (VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(pPipelineInfo);
	DE_UNREF(pExecutableCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableStatisticsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
{
	DE_UNREF(device);
	DE_UNREF(pExecutableInfo);
	DE_UNREF(pStatisticCount);
	DE_UNREF(pStatistics);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPipelineExecutableInternalRepresentationsKHR (VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
{
	DE_UNREF(device);
	DE_UNREF(pExecutableInfo);
	DE_UNREF(pInternalRepresentationCount);
	DE_UNREF(pInternalRepresentations);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEXT (VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(lineStippleFactor);
	DE_UNREF(lineStipplePattern);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceToolProperties (VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pToolCount);
	DE_UNREF(pToolProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(infoCount);
	DE_UNREF(pInfos);
	DE_UNREF(ppBuildRangeInfos);
}

VKAPI_ATTR void VKAPI_CALL cmdBuildAccelerationStructuresIndirectKHR (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(infoCount);
	DE_UNREF(pInfos);
	DE_UNREF(pIndirectDeviceAddresses);
	DE_UNREF(pIndirectStrides);
	DE_UNREF(ppMaxPrimitiveCounts);
}

VKAPI_ATTR VkResult VKAPI_CALL buildAccelerationStructuresKHR (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(infoCount);
	DE_UNREF(pInfos);
	DE_UNREF(ppBuildRangeInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR VkDeviceAddress VKAPI_CALL getAccelerationStructureDeviceAddressKHR (VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR uint32_t VKAPI_CALL getDeferredOperationMaxConcurrencyKHR (VkDevice device, VkDeferredOperationKHR operation)
{
	DE_UNREF(device);
	DE_UNREF(operation);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDeferredOperationResultKHR (VkDevice device, VkDeferredOperationKHR operation)
{
	DE_UNREF(device);
	DE_UNREF(operation);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL deferredOperationJoinKHR (VkDevice device, VkDeferredOperationKHR operation)
{
	DE_UNREF(device);
	DE_UNREF(operation);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetCullMode (VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(cullMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetFrontFace (VkCommandBuffer commandBuffer, VkFrontFace frontFace)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(frontFace);
}

VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveTopology (VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(primitiveTopology);
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewportWithCount (VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(viewportCount);
	DE_UNREF(pViewports);
}

VKAPI_ATTR void VKAPI_CALL cmdSetScissorWithCount (VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(scissorCount);
	DE_UNREF(pScissors);
}

VKAPI_ATTR void VKAPI_CALL cmdBindVertexBuffers2 (VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstBinding);
	DE_UNREF(bindingCount);
	DE_UNREF(pBuffers);
	DE_UNREF(pOffsets);
	DE_UNREF(pSizes);
	DE_UNREF(pStrides);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthTestEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthWriteEnable (VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthWriteEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthCompareOp (VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthCompareOp);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthBoundsTestEnable (VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthBoundsTestEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetStencilTestEnable (VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(stencilTestEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetStencilOp (VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(faceMask);
	DE_UNREF(failOp);
	DE_UNREF(passOp);
	DE_UNREF(depthFailOp);
	DE_UNREF(compareOp);
}

VKAPI_ATTR void VKAPI_CALL cmdSetPatchControlPointsEXT (VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(patchControlPoints);
}

VKAPI_ATTR void VKAPI_CALL cmdSetRasterizerDiscardEnable (VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(rasterizerDiscardEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthBiasEnable (VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthBiasEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEXT (VkCommandBuffer commandBuffer, VkLogicOp logicOp)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(logicOp);
}

VKAPI_ATTR void VKAPI_CALL cmdSetPrimitiveRestartEnable (VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(primitiveRestartEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetTessellationDomainOriginEXT (VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(domainOrigin);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthClampEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthClampEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthClampEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetPolygonModeEXT (VkCommandBuffer commandBuffer, VkPolygonMode polygonMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(polygonMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetRasterizationSamplesEXT (VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(rasterizationSamples);
}

VKAPI_ATTR void VKAPI_CALL cmdSetSampleMaskEXT (VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(samples);
	DE_UNREF(pSampleMask);
}

VKAPI_ATTR void VKAPI_CALL cmdSetAlphaToCoverageEnableEXT (VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(alphaToCoverageEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetAlphaToOneEnableEXT (VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(alphaToOneEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetLogicOpEnableEXT (VkCommandBuffer commandBuffer, VkBool32 logicOpEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(logicOpEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendEnableEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstAttachment);
	DE_UNREF(attachmentCount);
	DE_UNREF(pColorBlendEnables);
}

VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendEquationEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstAttachment);
	DE_UNREF(attachmentCount);
	DE_UNREF(pColorBlendEquations);
}

VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteMaskEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstAttachment);
	DE_UNREF(attachmentCount);
	DE_UNREF(pColorWriteMasks);
}

VKAPI_ATTR void VKAPI_CALL cmdSetRasterizationStreamEXT (VkCommandBuffer commandBuffer, uint32_t rasterizationStream)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(rasterizationStream);
}

VKAPI_ATTR void VKAPI_CALL cmdSetConservativeRasterizationModeEXT (VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(conservativeRasterizationMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetExtraPrimitiveOverestimationSizeEXT (VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(extraPrimitiveOverestimationSize);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthClipEnableEXT (VkCommandBuffer commandBuffer, VkBool32 depthClipEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(depthClipEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetSampleLocationsEnableEXT (VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(sampleLocationsEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetColorBlendAdvancedEXT (VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstAttachment);
	DE_UNREF(attachmentCount);
	DE_UNREF(pColorBlendAdvanced);
}

VKAPI_ATTR void VKAPI_CALL cmdSetProvokingVertexModeEXT (VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(provokingVertexMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetLineRasterizationModeEXT (VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(lineRasterizationMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetLineStippleEnableEXT (VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(stippledLineEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDepthClipNegativeOneToOneEXT (VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(negativeOneToOne);
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewportWScalingEnableNV (VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(viewportWScalingEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetViewportSwizzleNV (VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(firstViewport);
	DE_UNREF(viewportCount);
	DE_UNREF(pViewportSwizzles);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageToColorEnableNV (VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageToColorEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageToColorLocationNV (VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageToColorLocation);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationModeNV (VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageModulationMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationTableEnableNV (VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageModulationTableEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageModulationTableNV (VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageModulationTableCount);
	DE_UNREF(pCoverageModulationTable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetShadingRateImageEnableNV (VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(shadingRateImageEnable);
}

VKAPI_ATTR void VKAPI_CALL cmdSetCoverageReductionModeNV (VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(coverageReductionMode);
}

VKAPI_ATTR void VKAPI_CALL cmdSetRepresentativeFragmentTestEnableNV (VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(representativeFragmentTestEnable);
}

VKAPI_ATTR VkResult VKAPI_CALL setPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
	DE_UNREF(device);
	DE_UNREF(objectType);
	DE_UNREF(objectHandle);
	DE_UNREF(privateDataSlot);
	DE_UNREF(data);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getPrivateData (VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
	DE_UNREF(device);
	DE_UNREF(objectType);
	DE_UNREF(objectHandle);
	DE_UNREF(privateDataSlot);
	DE_UNREF(pData);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyBuffer2 (VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCopyBufferInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyImage2 (VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCopyImageInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdBlitImage2 (VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pBlitImageInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyBufferToImage2 (VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCopyBufferToImageInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdCopyImageToBuffer2 (VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCopyImageToBufferInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdResolveImage2 (VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pResolveImageInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateKHR (VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pFragmentSize);
	DE_UNREF(combinerOps);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceFragmentShadingRatesKHR (VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pFragmentShadingRateCount);
	DE_UNREF(pFragmentShadingRates);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdSetFragmentShadingRateEnumNV (VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
{
	DE_UNREF(commandBuffer);
	DE_UNREF(shadingRate);
	DE_UNREF(combinerOps);
}

VKAPI_ATTR void VKAPI_CALL getAccelerationStructureBuildSizesKHR (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
{
	DE_UNREF(device);
	DE_UNREF(buildType);
	DE_UNREF(pBuildInfo);
	DE_UNREF(pMaxPrimitiveCounts);
	DE_UNREF(pSizeInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdSetVertexInputEXT (VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(vertexBindingDescriptionCount);
	DE_UNREF(pVertexBindingDescriptions);
	DE_UNREF(vertexAttributeDescriptionCount);
	DE_UNREF(pVertexAttributeDescriptions);
}

VKAPI_ATTR void VKAPI_CALL cmdSetColorWriteEnableEXT (VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(attachmentCount);
	DE_UNREF(pColorWriteEnables);
}

VKAPI_ATTR void VKAPI_CALL cmdSetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(event);
	DE_UNREF(pDependencyInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdResetEvent2 (VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(event);
	DE_UNREF(stageMask);
}

VKAPI_ATTR void VKAPI_CALL cmdWaitEvents2 (VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(eventCount);
	DE_UNREF(pEvents);
	DE_UNREF(pDependencyInfos);
}

VKAPI_ATTR void VKAPI_CALL cmdPipelineBarrier2 (VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pDependencyInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL queueSubmit2 (VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
	DE_UNREF(queue);
	DE_UNREF(submitCount);
	DE_UNREF(pSubmits);
	DE_UNREF(fence);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdWriteTimestamp2 (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(stage);
	DE_UNREF(queryPool);
	DE_UNREF(query);
}

VKAPI_ATTR void VKAPI_CALL cmdWriteBufferMarker2AMD (VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(stage);
	DE_UNREF(dstBuffer);
	DE_UNREF(dstOffset);
	DE_UNREF(marker);
}

VKAPI_ATTR void VKAPI_CALL getQueueCheckpointData2NV (VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
{
	DE_UNREF(queue);
	DE_UNREF(pCheckpointDataCount);
	DE_UNREF(pCheckpointData);
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoCapabilitiesKHR (VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pVideoProfile);
	DE_UNREF(pCapabilities);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceVideoFormatPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pVideoFormatInfo);
	DE_UNREF(pVideoFormatPropertyCount);
	DE_UNREF(pVideoFormatProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL updateVideoSessionParametersKHR (VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
{
	DE_UNREF(device);
	DE_UNREF(videoSessionParameters);
	DE_UNREF(pUpdateInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getVideoSessionMemoryRequirementsKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements)
{
	DE_UNREF(device);
	DE_UNREF(videoSession);
	DE_UNREF(pMemoryRequirementsCount);
	DE_UNREF(pMemoryRequirements);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL bindVideoSessionMemoryKHR (VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos)
{
	DE_UNREF(device);
	DE_UNREF(videoSession);
	DE_UNREF(bindSessionMemoryInfoCount);
	DE_UNREF(pBindSessionMemoryInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdDecodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pDecodeInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdBeginVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pBeginInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdControlVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pCodingControlInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdEndVideoCodingKHR (VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pEndCodingInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdEncodeVideoKHR (VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pEncodeInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdDecompressMemoryNV (VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(decompressRegionCount);
	DE_UNREF(pDecompressMemoryRegions);
}

VKAPI_ATTR void VKAPI_CALL cmdDecompressMemoryIndirectCountNV (VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(indirectCommandsAddress);
	DE_UNREF(indirectCommandsCountAddress);
	DE_UNREF(stride);
}

VKAPI_ATTR void VKAPI_CALL cmdCuLaunchKernelNVX (VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pLaunchInfo);
}

VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutSizeEXT (VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes)
{
	DE_UNREF(device);
	DE_UNREF(layout);
	DE_UNREF(pLayoutSizeInBytes);
}

VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutBindingOffsetEXT (VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset)
{
	DE_UNREF(device);
	DE_UNREF(layout);
	DE_UNREF(binding);
	DE_UNREF(pOffset);
}

VKAPI_ATTR void VKAPI_CALL getDescriptorEXT (VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor)
{
	DE_UNREF(device);
	DE_UNREF(pDescriptorInfo);
	DE_UNREF(dataSize);
	DE_UNREF(pDescriptor);
}

VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorBuffersEXT (VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(bufferCount);
	DE_UNREF(pBindingInfos);
}

VKAPI_ATTR void VKAPI_CALL cmdSetDescriptorBufferOffsetsEXT (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(layout);
	DE_UNREF(firstSet);
	DE_UNREF(setCount);
	DE_UNREF(pBufferIndices);
	DE_UNREF(pOffsets);
}

VKAPI_ATTR void VKAPI_CALL cmdBindDescriptorBufferEmbeddedSamplersEXT (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pipelineBindPoint);
	DE_UNREF(layout);
	DE_UNREF(set);
}

VKAPI_ATTR VkResult VKAPI_CALL getBufferOpaqueCaptureDescriptorDataEXT (VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getImageOpaqueCaptureDescriptorDataEXT (VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getImageViewOpaqueCaptureDescriptorDataEXT (VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getSamplerOpaqueCaptureDescriptorDataEXT (VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getAccelerationStructureOpaqueCaptureDescriptorDataEXT (VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData)
{
	DE_UNREF(device);
	DE_UNREF(pInfo);
	DE_UNREF(pData);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL setDeviceMemoryPriorityEXT (VkDevice device, VkDeviceMemory memory, float priority)
{
	DE_UNREF(device);
	DE_UNREF(memory);
	DE_UNREF(priority);
}

VKAPI_ATTR VkResult VKAPI_CALL acquireDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(drmFd);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDrmDisplayEXT (VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(drmFd);
	DE_UNREF(connectorId);
	DE_UNREF(display);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL waitForPresentKHR (VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
{
	DE_UNREF(device);
	DE_UNREF(swapchain);
	DE_UNREF(presentId);
	DE_UNREF(timeout);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionBufferConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
{
	DE_UNREF(device);
	DE_UNREF(collection);
	DE_UNREF(pBufferConstraintsInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL setBufferCollectionImageConstraintsFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
{
	DE_UNREF(device);
	DE_UNREF(collection);
	DE_UNREF(pImageConstraintsInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getBufferCollectionPropertiesFUCHSIA (VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(collection);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdBeginRendering (VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pRenderingInfo);
}

VKAPI_ATTR void VKAPI_CALL cmdEndRendering (VkCommandBuffer commandBuffer)
{
	DE_UNREF(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL getDescriptorSetLayoutHostMappingInfoVALVE (VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping)
{
	DE_UNREF(device);
	DE_UNREF(pBindingReference);
	DE_UNREF(pHostMapping);
}

VKAPI_ATTR void VKAPI_CALL getDescriptorSetHostMappingVALVE (VkDevice device, VkDescriptorSet descriptorSet, void** ppData)
{
	DE_UNREF(device);
	DE_UNREF(descriptorSet);
	DE_UNREF(ppData);
}

VKAPI_ATTR void VKAPI_CALL cmdBuildMicromapsEXT (VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(infoCount);
	DE_UNREF(pInfos);
}

VKAPI_ATTR VkResult VKAPI_CALL buildMicromapsEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(infoCount);
	DE_UNREF(pInfos);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMicromapEXT (VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyMicromapEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMicromapToMemoryEXT (VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyMicromapToMemoryEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdCopyMemoryToMicromapEXT (VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(pInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL copyMemoryToMicromapEXT (VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo)
{
	DE_UNREF(device);
	DE_UNREF(deferredOperation);
	DE_UNREF(pInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdWriteMicromapsPropertiesEXT (VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(micromapCount);
	DE_UNREF(pMicromaps);
	DE_UNREF(queryType);
	DE_UNREF(queryPool);
	DE_UNREF(firstQuery);
}

VKAPI_ATTR VkResult VKAPI_CALL writeMicromapsPropertiesEXT (VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
{
	DE_UNREF(device);
	DE_UNREF(micromapCount);
	DE_UNREF(pMicromaps);
	DE_UNREF(queryType);
	DE_UNREF(dataSize);
	DE_UNREF(pData);
	DE_UNREF(stride);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL getDeviceMicromapCompatibilityEXT (VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
	DE_UNREF(device);
	DE_UNREF(pVersionInfo);
	DE_UNREF(pCompatibility);
}

VKAPI_ATTR void VKAPI_CALL getMicromapBuildSizesEXT (VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo)
{
	DE_UNREF(device);
	DE_UNREF(buildType);
	DE_UNREF(pBuildInfo);
	DE_UNREF(pSizeInfo);
}

VKAPI_ATTR void VKAPI_CALL getShaderModuleIdentifierEXT (VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier)
{
	DE_UNREF(device);
	DE_UNREF(shaderModule);
	DE_UNREF(pIdentifier);
}

VKAPI_ATTR void VKAPI_CALL getShaderModuleCreateInfoIdentifierEXT (VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier)
{
	DE_UNREF(device);
	DE_UNREF(pCreateInfo);
	DE_UNREF(pIdentifier);
}

VKAPI_ATTR void VKAPI_CALL getImageSubresourceLayout2EXT (VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout)
{
	DE_UNREF(device);
	DE_UNREF(image);
	DE_UNREF(pSubresource);
	DE_UNREF(pLayout);
}

VKAPI_ATTR VkResult VKAPI_CALL getPipelinePropertiesEXT (VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties)
{
	DE_UNREF(device);
	DE_UNREF(pPipelineInfo);
	DE_UNREF(pPipelineProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL exportMetalObjectsEXT (VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo)
{
	DE_UNREF(device);
	DE_UNREF(pMetalObjectsInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL getFramebufferTilePropertiesQCOM (VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(framebuffer);
	DE_UNREF(pPropertiesCount);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getDynamicRenderingTilePropertiesQCOM (VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties)
{
	DE_UNREF(device);
	DE_UNREF(pRenderingInfo);
	DE_UNREF(pProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceOpticalFlowImageFormatsNV (VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties)
{
	DE_UNREF(physicalDevice);
	DE_UNREF(pOpticalFlowImageFormatInfo);
	DE_UNREF(pFormatCount);
	DE_UNREF(pImageFormatProperties);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL bindOpticalFlowSessionImageNV (VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout)
{
	DE_UNREF(device);
	DE_UNREF(session);
	DE_UNREF(bindingPoint);
	DE_UNREF(view);
	DE_UNREF(layout);
	return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL cmdOpticalFlowExecuteNV (VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo)
{
	DE_UNREF(commandBuffer);
	DE_UNREF(session);
	DE_UNREF(pExecuteInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL getDeviceFaultInfoEXT (VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo)
{
	DE_UNREF(device);
	DE_UNREF(pFaultCounts);
	DE_UNREF(pFaultInfo);
	return VK_SUCCESS;
}

VKAPI_ATTR VkResult VKAPI_CALL releaseSwapchainImagesEXT (VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo)
{
	DE_UNREF(device);
	DE_UNREF(pReleaseInfo);
	return VK_SUCCESS;
}

static const tcu::StaticFunctionLibrary::Entry s_platformFunctions[] =
{
	VK_NULL_FUNC_ENTRY(vkCreateInstance,						createInstance),
	VK_NULL_FUNC_ENTRY(vkGetInstanceProcAddr,					getInstanceProcAddr),
	VK_NULL_FUNC_ENTRY(vkEnumerateInstanceVersion,				enumerateInstanceVersion),
	VK_NULL_FUNC_ENTRY(vkEnumerateInstanceLayerProperties,		enumerateInstanceLayerProperties),
	VK_NULL_FUNC_ENTRY(vkEnumerateInstanceExtensionProperties,	enumerateInstanceExtensionProperties),
};

static const tcu::StaticFunctionLibrary::Entry s_instanceFunctions[] =
{
	VK_NULL_FUNC_ENTRY(vkDestroyInstance,													destroyInstance),
	VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDevices,											enumeratePhysicalDevices),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties,										getPhysicalDeviceProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties,							getPhysicalDeviceQueueFamilyProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties,									getPhysicalDeviceMemoryProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures,											getPhysicalDeviceFeatures),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties,									getPhysicalDeviceFormatProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties,							getPhysicalDeviceImageFormatProperties),
	VK_NULL_FUNC_ENTRY(vkCreateDevice,														createDevice),
	VK_NULL_FUNC_ENTRY(vkEnumerateDeviceLayerProperties,									enumerateDeviceLayerProperties),
	VK_NULL_FUNC_ENTRY(vkEnumerateDeviceExtensionProperties,								enumerateDeviceExtensionProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties,						getPhysicalDeviceSparseImageFormatProperties),
	VK_NULL_FUNC_ENTRY(vkCreateAndroidSurfaceKHR,											createAndroidSurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkCreateOHOSSurfaceOpenHarmony,										createOHOSSurfaceOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPropertiesKHR,								getPhysicalDeviceDisplayPropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlanePropertiesKHR,						getPhysicalDeviceDisplayPlanePropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneSupportedDisplaysKHR,								getDisplayPlaneSupportedDisplaysKHR),
	VK_NULL_FUNC_ENTRY(vkGetDisplayModePropertiesKHR,										getDisplayModePropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkCreateDisplayModeKHR,												createDisplayModeKHR),
	VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilitiesKHR,									getDisplayPlaneCapabilitiesKHR),
	VK_NULL_FUNC_ENTRY(vkCreateDisplayPlaneSurfaceKHR,										createDisplayPlaneSurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkDestroySurfaceKHR,													destroySurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceSupportKHR,								getPhysicalDeviceSurfaceSupportKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilitiesKHR,							getPhysicalDeviceSurfaceCapabilitiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormatsKHR,								getPhysicalDeviceSurfaceFormatsKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModesKHR,							getPhysicalDeviceSurfacePresentModesKHR),
	VK_NULL_FUNC_ENTRY(vkCreateViSurfaceNN,													createViSurfaceNN),
	VK_NULL_FUNC_ENTRY(vkCreateWaylandSurfaceKHR,											createWaylandSurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWaylandPresentationSupportKHR,					getPhysicalDeviceWaylandPresentationSupportKHR),
	VK_NULL_FUNC_ENTRY(vkCreateWin32SurfaceKHR,												createWin32SurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR,						getPhysicalDeviceWin32PresentationSupportKHR),
	VK_NULL_FUNC_ENTRY(vkCreateXlibSurfaceKHR,												createXlibSurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXlibPresentationSupportKHR,						getPhysicalDeviceXlibPresentationSupportKHR),
	VK_NULL_FUNC_ENTRY(vkCreateXcbSurfaceKHR,												createXcbSurfaceKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceXcbPresentationSupportKHR,						getPhysicalDeviceXcbPresentationSupportKHR),
	VK_NULL_FUNC_ENTRY(vkCreateImagePipeSurfaceFUCHSIA,										createImagePipeSurfaceFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkCreateStreamDescriptorSurfaceGGP,									createStreamDescriptorSurfaceGGP),
	VK_NULL_FUNC_ENTRY(vkCreateScreenSurfaceQNX,											createScreenSurfaceQNX),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceScreenPresentationSupportQNX,						getPhysicalDeviceScreenPresentationSupportQNX),
	VK_NULL_FUNC_ENTRY(vkCreateDebugReportCallbackEXT,										createDebugReportCallbackEXT),
	VK_NULL_FUNC_ENTRY(vkDestroyDebugReportCallbackEXT,										destroyDebugReportCallbackEXT),
	VK_NULL_FUNC_ENTRY(vkDebugReportMessageEXT,												debugReportMessageEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalImageFormatPropertiesNV,					getPhysicalDeviceExternalImageFormatPropertiesNV),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFeatures2,										getPhysicalDeviceFeatures2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceProperties2,										getPhysicalDeviceProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFormatProperties2,								getPhysicalDeviceFormatProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceImageFormatProperties2,							getPhysicalDeviceImageFormatProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyProperties2,							getPhysicalDeviceQueueFamilyProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMemoryProperties2,								getPhysicalDeviceMemoryProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSparseImageFormatProperties2,						getPhysicalDeviceSparseImageFormatProperties2),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalBufferProperties,							getPhysicalDeviceExternalBufferProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalSemaphoreProperties,						getPhysicalDeviceExternalSemaphoreProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceExternalFenceProperties,							getPhysicalDeviceExternalFenceProperties),
	VK_NULL_FUNC_ENTRY(vkReleaseDisplayEXT,													releaseDisplayEXT),
	VK_NULL_FUNC_ENTRY(vkAcquireXlibDisplayEXT,												acquireXlibDisplayEXT),
	VK_NULL_FUNC_ENTRY(vkGetRandROutputDisplayEXT,											getRandROutputDisplayEXT),
	VK_NULL_FUNC_ENTRY(vkAcquireWinrtDisplayNV,												acquireWinrtDisplayNV),
	VK_NULL_FUNC_ENTRY(vkGetWinrtDisplayNV,													getWinrtDisplayNV),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2EXT,							getPhysicalDeviceSurfaceCapabilities2EXT),
	VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceGroups,										enumeratePhysicalDeviceGroups),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDevicePresentRectanglesKHR,								getPhysicalDevicePresentRectanglesKHR),
	VK_NULL_FUNC_ENTRY(vkCreateIOSSurfaceMVK,												createIOSSurfaceMVK),
	VK_NULL_FUNC_ENTRY(vkCreateMacOSSurfaceMVK,												createMacOSSurfaceMVK),
	VK_NULL_FUNC_ENTRY(vkCreateMetalSurfaceEXT,												createMetalSurfaceEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceMultisamplePropertiesEXT,							getPhysicalDeviceMultisamplePropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceCapabilities2KHR,							getPhysicalDeviceSurfaceCapabilities2KHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfaceFormats2KHR,								getPhysicalDeviceSurfaceFormats2KHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayProperties2KHR,							getPhysicalDeviceDisplayProperties2KHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceDisplayPlaneProperties2KHR,						getPhysicalDeviceDisplayPlaneProperties2KHR),
	VK_NULL_FUNC_ENTRY(vkGetDisplayModeProperties2KHR,										getDisplayModeProperties2KHR),
	VK_NULL_FUNC_ENTRY(vkGetDisplayPlaneCapabilities2KHR,									getDisplayPlaneCapabilities2KHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,						getPhysicalDeviceCalibrateableTimeDomainsEXT),
	VK_NULL_FUNC_ENTRY(vkCreateDebugUtilsMessengerEXT,										createDebugUtilsMessengerEXT),
	VK_NULL_FUNC_ENTRY(vkDestroyDebugUtilsMessengerEXT,										destroyDebugUtilsMessengerEXT),
	VK_NULL_FUNC_ENTRY(vkSubmitDebugUtilsMessageEXT,										submitDebugUtilsMessageEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,					getPhysicalDeviceCooperativeMatrixPropertiesNV),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSurfacePresentModes2EXT,							getPhysicalDeviceSurfacePresentModes2EXT),
	VK_NULL_FUNC_ENTRY(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,		enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,				getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR),
	VK_NULL_FUNC_ENTRY(vkCreateHeadlessSurfaceEXT,											createHeadlessSurfaceEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,	getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceToolProperties,									getPhysicalDeviceToolProperties),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceFragmentShadingRatesKHR,							getPhysicalDeviceFragmentShadingRatesKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoCapabilitiesKHR,								getPhysicalDeviceVideoCapabilitiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceVideoFormatPropertiesKHR,							getPhysicalDeviceVideoFormatPropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkAcquireDrmDisplayEXT,												acquireDrmDisplayEXT),
	VK_NULL_FUNC_ENTRY(vkGetDrmDisplayEXT,													getDrmDisplayEXT),
	VK_NULL_FUNC_ENTRY(vkGetPhysicalDeviceOpticalFlowImageFormatsNV,						getPhysicalDeviceOpticalFlowImageFormatsNV),
};

static const tcu::StaticFunctionLibrary::Entry s_deviceFunctions[] =
{
	VK_NULL_FUNC_ENTRY(vkGetDeviceProcAddr,											getDeviceProcAddr),
	VK_NULL_FUNC_ENTRY(vkDestroyDevice,												destroyDevice),
	VK_NULL_FUNC_ENTRY(vkGetDeviceQueue,											getDeviceQueue),
	VK_NULL_FUNC_ENTRY(vkQueueSubmit,												queueSubmit),
	VK_NULL_FUNC_ENTRY(vkQueueWaitIdle,												queueWaitIdle),
	VK_NULL_FUNC_ENTRY(vkDeviceWaitIdle,											deviceWaitIdle),
	VK_NULL_FUNC_ENTRY(vkAllocateMemory,											allocateMemory),
	VK_NULL_FUNC_ENTRY(vkFreeMemory,												freeMemory),
	VK_NULL_FUNC_ENTRY(vkMapMemory,													mapMemory),
	VK_NULL_FUNC_ENTRY(vkUnmapMemory,												unmapMemory),
	VK_NULL_FUNC_ENTRY(vkFlushMappedMemoryRanges,									flushMappedMemoryRanges),
	VK_NULL_FUNC_ENTRY(vkInvalidateMappedMemoryRanges,								invalidateMappedMemoryRanges),
	VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryCommitment,									getDeviceMemoryCommitment),
	VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements,								getBufferMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkBindBufferMemory,											bindBufferMemory),
	VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements,								getImageMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkBindImageMemory,											bindImageMemory),
	VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements,							getImageSparseMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkQueueBindSparse,											queueBindSparse),
	VK_NULL_FUNC_ENTRY(vkCreateFence,												createFence),
	VK_NULL_FUNC_ENTRY(vkDestroyFence,												destroyFence),
	VK_NULL_FUNC_ENTRY(vkResetFences,												resetFences),
	VK_NULL_FUNC_ENTRY(vkGetFenceStatus,											getFenceStatus),
	VK_NULL_FUNC_ENTRY(vkWaitForFences,												waitForFences),
	VK_NULL_FUNC_ENTRY(vkCreateSemaphore,											createSemaphore),
	VK_NULL_FUNC_ENTRY(vkDestroySemaphore,											destroySemaphore),
	VK_NULL_FUNC_ENTRY(vkCreateEvent,												createEvent),
	VK_NULL_FUNC_ENTRY(vkDestroyEvent,												destroyEvent),
	VK_NULL_FUNC_ENTRY(vkGetEventStatus,											getEventStatus),
	VK_NULL_FUNC_ENTRY(vkSetEvent,													setEvent),
	VK_NULL_FUNC_ENTRY(vkResetEvent,												resetEvent),
	VK_NULL_FUNC_ENTRY(vkCreateQueryPool,											createQueryPool),
	VK_NULL_FUNC_ENTRY(vkDestroyQueryPool,											destroyQueryPool),
	VK_NULL_FUNC_ENTRY(vkGetQueryPoolResults,										getQueryPoolResults),
	VK_NULL_FUNC_ENTRY(vkResetQueryPool,											resetQueryPool),
	VK_NULL_FUNC_ENTRY(vkCreateBuffer,												createBuffer),
	VK_NULL_FUNC_ENTRY(vkDestroyBuffer,												destroyBuffer),
	VK_NULL_FUNC_ENTRY(vkCreateBufferView,											createBufferView),
	VK_NULL_FUNC_ENTRY(vkDestroyBufferView,											destroyBufferView),
	VK_NULL_FUNC_ENTRY(vkCreateImage,												createImage),
	VK_NULL_FUNC_ENTRY(vkDestroyImage,												destroyImage),
	VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout,									getImageSubresourceLayout),
	VK_NULL_FUNC_ENTRY(vkCreateImageView,											createImageView),
	VK_NULL_FUNC_ENTRY(vkDestroyImageView,											destroyImageView),
	VK_NULL_FUNC_ENTRY(vkCreateShaderModule,										createShaderModule),
	VK_NULL_FUNC_ENTRY(vkDestroyShaderModule,										destroyShaderModule),
	VK_NULL_FUNC_ENTRY(vkCreatePipelineCache,										createPipelineCache),
	VK_NULL_FUNC_ENTRY(vkDestroyPipelineCache,										destroyPipelineCache),
	VK_NULL_FUNC_ENTRY(vkGetPipelineCacheData,										getPipelineCacheData),
	VK_NULL_FUNC_ENTRY(vkMergePipelineCaches,										mergePipelineCaches),
	VK_NULL_FUNC_ENTRY(vkCreateGraphicsPipelines,									createGraphicsPipelines),
	VK_NULL_FUNC_ENTRY(vkCreateComputePipelines,									createComputePipelines),
	VK_NULL_FUNC_ENTRY(vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,				getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI),
	VK_NULL_FUNC_ENTRY(vkDestroyPipeline,											destroyPipeline),
	VK_NULL_FUNC_ENTRY(vkCreatePipelineLayout,										createPipelineLayout),
	VK_NULL_FUNC_ENTRY(vkDestroyPipelineLayout,										destroyPipelineLayout),
	VK_NULL_FUNC_ENTRY(vkCreateSampler,												createSampler),
	VK_NULL_FUNC_ENTRY(vkDestroySampler,											destroySampler),
	VK_NULL_FUNC_ENTRY(vkCreateDescriptorSetLayout,									createDescriptorSetLayout),
	VK_NULL_FUNC_ENTRY(vkDestroyDescriptorSetLayout,								destroyDescriptorSetLayout),
	VK_NULL_FUNC_ENTRY(vkCreateDescriptorPool,										createDescriptorPool),
	VK_NULL_FUNC_ENTRY(vkDestroyDescriptorPool,										destroyDescriptorPool),
	VK_NULL_FUNC_ENTRY(vkResetDescriptorPool,										resetDescriptorPool),
	VK_NULL_FUNC_ENTRY(vkAllocateDescriptorSets,									allocateDescriptorSets),
	VK_NULL_FUNC_ENTRY(vkFreeDescriptorSets,										freeDescriptorSets),
	VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSets,										updateDescriptorSets),
	VK_NULL_FUNC_ENTRY(vkCreateFramebuffer,											createFramebuffer),
	VK_NULL_FUNC_ENTRY(vkDestroyFramebuffer,										destroyFramebuffer),
	VK_NULL_FUNC_ENTRY(vkCreateRenderPass,											createRenderPass),
	VK_NULL_FUNC_ENTRY(vkDestroyRenderPass,											destroyRenderPass),
	VK_NULL_FUNC_ENTRY(vkGetRenderAreaGranularity,									getRenderAreaGranularity),
	VK_NULL_FUNC_ENTRY(vkCreateCommandPool,											createCommandPool),
	VK_NULL_FUNC_ENTRY(vkDestroyCommandPool,										destroyCommandPool),
	VK_NULL_FUNC_ENTRY(vkResetCommandPool,											resetCommandPool),
	VK_NULL_FUNC_ENTRY(vkAllocateCommandBuffers,									allocateCommandBuffers),
	VK_NULL_FUNC_ENTRY(vkFreeCommandBuffers,										freeCommandBuffers),
	VK_NULL_FUNC_ENTRY(vkBeginCommandBuffer,										beginCommandBuffer),
	VK_NULL_FUNC_ENTRY(vkEndCommandBuffer,											endCommandBuffer),
	VK_NULL_FUNC_ENTRY(vkResetCommandBuffer,										resetCommandBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdBindPipeline,											cmdBindPipeline),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewport,											cmdSetViewport),
	VK_NULL_FUNC_ENTRY(vkCmdSetScissor,												cmdSetScissor),
	VK_NULL_FUNC_ENTRY(vkCmdSetLineWidth,											cmdSetLineWidth),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthBias,											cmdSetDepthBias),
	VK_NULL_FUNC_ENTRY(vkCmdSetBlendConstants,										cmdSetBlendConstants),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthBounds,											cmdSetDepthBounds),
	VK_NULL_FUNC_ENTRY(vkCmdSetStencilCompareMask,									cmdSetStencilCompareMask),
	VK_NULL_FUNC_ENTRY(vkCmdSetStencilWriteMask,									cmdSetStencilWriteMask),
	VK_NULL_FUNC_ENTRY(vkCmdSetStencilReference,									cmdSetStencilReference),
	VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorSets,										cmdBindDescriptorSets),
	VK_NULL_FUNC_ENTRY(vkCmdBindIndexBuffer,										cmdBindIndexBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers,										cmdBindVertexBuffers),
	VK_NULL_FUNC_ENTRY(vkCmdDraw,													cmdDraw),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndexed,											cmdDrawIndexed),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMultiEXT,											cmdDrawMultiEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMultiIndexedEXT,									cmdDrawMultiIndexedEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndirect,											cmdDrawIndirect),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirect,									cmdDrawIndexedIndirect),
	VK_NULL_FUNC_ENTRY(vkCmdDispatch,												cmdDispatch),
	VK_NULL_FUNC_ENTRY(vkCmdDispatchIndirect,										cmdDispatchIndirect),
	VK_NULL_FUNC_ENTRY(vkCmdSubpassShadingHUAWEI,									cmdSubpassShadingHUAWEI),
	VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer,												cmdCopyBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdCopyImage,												cmdCopyImage),
	VK_NULL_FUNC_ENTRY(vkCmdBlitImage,												cmdBlitImage),
	VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage,										cmdCopyBufferToImage),
	VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer,										cmdCopyImageToBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryIndirectNV,									cmdCopyMemoryIndirectNV),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToImageIndirectNV,							cmdCopyMemoryToImageIndirectNV),
	VK_NULL_FUNC_ENTRY(vkCmdUpdateBuffer,											cmdUpdateBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdFillBuffer,												cmdFillBuffer),
	VK_NULL_FUNC_ENTRY(vkCmdClearColorImage,										cmdClearColorImage),
	VK_NULL_FUNC_ENTRY(vkCmdClearDepthStencilImage,									cmdClearDepthStencilImage),
	VK_NULL_FUNC_ENTRY(vkCmdClearAttachments,										cmdClearAttachments),
	VK_NULL_FUNC_ENTRY(vkCmdResolveImage,											cmdResolveImage),
	VK_NULL_FUNC_ENTRY(vkCmdSetEvent,												cmdSetEvent),
	VK_NULL_FUNC_ENTRY(vkCmdResetEvent,												cmdResetEvent),
	VK_NULL_FUNC_ENTRY(vkCmdWaitEvents,												cmdWaitEvents),
	VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier,										cmdPipelineBarrier),
	VK_NULL_FUNC_ENTRY(vkCmdBeginQuery,												cmdBeginQuery),
	VK_NULL_FUNC_ENTRY(vkCmdEndQuery,												cmdEndQuery),
	VK_NULL_FUNC_ENTRY(vkCmdBeginConditionalRenderingEXT,							cmdBeginConditionalRenderingEXT),
	VK_NULL_FUNC_ENTRY(vkCmdEndConditionalRenderingEXT,								cmdEndConditionalRenderingEXT),
	VK_NULL_FUNC_ENTRY(vkCmdResetQueryPool,											cmdResetQueryPool),
	VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp,											cmdWriteTimestamp),
	VK_NULL_FUNC_ENTRY(vkCmdCopyQueryPoolResults,									cmdCopyQueryPoolResults),
	VK_NULL_FUNC_ENTRY(vkCmdPushConstants,											cmdPushConstants),
	VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass,										cmdBeginRenderPass),
	VK_NULL_FUNC_ENTRY(vkCmdNextSubpass,											cmdNextSubpass),
	VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass,											cmdEndRenderPass),
	VK_NULL_FUNC_ENTRY(vkCmdExecuteCommands,										cmdExecuteCommands),
	VK_NULL_FUNC_ENTRY(vkGetOHOSNativeBufferPropertiesOpenHarmony,					getOHOSNativeBufferPropertiesOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkCreateSharedSwapchainsKHR,									createSharedSwapchainsKHR),
	VK_NULL_FUNC_ENTRY(vkCreateSwapchainKHR,										createSwapchainKHR),
	VK_NULL_FUNC_ENTRY(vkDestroySwapchainKHR,										destroySwapchainKHR),
	VK_NULL_FUNC_ENTRY(vkGetSwapchainImagesKHR,										getSwapchainImagesKHR),
	VK_NULL_FUNC_ENTRY(vkAcquireNextImageKHR,										acquireNextImageKHR),
	VK_NULL_FUNC_ENTRY(vkQueuePresentKHR,											queuePresentKHR),
	VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectNameEXT,								debugMarkerSetObjectNameEXT),
	VK_NULL_FUNC_ENTRY(vkDebugMarkerSetObjectTagEXT,								debugMarkerSetObjectTagEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerBeginEXT,									cmdDebugMarkerBeginEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerEndEXT,										cmdDebugMarkerEndEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDebugMarkerInsertEXT,									cmdDebugMarkerInsertEXT),
	VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleNV,									getMemoryWin32HandleNV),
	VK_NULL_FUNC_ENTRY(vkCmdExecuteGeneratedCommandsNV,								cmdExecuteGeneratedCommandsNV),
	VK_NULL_FUNC_ENTRY(vkCmdPreprocessGeneratedCommandsNV,							cmdPreprocessGeneratedCommandsNV),
	VK_NULL_FUNC_ENTRY(vkCmdBindPipelineShaderGroupNV,								cmdBindPipelineShaderGroupNV),
	VK_NULL_FUNC_ENTRY(vkGetGeneratedCommandsMemoryRequirementsNV,					getGeneratedCommandsMemoryRequirementsNV),
	VK_NULL_FUNC_ENTRY(vkCreateIndirectCommandsLayoutNV,							createIndirectCommandsLayoutNV),
	VK_NULL_FUNC_ENTRY(vkDestroyIndirectCommandsLayoutNV,							destroyIndirectCommandsLayoutNV),
	VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetKHR,									cmdPushDescriptorSetKHR),
	VK_NULL_FUNC_ENTRY(vkTrimCommandPool,											trimCommandPool),
	VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandleKHR,									getMemoryWin32HandleKHR),
	VK_NULL_FUNC_ENTRY(vkGetMemoryWin32HandlePropertiesKHR,							getMemoryWin32HandlePropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetMemoryFdKHR,											getMemoryFdKHR),
	VK_NULL_FUNC_ENTRY(vkGetMemoryFdPropertiesKHR,									getMemoryFdPropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandleFUCHSIA,								getMemoryZirconHandleFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkGetMemoryZirconHandlePropertiesFUCHSIA,					getMemoryZirconHandlePropertiesFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkGetMemoryRemoteAddressNV,									getMemoryRemoteAddressNV),
	VK_NULL_FUNC_ENTRY(vkGetSemaphoreWin32HandleKHR,								getSemaphoreWin32HandleKHR),
	VK_NULL_FUNC_ENTRY(vkImportSemaphoreWin32HandleKHR,								importSemaphoreWin32HandleKHR),
	VK_NULL_FUNC_ENTRY(vkGetSemaphoreFdKHR,											getSemaphoreFdKHR),
	VK_NULL_FUNC_ENTRY(vkImportSemaphoreFdKHR,										importSemaphoreFdKHR),
	VK_NULL_FUNC_ENTRY(vkGetSemaphoreZirconHandleFUCHSIA,							getSemaphoreZirconHandleFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkImportSemaphoreZirconHandleFUCHSIA,						importSemaphoreZirconHandleFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkGetFenceWin32HandleKHR,									getFenceWin32HandleKHR),
	VK_NULL_FUNC_ENTRY(vkImportFenceWin32HandleKHR,									importFenceWin32HandleKHR),
	VK_NULL_FUNC_ENTRY(vkGetFenceFdKHR,												getFenceFdKHR),
	VK_NULL_FUNC_ENTRY(vkImportFenceFdKHR,											importFenceFdKHR),
	VK_NULL_FUNC_ENTRY(vkDisplayPowerControlEXT,									displayPowerControlEXT),
	VK_NULL_FUNC_ENTRY(vkRegisterDeviceEventEXT,									registerDeviceEventEXT),
	VK_NULL_FUNC_ENTRY(vkRegisterDisplayEventEXT,									registerDisplayEventEXT),
	VK_NULL_FUNC_ENTRY(vkGetSwapchainCounterEXT,									getSwapchainCounterEXT),
	VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPeerMemoryFeatures,							getDeviceGroupPeerMemoryFeatures),
	VK_NULL_FUNC_ENTRY(vkBindBufferMemory2,											bindBufferMemory2),
	VK_NULL_FUNC_ENTRY(vkBindImageMemory2,											bindImageMemory2),
	VK_NULL_FUNC_ENTRY(vkCmdSetDeviceMask,											cmdSetDeviceMask),
	VK_NULL_FUNC_ENTRY(vkGetDeviceGroupPresentCapabilitiesKHR,						getDeviceGroupPresentCapabilitiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModesKHR,						getDeviceGroupSurfacePresentModesKHR),
	VK_NULL_FUNC_ENTRY(vkAcquireNextImage2KHR,										acquireNextImage2KHR),
	VK_NULL_FUNC_ENTRY(vkCmdDispatchBase,											cmdDispatchBase),
	VK_NULL_FUNC_ENTRY(vkCreateDescriptorUpdateTemplate,							createDescriptorUpdateTemplate),
	VK_NULL_FUNC_ENTRY(vkDestroyDescriptorUpdateTemplate,							destroyDescriptorUpdateTemplate),
	VK_NULL_FUNC_ENTRY(vkUpdateDescriptorSetWithTemplate,							updateDescriptorSetWithTemplate),
	VK_NULL_FUNC_ENTRY(vkCmdPushDescriptorSetWithTemplateKHR,						cmdPushDescriptorSetWithTemplateKHR),
	VK_NULL_FUNC_ENTRY(vkSetHdrMetadataEXT,											setHdrMetadataEXT),
	VK_NULL_FUNC_ENTRY(vkGetSwapchainStatusKHR,										getSwapchainStatusKHR),
	VK_NULL_FUNC_ENTRY(vkGetRefreshCycleDurationGOOGLE,								getRefreshCycleDurationGOOGLE),
	VK_NULL_FUNC_ENTRY(vkGetPastPresentationTimingGOOGLE,							getPastPresentationTimingGOOGLE),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingNV,									cmdSetViewportWScalingNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetDiscardRectangleEXT,									cmdSetDiscardRectangleEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEXT,									cmdSetSampleLocationsEXT),
	VK_NULL_FUNC_ENTRY(vkGetBufferMemoryRequirements2,								getBufferMemoryRequirements2),
	VK_NULL_FUNC_ENTRY(vkGetImageMemoryRequirements2,								getImageMemoryRequirements2),
	VK_NULL_FUNC_ENTRY(vkGetImageSparseMemoryRequirements2,							getImageSparseMemoryRequirements2),
	VK_NULL_FUNC_ENTRY(vkGetDeviceBufferMemoryRequirements,							getDeviceBufferMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkGetDeviceImageMemoryRequirements,							getDeviceImageMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkGetDeviceImageSparseMemoryRequirements,					getDeviceImageSparseMemoryRequirements),
	VK_NULL_FUNC_ENTRY(vkCreateSamplerYcbcrConversion,								createSamplerYcbcrConversion),
	VK_NULL_FUNC_ENTRY(vkDestroySamplerYcbcrConversion,								destroySamplerYcbcrConversion),
	VK_NULL_FUNC_ENTRY(vkGetDeviceQueue2,											getDeviceQueue2),
	VK_NULL_FUNC_ENTRY(vkCreateValidationCacheEXT,									createValidationCacheEXT),
	VK_NULL_FUNC_ENTRY(vkDestroyValidationCacheEXT,									destroyValidationCacheEXT),
	VK_NULL_FUNC_ENTRY(vkGetValidationCacheDataEXT,									getValidationCacheDataEXT),
	VK_NULL_FUNC_ENTRY(vkMergeValidationCachesEXT,									mergeValidationCachesEXT),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSupport,								getDescriptorSetLayoutSupport),
	VK_NULL_FUNC_ENTRY(vkGetSwapchainGrallocUsageOpenHarmony,						getSwapchainGrallocUsageOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkSetNativeFenceFdOpenHarmony,								setNativeFenceFdOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkGetNativeFenceFdOpenHarmony,								getNativeFenceFdOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkGetShaderInfoAMD,											getShaderInfoAMD),
	VK_NULL_FUNC_ENTRY(vkSetLocalDimmingAMD,										setLocalDimmingAMD),
	VK_NULL_FUNC_ENTRY(vkGetCalibratedTimestampsEXT,								getCalibratedTimestampsEXT),
	VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectNameEXT,								setDebugUtilsObjectNameEXT),
	VK_NULL_FUNC_ENTRY(vkSetDebugUtilsObjectTagEXT,									setDebugUtilsObjectTagEXT),
	VK_NULL_FUNC_ENTRY(vkQueueBeginDebugUtilsLabelEXT,								queueBeginDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkQueueEndDebugUtilsLabelEXT,								queueEndDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkQueueInsertDebugUtilsLabelEXT,								queueInsertDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBeginDebugUtilsLabelEXT,								cmdBeginDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkCmdEndDebugUtilsLabelEXT,									cmdEndDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkCmdInsertDebugUtilsLabelEXT,								cmdInsertDebugUtilsLabelEXT),
	VK_NULL_FUNC_ENTRY(vkGetMemoryHostPointerPropertiesEXT,							getMemoryHostPointerPropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarkerAMD,									cmdWriteBufferMarkerAMD),
	VK_NULL_FUNC_ENTRY(vkCreateRenderPass2,											createRenderPass2),
	VK_NULL_FUNC_ENTRY(vkCmdBeginRenderPass2,										cmdBeginRenderPass2),
	VK_NULL_FUNC_ENTRY(vkCmdNextSubpass2,											cmdNextSubpass2),
	VK_NULL_FUNC_ENTRY(vkCmdEndRenderPass2,											cmdEndRenderPass2),
	VK_NULL_FUNC_ENTRY(vkGetSemaphoreCounterValue,									getSemaphoreCounterValue),
	VK_NULL_FUNC_ENTRY(vkWaitSemaphores,											waitSemaphores),
	VK_NULL_FUNC_ENTRY(vkSignalSemaphore,											signalSemaphore),
	VK_NULL_FUNC_ENTRY(vkGetAndroidHardwareBufferPropertiesANDROID,					getAndroidHardwareBufferPropertiesANDROID),
	VK_NULL_FUNC_ENTRY(vkGetMemoryAndroidHardwareBufferANDROID,						getMemoryAndroidHardwareBufferANDROID),
	VK_NULL_FUNC_ENTRY(vkGetMemoryOHOSNativeBufferOpenHarmony,						getMemoryOHOSNativeBufferOpenHarmony),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectCount,										cmdDrawIndirectCount),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndexedIndirectCount,								cmdDrawIndexedIndirectCount),
	VK_NULL_FUNC_ENTRY(vkCmdSetCheckpointNV,										cmdSetCheckpointNV),
	VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointDataNV,									getQueueCheckpointDataNV),
	VK_NULL_FUNC_ENTRY(vkCmdBindTransformFeedbackBuffersEXT,						cmdBindTransformFeedbackBuffersEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBeginTransformFeedbackEXT,								cmdBeginTransformFeedbackEXT),
	VK_NULL_FUNC_ENTRY(vkCmdEndTransformFeedbackEXT,								cmdEndTransformFeedbackEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBeginQueryIndexedEXT,									cmdBeginQueryIndexedEXT),
	VK_NULL_FUNC_ENTRY(vkCmdEndQueryIndexedEXT,										cmdEndQueryIndexedEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDrawIndirectByteCountEXT,								cmdDrawIndirectByteCountEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetExclusiveScissorNV,									cmdSetExclusiveScissorNV),
	VK_NULL_FUNC_ENTRY(vkCmdBindShadingRateImageNV,									cmdBindShadingRateImageNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewportShadingRatePaletteNV,						cmdSetViewportShadingRatePaletteNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoarseSampleOrderNV,									cmdSetCoarseSampleOrderNV),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksNV,										cmdDrawMeshTasksNV),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectNV,								cmdDrawMeshTasksIndirectNV),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountNV,							cmdDrawMeshTasksIndirectCountNV),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksEXT,										cmdDrawMeshTasksEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectEXT,								cmdDrawMeshTasksIndirectEXT),
	VK_NULL_FUNC_ENTRY(vkCmdDrawMeshTasksIndirectCountEXT,							cmdDrawMeshTasksIndirectCountEXT),
	VK_NULL_FUNC_ENTRY(vkCompileDeferredNV,											compileDeferredNV),
	VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureNV,								createAccelerationStructureNV),
	VK_NULL_FUNC_ENTRY(vkCmdBindInvocationMaskHUAWEI,								cmdBindInvocationMaskHUAWEI),
	VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureKHR,							destroyAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkDestroyAccelerationStructureNV,							destroyAccelerationStructureNV),
	VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureMemoryRequirementsNV,				getAccelerationStructureMemoryRequirementsNV),
	VK_NULL_FUNC_ENTRY(vkBindAccelerationStructureMemoryNV,							bindAccelerationStructureMemoryNV),
	VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureNV,							cmdCopyAccelerationStructureNV),
	VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureKHR,							cmdCopyAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureKHR,								copyAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkCmdCopyAccelerationStructureToMemoryKHR,					cmdCopyAccelerationStructureToMemoryKHR),
	VK_NULL_FUNC_ENTRY(vkCopyAccelerationStructureToMemoryKHR,						copyAccelerationStructureToMemoryKHR),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToAccelerationStructureKHR,					cmdCopyMemoryToAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkCopyMemoryToAccelerationStructureKHR,						copyMemoryToAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesKHR,				cmdWriteAccelerationStructuresPropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkCmdWriteAccelerationStructuresPropertiesNV,				cmdWriteAccelerationStructuresPropertiesNV),
	VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructureNV,							cmdBuildAccelerationStructureNV),
	VK_NULL_FUNC_ENTRY(vkWriteAccelerationStructuresPropertiesKHR,					writeAccelerationStructuresPropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkCmdTraceRaysKHR,											cmdTraceRaysKHR),
	VK_NULL_FUNC_ENTRY(vkCmdTraceRaysNV,											cmdTraceRaysNV),
	VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupHandlesKHR,						getRayTracingShaderGroupHandlesKHR),
	VK_NULL_FUNC_ENTRY(vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,			getRayTracingCaptureReplayShaderGroupHandlesKHR),
	VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureHandleNV,							getAccelerationStructureHandleNV),
	VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesNV,								createRayTracingPipelinesNV),
	VK_NULL_FUNC_ENTRY(vkCreateRayTracingPipelinesKHR,								createRayTracingPipelinesKHR),
	VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirectKHR,									cmdTraceRaysIndirectKHR),
	VK_NULL_FUNC_ENTRY(vkCmdTraceRaysIndirect2KHR,									cmdTraceRaysIndirect2KHR),
	VK_NULL_FUNC_ENTRY(vkGetDeviceAccelerationStructureCompatibilityKHR,			getDeviceAccelerationStructureCompatibilityKHR),
	VK_NULL_FUNC_ENTRY(vkGetRayTracingShaderGroupStackSizeKHR,						getRayTracingShaderGroupStackSizeKHR),
	VK_NULL_FUNC_ENTRY(vkCmdSetRayTracingPipelineStackSizeKHR,						cmdSetRayTracingPipelineStackSizeKHR),
	VK_NULL_FUNC_ENTRY(vkGetImageViewHandleNVX,										getImageViewHandleNVX),
	VK_NULL_FUNC_ENTRY(vkGetImageViewAddressNVX,									getImageViewAddressNVX),
	VK_NULL_FUNC_ENTRY(vkGetDeviceGroupSurfacePresentModes2EXT,						getDeviceGroupSurfacePresentModes2EXT),
	VK_NULL_FUNC_ENTRY(vkAcquireFullScreenExclusiveModeEXT,							acquireFullScreenExclusiveModeEXT),
	VK_NULL_FUNC_ENTRY(vkReleaseFullScreenExclusiveModeEXT,							releaseFullScreenExclusiveModeEXT),
	VK_NULL_FUNC_ENTRY(vkAcquireProfilingLockKHR,									acquireProfilingLockKHR),
	VK_NULL_FUNC_ENTRY(vkReleaseProfilingLockKHR,									releaseProfilingLockKHR),
	VK_NULL_FUNC_ENTRY(vkGetImageDrmFormatModifierPropertiesEXT,					getImageDrmFormatModifierPropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureAddress,								getBufferOpaqueCaptureAddress),
	VK_NULL_FUNC_ENTRY(vkGetBufferDeviceAddress,									getBufferDeviceAddress),
	VK_NULL_FUNC_ENTRY(vkInitializePerformanceApiINTEL,								initializePerformanceApiINTEL),
	VK_NULL_FUNC_ENTRY(vkUninitializePerformanceApiINTEL,							uninitializePerformanceApiINTEL),
	VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceMarkerINTEL,								cmdSetPerformanceMarkerINTEL),
	VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceStreamMarkerINTEL,						cmdSetPerformanceStreamMarkerINTEL),
	VK_NULL_FUNC_ENTRY(vkCmdSetPerformanceOverrideINTEL,							cmdSetPerformanceOverrideINTEL),
	VK_NULL_FUNC_ENTRY(vkAcquirePerformanceConfigurationINTEL,						acquirePerformanceConfigurationINTEL),
	VK_NULL_FUNC_ENTRY(vkReleasePerformanceConfigurationINTEL,						releasePerformanceConfigurationINTEL),
	VK_NULL_FUNC_ENTRY(vkQueueSetPerformanceConfigurationINTEL,						queueSetPerformanceConfigurationINTEL),
	VK_NULL_FUNC_ENTRY(vkGetPerformanceParameterINTEL,								getPerformanceParameterINTEL),
	VK_NULL_FUNC_ENTRY(vkGetDeviceMemoryOpaqueCaptureAddress,						getDeviceMemoryOpaqueCaptureAddress),
	VK_NULL_FUNC_ENTRY(vkGetPipelineExecutablePropertiesKHR,						getPipelineExecutablePropertiesKHR),
	VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableStatisticsKHR,						getPipelineExecutableStatisticsKHR),
	VK_NULL_FUNC_ENTRY(vkGetPipelineExecutableInternalRepresentationsKHR,			getPipelineExecutableInternalRepresentationsKHR),
	VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEXT,										cmdSetLineStippleEXT),
	VK_NULL_FUNC_ENTRY(vkCreateAccelerationStructureKHR,							createAccelerationStructureKHR),
	VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresKHR,							cmdBuildAccelerationStructuresKHR),
	VK_NULL_FUNC_ENTRY(vkCmdBuildAccelerationStructuresIndirectKHR,					cmdBuildAccelerationStructuresIndirectKHR),
	VK_NULL_FUNC_ENTRY(vkBuildAccelerationStructuresKHR,							buildAccelerationStructuresKHR),
	VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureDeviceAddressKHR,					getAccelerationStructureDeviceAddressKHR),
	VK_NULL_FUNC_ENTRY(vkCreateDeferredOperationKHR,								createDeferredOperationKHR),
	VK_NULL_FUNC_ENTRY(vkDestroyDeferredOperationKHR,								destroyDeferredOperationKHR),
	VK_NULL_FUNC_ENTRY(vkGetDeferredOperationMaxConcurrencyKHR,						getDeferredOperationMaxConcurrencyKHR),
	VK_NULL_FUNC_ENTRY(vkGetDeferredOperationResultKHR,								getDeferredOperationResultKHR),
	VK_NULL_FUNC_ENTRY(vkDeferredOperationJoinKHR,									deferredOperationJoinKHR),
	VK_NULL_FUNC_ENTRY(vkCmdSetCullMode,											cmdSetCullMode),
	VK_NULL_FUNC_ENTRY(vkCmdSetFrontFace,											cmdSetFrontFace),
	VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveTopology,									cmdSetPrimitiveTopology),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewportWithCount,									cmdSetViewportWithCount),
	VK_NULL_FUNC_ENTRY(vkCmdSetScissorWithCount,									cmdSetScissorWithCount),
	VK_NULL_FUNC_ENTRY(vkCmdBindVertexBuffers2,										cmdBindVertexBuffers2),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthTestEnable,										cmdSetDepthTestEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthWriteEnable,									cmdSetDepthWriteEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthCompareOp,										cmdSetDepthCompareOp),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthBoundsTestEnable,								cmdSetDepthBoundsTestEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetStencilTestEnable,									cmdSetStencilTestEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetStencilOp,											cmdSetStencilOp),
	VK_NULL_FUNC_ENTRY(vkCmdSetPatchControlPointsEXT,								cmdSetPatchControlPointsEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetRasterizerDiscardEnable,								cmdSetRasterizerDiscardEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthBiasEnable,										cmdSetDepthBiasEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEXT,											cmdSetLogicOpEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetPrimitiveRestartEnable,								cmdSetPrimitiveRestartEnable),
	VK_NULL_FUNC_ENTRY(vkCmdSetTessellationDomainOriginEXT,							cmdSetTessellationDomainOriginEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthClampEnableEXT,									cmdSetDepthClampEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetPolygonModeEXT,										cmdSetPolygonModeEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetRasterizationSamplesEXT,								cmdSetRasterizationSamplesEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetSampleMaskEXT,										cmdSetSampleMaskEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetAlphaToCoverageEnableEXT,							cmdSetAlphaToCoverageEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetAlphaToOneEnableEXT,									cmdSetAlphaToOneEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetLogicOpEnableEXT,									cmdSetLogicOpEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendEnableEXT,									cmdSetColorBlendEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendEquationEXT,								cmdSetColorBlendEquationEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteMaskEXT,									cmdSetColorWriteMaskEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetRasterizationStreamEXT,								cmdSetRasterizationStreamEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetConservativeRasterizationModeEXT,					cmdSetConservativeRasterizationModeEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetExtraPrimitiveOverestimationSizeEXT,					cmdSetExtraPrimitiveOverestimationSizeEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthClipEnableEXT,									cmdSetDepthClipEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetSampleLocationsEnableEXT,							cmdSetSampleLocationsEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetColorBlendAdvancedEXT,								cmdSetColorBlendAdvancedEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetProvokingVertexModeEXT,								cmdSetProvokingVertexModeEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetLineRasterizationModeEXT,							cmdSetLineRasterizationModeEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetLineStippleEnableEXT,								cmdSetLineStippleEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetDepthClipNegativeOneToOneEXT,						cmdSetDepthClipNegativeOneToOneEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewportWScalingEnableNV,							cmdSetViewportWScalingEnableNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetViewportSwizzleNV,									cmdSetViewportSwizzleNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageToColorEnableNV,								cmdSetCoverageToColorEnableNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageToColorLocationNV,							cmdSetCoverageToColorLocationNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationModeNV,							cmdSetCoverageModulationModeNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationTableEnableNV,						cmdSetCoverageModulationTableEnableNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageModulationTableNV,							cmdSetCoverageModulationTableNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetShadingRateImageEnableNV,							cmdSetShadingRateImageEnableNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetCoverageReductionModeNV,								cmdSetCoverageReductionModeNV),
	VK_NULL_FUNC_ENTRY(vkCmdSetRepresentativeFragmentTestEnableNV,					cmdSetRepresentativeFragmentTestEnableNV),
	VK_NULL_FUNC_ENTRY(vkCreatePrivateDataSlot,										createPrivateDataSlot),
	VK_NULL_FUNC_ENTRY(vkDestroyPrivateDataSlot,									destroyPrivateDataSlot),
	VK_NULL_FUNC_ENTRY(vkSetPrivateData,											setPrivateData),
	VK_NULL_FUNC_ENTRY(vkGetPrivateData,											getPrivateData),
	VK_NULL_FUNC_ENTRY(vkCmdCopyBuffer2,											cmdCopyBuffer2),
	VK_NULL_FUNC_ENTRY(vkCmdCopyImage2,												cmdCopyImage2),
	VK_NULL_FUNC_ENTRY(vkCmdBlitImage2,												cmdBlitImage2),
	VK_NULL_FUNC_ENTRY(vkCmdCopyBufferToImage2,										cmdCopyBufferToImage2),
	VK_NULL_FUNC_ENTRY(vkCmdCopyImageToBuffer2,										cmdCopyImageToBuffer2),
	VK_NULL_FUNC_ENTRY(vkCmdResolveImage2,											cmdResolveImage2),
	VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateKHR,								cmdSetFragmentShadingRateKHR),
	VK_NULL_FUNC_ENTRY(vkCmdSetFragmentShadingRateEnumNV,							cmdSetFragmentShadingRateEnumNV),
	VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureBuildSizesKHR,						getAccelerationStructureBuildSizesKHR),
	VK_NULL_FUNC_ENTRY(vkCmdSetVertexInputEXT,										cmdSetVertexInputEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetColorWriteEnableEXT,									cmdSetColorWriteEnableEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetEvent2,												cmdSetEvent2),
	VK_NULL_FUNC_ENTRY(vkCmdResetEvent2,											cmdResetEvent2),
	VK_NULL_FUNC_ENTRY(vkCmdWaitEvents2,											cmdWaitEvents2),
	VK_NULL_FUNC_ENTRY(vkCmdPipelineBarrier2,										cmdPipelineBarrier2),
	VK_NULL_FUNC_ENTRY(vkQueueSubmit2,												queueSubmit2),
	VK_NULL_FUNC_ENTRY(vkCmdWriteTimestamp2,										cmdWriteTimestamp2),
	VK_NULL_FUNC_ENTRY(vkCmdWriteBufferMarker2AMD,									cmdWriteBufferMarker2AMD),
	VK_NULL_FUNC_ENTRY(vkGetQueueCheckpointData2NV,									getQueueCheckpointData2NV),
	VK_NULL_FUNC_ENTRY(vkCreateVideoSessionKHR,										createVideoSessionKHR),
	VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionKHR,									destroyVideoSessionKHR),
	VK_NULL_FUNC_ENTRY(vkCreateVideoSessionParametersKHR,							createVideoSessionParametersKHR),
	VK_NULL_FUNC_ENTRY(vkUpdateVideoSessionParametersKHR,							updateVideoSessionParametersKHR),
	VK_NULL_FUNC_ENTRY(vkDestroyVideoSessionParametersKHR,							destroyVideoSessionParametersKHR),
	VK_NULL_FUNC_ENTRY(vkGetVideoSessionMemoryRequirementsKHR,						getVideoSessionMemoryRequirementsKHR),
	VK_NULL_FUNC_ENTRY(vkBindVideoSessionMemoryKHR,									bindVideoSessionMemoryKHR),
	VK_NULL_FUNC_ENTRY(vkCmdDecodeVideoKHR,											cmdDecodeVideoKHR),
	VK_NULL_FUNC_ENTRY(vkCmdBeginVideoCodingKHR,									cmdBeginVideoCodingKHR),
	VK_NULL_FUNC_ENTRY(vkCmdControlVideoCodingKHR,									cmdControlVideoCodingKHR),
	VK_NULL_FUNC_ENTRY(vkCmdEndVideoCodingKHR,										cmdEndVideoCodingKHR),
	VK_NULL_FUNC_ENTRY(vkCmdEncodeVideoKHR,											cmdEncodeVideoKHR),
	VK_NULL_FUNC_ENTRY(vkCmdDecompressMemoryNV,										cmdDecompressMemoryNV),
	VK_NULL_FUNC_ENTRY(vkCmdDecompressMemoryIndirectCountNV,						cmdDecompressMemoryIndirectCountNV),
	VK_NULL_FUNC_ENTRY(vkCreateCuModuleNVX,											createCuModuleNVX),
	VK_NULL_FUNC_ENTRY(vkCreateCuFunctionNVX,										createCuFunctionNVX),
	VK_NULL_FUNC_ENTRY(vkDestroyCuModuleNVX,										destroyCuModuleNVX),
	VK_NULL_FUNC_ENTRY(vkDestroyCuFunctionNVX,										destroyCuFunctionNVX),
	VK_NULL_FUNC_ENTRY(vkCmdCuLaunchKernelNVX,										cmdCuLaunchKernelNVX),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutSizeEXT,								getDescriptorSetLayoutSizeEXT),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutBindingOffsetEXT,					getDescriptorSetLayoutBindingOffsetEXT),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorEXT,											getDescriptorEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorBuffersEXT,								cmdBindDescriptorBuffersEXT),
	VK_NULL_FUNC_ENTRY(vkCmdSetDescriptorBufferOffsetsEXT,							cmdSetDescriptorBufferOffsetsEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBindDescriptorBufferEmbeddedSamplersEXT,				cmdBindDescriptorBufferEmbeddedSamplersEXT),
	VK_NULL_FUNC_ENTRY(vkGetBufferOpaqueCaptureDescriptorDataEXT,					getBufferOpaqueCaptureDescriptorDataEXT),
	VK_NULL_FUNC_ENTRY(vkGetImageOpaqueCaptureDescriptorDataEXT,					getImageOpaqueCaptureDescriptorDataEXT),
	VK_NULL_FUNC_ENTRY(vkGetImageViewOpaqueCaptureDescriptorDataEXT,				getImageViewOpaqueCaptureDescriptorDataEXT),
	VK_NULL_FUNC_ENTRY(vkGetSamplerOpaqueCaptureDescriptorDataEXT,					getSamplerOpaqueCaptureDescriptorDataEXT),
	VK_NULL_FUNC_ENTRY(vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,	getAccelerationStructureOpaqueCaptureDescriptorDataEXT),
	VK_NULL_FUNC_ENTRY(vkSetDeviceMemoryPriorityEXT,								setDeviceMemoryPriorityEXT),
	VK_NULL_FUNC_ENTRY(vkWaitForPresentKHR,											waitForPresentKHR),
	VK_NULL_FUNC_ENTRY(vkCreateBufferCollectionFUCHSIA,								createBufferCollectionFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkSetBufferCollectionBufferConstraintsFUCHSIA,				setBufferCollectionBufferConstraintsFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkSetBufferCollectionImageConstraintsFUCHSIA,				setBufferCollectionImageConstraintsFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkDestroyBufferCollectionFUCHSIA,							destroyBufferCollectionFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkGetBufferCollectionPropertiesFUCHSIA,						getBufferCollectionPropertiesFUCHSIA),
	VK_NULL_FUNC_ENTRY(vkCmdBeginRendering,											cmdBeginRendering),
	VK_NULL_FUNC_ENTRY(vkCmdEndRendering,											cmdEndRendering),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorSetLayoutHostMappingInfoVALVE,				getDescriptorSetLayoutHostMappingInfoVALVE),
	VK_NULL_FUNC_ENTRY(vkGetDescriptorSetHostMappingVALVE,							getDescriptorSetHostMappingVALVE),
	VK_NULL_FUNC_ENTRY(vkCreateMicromapEXT,											createMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCmdBuildMicromapsEXT,										cmdBuildMicromapsEXT),
	VK_NULL_FUNC_ENTRY(vkBuildMicromapsEXT,											buildMicromapsEXT),
	VK_NULL_FUNC_ENTRY(vkDestroyMicromapEXT,										destroyMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMicromapEXT,										cmdCopyMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCopyMicromapEXT,											copyMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMicromapToMemoryEXT,								cmdCopyMicromapToMemoryEXT),
	VK_NULL_FUNC_ENTRY(vkCopyMicromapToMemoryEXT,									copyMicromapToMemoryEXT),
	VK_NULL_FUNC_ENTRY(vkCmdCopyMemoryToMicromapEXT,								cmdCopyMemoryToMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCopyMemoryToMicromapEXT,									copyMemoryToMicromapEXT),
	VK_NULL_FUNC_ENTRY(vkCmdWriteMicromapsPropertiesEXT,							cmdWriteMicromapsPropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkWriteMicromapsPropertiesEXT,								writeMicromapsPropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkGetDeviceMicromapCompatibilityEXT,							getDeviceMicromapCompatibilityEXT),
	VK_NULL_FUNC_ENTRY(vkGetMicromapBuildSizesEXT,									getMicromapBuildSizesEXT),
	VK_NULL_FUNC_ENTRY(vkGetShaderModuleIdentifierEXT,								getShaderModuleIdentifierEXT),
	VK_NULL_FUNC_ENTRY(vkGetShaderModuleCreateInfoIdentifierEXT,					getShaderModuleCreateInfoIdentifierEXT),
	VK_NULL_FUNC_ENTRY(vkGetImageSubresourceLayout2EXT,								getImageSubresourceLayout2EXT),
	VK_NULL_FUNC_ENTRY(vkGetPipelinePropertiesEXT,									getPipelinePropertiesEXT),
	VK_NULL_FUNC_ENTRY(vkExportMetalObjectsEXT,										exportMetalObjectsEXT),
	VK_NULL_FUNC_ENTRY(vkGetFramebufferTilePropertiesQCOM,							getFramebufferTilePropertiesQCOM),
	VK_NULL_FUNC_ENTRY(vkGetDynamicRenderingTilePropertiesQCOM,						getDynamicRenderingTilePropertiesQCOM),
	VK_NULL_FUNC_ENTRY(vkCreateOpticalFlowSessionNV,								createOpticalFlowSessionNV),
	VK_NULL_FUNC_ENTRY(vkDestroyOpticalFlowSessionNV,								destroyOpticalFlowSessionNV),
	VK_NULL_FUNC_ENTRY(vkBindOpticalFlowSessionImageNV,								bindOpticalFlowSessionImageNV),
	VK_NULL_FUNC_ENTRY(vkCmdOpticalFlowExecuteNV,									cmdOpticalFlowExecuteNV),
	VK_NULL_FUNC_ENTRY(vkGetDeviceFaultInfoEXT,										getDeviceFaultInfoEXT),
	VK_NULL_FUNC_ENTRY(vkReleaseSwapchainImagesEXT,									releaseSwapchainImagesEXT),
};