system/vulkan_cereal/goldfish_vk_frontend.cpp

// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Autogenerated module goldfish_vk_frontend
// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
// Please do not modify directly;
// re-run android/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR

#include "goldfish_vk_frontend.h"



namespace goldfish_vk {

#ifdef VK_VERSION_1_0
static void validate_vkCreateInstance(
    VkResult* validateResult,
    const VkInstanceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkInstance* pInstance)
{
}

VkResult goldfish_frontend_vkCreateInstance(
    const VkInstanceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkInstance* pInstance)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateInstance(&validateResult, pCreateInfo, pAllocator, pInstance);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateInstance(vkStream, pCreateInfo, pAllocator, pInstance);
    return res;
}

static void validate_vkDestroyInstance(
    VkResult* validateResult,
    VkInstance instance,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyInstance(
    VkInstance instance,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyInstance(&validateResult, instance, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyInstance(vkStream, instance, pAllocator);
}

static void validate_vkEnumeratePhysicalDevices(
    VkResult* validateResult,
    VkInstance instance,
    uint32_t* pPhysicalDeviceCount,
    VkPhysicalDevice* pPhysicalDevices)
{
}

VkResult goldfish_frontend_vkEnumeratePhysicalDevices(
    VkInstance instance,
    uint32_t* pPhysicalDeviceCount,
    VkPhysicalDevice* pPhysicalDevices)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumeratePhysicalDevices(&validateResult, instance, pPhysicalDeviceCount, pPhysicalDevices);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumeratePhysicalDevices(vkStream, instance, pPhysicalDeviceCount, pPhysicalDevices);
    return res;
}

static void validate_vkGetPhysicalDeviceFeatures(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures* pFeatures)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFeatures(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures* pFeatures)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFeatures(&validateResult, physicalDevice, pFeatures);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFeatures(vkStream, physicalDevice, pFeatures);
}

static void validate_vkGetPhysicalDeviceFormatProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties* pFormatProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties* pFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFormatProperties(&validateResult, physicalDevice, format, pFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFormatProperties(vkStream, physicalDevice, format, pFormatProperties);
}

static void validate_vkGetPhysicalDeviceImageFormatProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceImageFormatProperties(&validateResult, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceImageFormatProperties(vkStream, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
    return res;
}

static void validate_vkGetPhysicalDeviceProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceProperties(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceProperties(&validateResult, physicalDevice, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceProperties(vkStream, physicalDevice, pProperties);
}

static void validate_vkGetPhysicalDeviceQueueFamilyProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceQueueFamilyProperties(
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceQueueFamilyProperties(&validateResult, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceQueueFamilyProperties(vkStream, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}

static void validate_vkGetPhysicalDeviceMemoryProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceMemoryProperties(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceMemoryProperties(&validateResult, physicalDevice, pMemoryProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceMemoryProperties(vkStream, physicalDevice, pMemoryProperties);
}

static void validate_vkGetInstanceProcAddr(
    VkResult* validateResult,
    VkInstance instance,
    const char* pName)
{
}

PFN_vkVoidFunction goldfish_frontend_vkGetInstanceProcAddr(
    VkInstance instance,
    const char* pName)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetInstanceProcAddr(&validateResult, instance, pName);
    if (validateResult != VK_SUCCESS)
    {
        return (PFN_vkVoidFunction)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    PFN_vkVoidFunction res = marshal_vkGetInstanceProcAddr(vkStream, instance, pName);
    return res;
}

static void validate_vkGetDeviceProcAddr(
    VkResult* validateResult,
    VkDevice device,
    const char* pName)
{
}

PFN_vkVoidFunction goldfish_frontend_vkGetDeviceProcAddr(
    VkDevice device,
    const char* pName)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceProcAddr(&validateResult, device, pName);
    if (validateResult != VK_SUCCESS)
    {
        return (PFN_vkVoidFunction)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    PFN_vkVoidFunction res = marshal_vkGetDeviceProcAddr(vkStream, device, pName);
    return res;
}

static void validate_vkCreateDevice(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkDeviceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDevice* pDevice)
{
}

VkResult goldfish_frontend_vkCreateDevice(
    VkPhysicalDevice physicalDevice,
    const VkDeviceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDevice* pDevice)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDevice(&validateResult, physicalDevice, pCreateInfo, pAllocator, pDevice);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDevice(vkStream, physicalDevice, pCreateInfo, pAllocator, pDevice);
    return res;
}

static void validate_vkDestroyDevice(
    VkResult* validateResult,
    VkDevice device,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDevice(
    VkDevice device,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDevice(&validateResult, device, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDevice(vkStream, device, pAllocator);
}

static void validate_vkEnumerateInstanceExtensionProperties(
    VkResult* validateResult,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
}

VkResult goldfish_frontend_vkEnumerateInstanceExtensionProperties(
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumerateInstanceExtensionProperties(&validateResult, pLayerName, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumerateInstanceExtensionProperties(vkStream, pLayerName, pPropertyCount, pProperties);
    return res;
}

static void validate_vkEnumerateDeviceExtensionProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
}

VkResult goldfish_frontend_vkEnumerateDeviceExtensionProperties(
    VkPhysicalDevice physicalDevice,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumerateDeviceExtensionProperties(&validateResult, physicalDevice, pLayerName, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumerateDeviceExtensionProperties(vkStream, physicalDevice, pLayerName, pPropertyCount, pProperties);
    return res;
}

static void validate_vkEnumerateInstanceLayerProperties(
    VkResult* validateResult,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
}

VkResult goldfish_frontend_vkEnumerateInstanceLayerProperties(
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumerateInstanceLayerProperties(&validateResult, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumerateInstanceLayerProperties(vkStream, pPropertyCount, pProperties);
    return res;
}

static void validate_vkEnumerateDeviceLayerProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
}

VkResult goldfish_frontend_vkEnumerateDeviceLayerProperties(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumerateDeviceLayerProperties(&validateResult, physicalDevice, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumerateDeviceLayerProperties(vkStream, physicalDevice, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetDeviceQueue(
    VkResult* validateResult,
    VkDevice device,
    uint32_t queueFamilyIndex,
    uint32_t queueIndex,
    VkQueue* pQueue)
{
}

void goldfish_frontend_vkGetDeviceQueue(
    VkDevice device,
    uint32_t queueFamilyIndex,
    uint32_t queueIndex,
    VkQueue* pQueue)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceQueue(&validateResult, device, queueFamilyIndex, queueIndex, pQueue);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDeviceQueue(vkStream, device, queueFamilyIndex, queueIndex, pQueue);
}

static void validate_vkQueueSubmit(
    VkResult* validateResult,
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
}

VkResult goldfish_frontend_vkQueueSubmit(
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueSubmit(&validateResult, queue, submitCount, pSubmits, fence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkQueueSubmit(vkStream, queue, submitCount, pSubmits, fence);
    return res;
}

static void validate_vkQueueWaitIdle(
    VkResult* validateResult,
    VkQueue queue)
{
}

VkResult goldfish_frontend_vkQueueWaitIdle(
    VkQueue queue)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueWaitIdle(&validateResult, queue);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkQueueWaitIdle(vkStream, queue);
    return res;
}

static void validate_vkDeviceWaitIdle(
    VkResult* validateResult,
    VkDevice device)
{
}

VkResult goldfish_frontend_vkDeviceWaitIdle(
    VkDevice device)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDeviceWaitIdle(&validateResult, device);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkDeviceWaitIdle(vkStream, device);
    return res;
}

static void validate_vkAllocateMemory(
    VkResult* validateResult,
    VkDevice device,
    const VkMemoryAllocateInfo* pAllocateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDeviceMemory* pMemory)
{
}

VkResult goldfish_frontend_vkAllocateMemory(
    VkDevice device,
    const VkMemoryAllocateInfo* pAllocateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDeviceMemory* pMemory)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAllocateMemory(&validateResult, device, pAllocateInfo, pAllocator, pMemory);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAllocateMemory(vkStream, device, pAllocateInfo, pAllocator, pMemory);
    return res;
}

static void validate_vkFreeMemory(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkFreeMemory(
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkFreeMemory(&validateResult, device, memory, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkFreeMemory(vkStream, device, memory, pAllocator);
}

static void validate_vkMapMemory(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize offset,
    VkDeviceSize size,
    VkMemoryMapFlags flags,
    void** ppData)
{
}

VkResult goldfish_frontend_vkMapMemory(
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize offset,
    VkDeviceSize size,
    VkMemoryMapFlags flags,
    void** ppData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkMapMemory(&validateResult, device, memory, offset, size, flags, ppData);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkMapMemory(vkStream, device, memory, offset, size, flags, ppData);
    return res;
}

static void validate_vkUnmapMemory(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceMemory memory)
{
}

void goldfish_frontend_vkUnmapMemory(
    VkDevice device,
    VkDeviceMemory memory)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkUnmapMemory(&validateResult, device, memory);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkUnmapMemory(vkStream, device, memory);
}

static void validate_vkFlushMappedMemoryRanges(
    VkResult* validateResult,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
}

VkResult goldfish_frontend_vkFlushMappedMemoryRanges(
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkFlushMappedMemoryRanges(&validateResult, device, memoryRangeCount, pMemoryRanges);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkFlushMappedMemoryRanges(vkStream, device, memoryRangeCount, pMemoryRanges);
    return res;
}

static void validate_vkInvalidateMappedMemoryRanges(
    VkResult* validateResult,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
}

VkResult goldfish_frontend_vkInvalidateMappedMemoryRanges(
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkInvalidateMappedMemoryRanges(&validateResult, device, memoryRangeCount, pMemoryRanges);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkInvalidateMappedMemoryRanges(vkStream, device, memoryRangeCount, pMemoryRanges);
    return res;
}

static void validate_vkGetDeviceMemoryCommitment(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize* pCommittedMemoryInBytes)
{
}

void goldfish_frontend_vkGetDeviceMemoryCommitment(
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize* pCommittedMemoryInBytes)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceMemoryCommitment(&validateResult, device, memory, pCommittedMemoryInBytes);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDeviceMemoryCommitment(vkStream, device, memory, pCommittedMemoryInBytes);
}

static void validate_vkBindBufferMemory(
    VkResult* validateResult,
    VkDevice device,
    VkBuffer buffer,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
}

VkResult goldfish_frontend_vkBindBufferMemory(
    VkDevice device,
    VkBuffer buffer,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindBufferMemory(&validateResult, device, buffer, memory, memoryOffset);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindBufferMemory(vkStream, device, buffer, memory, memoryOffset);
    return res;
}

static void validate_vkBindImageMemory(
    VkResult* validateResult,
    VkDevice device,
    VkImage image,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
}

VkResult goldfish_frontend_vkBindImageMemory(
    VkDevice device,
    VkImage image,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindImageMemory(&validateResult, device, image, memory, memoryOffset);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindImageMemory(vkStream, device, image, memory, memoryOffset);
    return res;
}

static void validate_vkGetBufferMemoryRequirements(
    VkResult* validateResult,
    VkDevice device,
    VkBuffer buffer,
    VkMemoryRequirements* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetBufferMemoryRequirements(
    VkDevice device,
    VkBuffer buffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetBufferMemoryRequirements(&validateResult, device, buffer, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetBufferMemoryRequirements(vkStream, device, buffer, pMemoryRequirements);
}

static void validate_vkGetImageMemoryRequirements(
    VkResult* validateResult,
    VkDevice device,
    VkImage image,
    VkMemoryRequirements* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageMemoryRequirements(
    VkDevice device,
    VkImage image,
    VkMemoryRequirements* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageMemoryRequirements(&validateResult, device, image, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageMemoryRequirements(vkStream, device, image, pMemoryRequirements);
}

static void validate_vkGetImageSparseMemoryRequirements(
    VkResult* validateResult,
    VkDevice device,
    VkImage image,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageSparseMemoryRequirements(
    VkDevice device,
    VkImage image,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageSparseMemoryRequirements(&validateResult, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageSparseMemoryRequirements(vkStream, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}

static void validate_vkGetPhysicalDeviceSparseImageFormatProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkSampleCountFlagBits samples,
    VkImageUsageFlags usage,
    VkImageTiling tiling,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkSampleCountFlagBits samples,
    VkImageUsageFlags usage,
    VkImageTiling tiling,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSparseImageFormatProperties(&validateResult, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceSparseImageFormatProperties(vkStream, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}

static void validate_vkQueueBindSparse(
    VkResult* validateResult,
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
}

VkResult goldfish_frontend_vkQueueBindSparse(
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueBindSparse(&validateResult, queue, bindInfoCount, pBindInfo, fence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkQueueBindSparse(vkStream, queue, bindInfoCount, pBindInfo, fence);
    return res;
}

static void validate_vkCreateFence(
    VkResult* validateResult,
    VkDevice device,
    const VkFenceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
}

VkResult goldfish_frontend_vkCreateFence(
    VkDevice device,
    const VkFenceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateFence(&validateResult, device, pCreateInfo, pAllocator, pFence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateFence(vkStream, device, pCreateInfo, pAllocator, pFence);
    return res;
}

static void validate_vkDestroyFence(
    VkResult* validateResult,
    VkDevice device,
    VkFence fence,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyFence(
    VkDevice device,
    VkFence fence,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyFence(&validateResult, device, fence, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyFence(vkStream, device, fence, pAllocator);
}

static void validate_vkResetFences(
    VkResult* validateResult,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences)
{
}

VkResult goldfish_frontend_vkResetFences(
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkResetFences(&validateResult, device, fenceCount, pFences);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkResetFences(vkStream, device, fenceCount, pFences);
    return res;
}

static void validate_vkGetFenceStatus(
    VkResult* validateResult,
    VkDevice device,
    VkFence fence)
{
}

VkResult goldfish_frontend_vkGetFenceStatus(
    VkDevice device,
    VkFence fence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetFenceStatus(&validateResult, device, fence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetFenceStatus(vkStream, device, fence);
    return res;
}

static void validate_vkWaitForFences(
    VkResult* validateResult,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences,
    VkBool32 waitAll,
    uint64_t timeout)
{
}

VkResult goldfish_frontend_vkWaitForFences(
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences,
    VkBool32 waitAll,
    uint64_t timeout)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkWaitForFences(&validateResult, device, fenceCount, pFences, waitAll, timeout);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkWaitForFences(vkStream, device, fenceCount, pFences, waitAll, timeout);
    return res;
}

static void validate_vkCreateSemaphore(
    VkResult* validateResult,
    VkDevice device,
    const VkSemaphoreCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSemaphore* pSemaphore)
{
}

VkResult goldfish_frontend_vkCreateSemaphore(
    VkDevice device,
    const VkSemaphoreCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSemaphore* pSemaphore)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSemaphore(&validateResult, device, pCreateInfo, pAllocator, pSemaphore);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSemaphore(vkStream, device, pCreateInfo, pAllocator, pSemaphore);
    return res;
}

static void validate_vkDestroySemaphore(
    VkResult* validateResult,
    VkDevice device,
    VkSemaphore semaphore,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySemaphore(
    VkDevice device,
    VkSemaphore semaphore,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySemaphore(&validateResult, device, semaphore, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySemaphore(vkStream, device, semaphore, pAllocator);
}

static void validate_vkCreateEvent(
    VkResult* validateResult,
    VkDevice device,
    const VkEventCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkEvent* pEvent)
{
}

VkResult goldfish_frontend_vkCreateEvent(
    VkDevice device,
    const VkEventCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkEvent* pEvent)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateEvent(&validateResult, device, pCreateInfo, pAllocator, pEvent);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateEvent(vkStream, device, pCreateInfo, pAllocator, pEvent);
    return res;
}

static void validate_vkDestroyEvent(
    VkResult* validateResult,
    VkDevice device,
    VkEvent event,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyEvent(
    VkDevice device,
    VkEvent event,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyEvent(&validateResult, device, event, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyEvent(vkStream, device, event, pAllocator);
}

static void validate_vkGetEventStatus(
    VkResult* validateResult,
    VkDevice device,
    VkEvent event)
{
}

VkResult goldfish_frontend_vkGetEventStatus(
    VkDevice device,
    VkEvent event)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetEventStatus(&validateResult, device, event);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetEventStatus(vkStream, device, event);
    return res;
}

static void validate_vkSetEvent(
    VkResult* validateResult,
    VkDevice device,
    VkEvent event)
{
}

VkResult goldfish_frontend_vkSetEvent(
    VkDevice device,
    VkEvent event)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkSetEvent(&validateResult, device, event);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkSetEvent(vkStream, device, event);
    return res;
}

static void validate_vkResetEvent(
    VkResult* validateResult,
    VkDevice device,
    VkEvent event)
{
}

VkResult goldfish_frontend_vkResetEvent(
    VkDevice device,
    VkEvent event)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkResetEvent(&validateResult, device, event);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkResetEvent(vkStream, device, event);
    return res;
}

static void validate_vkCreateQueryPool(
    VkResult* validateResult,
    VkDevice device,
    const VkQueryPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkQueryPool* pQueryPool)
{
}

VkResult goldfish_frontend_vkCreateQueryPool(
    VkDevice device,
    const VkQueryPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkQueryPool* pQueryPool)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateQueryPool(&validateResult, device, pCreateInfo, pAllocator, pQueryPool);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateQueryPool(vkStream, device, pCreateInfo, pAllocator, pQueryPool);
    return res;
}

static void validate_vkDestroyQueryPool(
    VkResult* validateResult,
    VkDevice device,
    VkQueryPool queryPool,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyQueryPool(
    VkDevice device,
    VkQueryPool queryPool,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyQueryPool(&validateResult, device, queryPool, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyQueryPool(vkStream, device, queryPool, pAllocator);
}

static void validate_vkGetQueryPoolResults(
    VkResult* validateResult,
    VkDevice device,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    size_t dataSize,
    void* pData,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
}

VkResult goldfish_frontend_vkGetQueryPoolResults(
    VkDevice device,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    size_t dataSize,
    void* pData,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetQueryPoolResults(&validateResult, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetQueryPoolResults(vkStream, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
    return res;
}

static void validate_vkCreateBuffer(
    VkResult* validateResult,
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer)
{
}

VkResult goldfish_frontend_vkCreateBuffer(
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateBuffer(&validateResult, device, pCreateInfo, pAllocator, pBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateBuffer(vkStream, device, pCreateInfo, pAllocator, pBuffer);
    return res;
}

static void validate_vkDestroyBuffer(
    VkResult* validateResult,
    VkDevice device,
    VkBuffer buffer,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyBuffer(
    VkDevice device,
    VkBuffer buffer,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyBuffer(&validateResult, device, buffer, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyBuffer(vkStream, device, buffer, pAllocator);
}

static void validate_vkCreateBufferView(
    VkResult* validateResult,
    VkDevice device,
    const VkBufferViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBufferView* pView)
{
}

VkResult goldfish_frontend_vkCreateBufferView(
    VkDevice device,
    const VkBufferViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBufferView* pView)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateBufferView(&validateResult, device, pCreateInfo, pAllocator, pView);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateBufferView(vkStream, device, pCreateInfo, pAllocator, pView);
    return res;
}

static void validate_vkDestroyBufferView(
    VkResult* validateResult,
    VkDevice device,
    VkBufferView bufferView,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyBufferView(
    VkDevice device,
    VkBufferView bufferView,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyBufferView(&validateResult, device, bufferView, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyBufferView(vkStream, device, bufferView, pAllocator);
}

static void validate_vkCreateImage(
    VkResult* validateResult,
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage)
{
}

VkResult goldfish_frontend_vkCreateImage(
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateImage(&validateResult, device, pCreateInfo, pAllocator, pImage);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateImage(vkStream, device, pCreateInfo, pAllocator, pImage);
    return res;
}

static void validate_vkDestroyImage(
    VkResult* validateResult,
    VkDevice device,
    VkImage image,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyImage(
    VkDevice device,
    VkImage image,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyImage(&validateResult, device, image, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyImage(vkStream, device, image, pAllocator);
}

static void validate_vkGetImageSubresourceLayout(
    VkResult* validateResult,
    VkDevice device,
    VkImage image,
    const VkImageSubresource* pSubresource,
    VkSubresourceLayout* pLayout)
{
}

void goldfish_frontend_vkGetImageSubresourceLayout(
    VkDevice device,
    VkImage image,
    const VkImageSubresource* pSubresource,
    VkSubresourceLayout* pLayout)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageSubresourceLayout(&validateResult, device, image, pSubresource, pLayout);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageSubresourceLayout(vkStream, device, image, pSubresource, pLayout);
}

static void validate_vkCreateImageView(
    VkResult* validateResult,
    VkDevice device,
    const VkImageViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImageView* pView)
{
}

VkResult goldfish_frontend_vkCreateImageView(
    VkDevice device,
    const VkImageViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImageView* pView)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateImageView(&validateResult, device, pCreateInfo, pAllocator, pView);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateImageView(vkStream, device, pCreateInfo, pAllocator, pView);
    return res;
}

static void validate_vkDestroyImageView(
    VkResult* validateResult,
    VkDevice device,
    VkImageView imageView,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyImageView(
    VkDevice device,
    VkImageView imageView,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyImageView(&validateResult, device, imageView, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyImageView(vkStream, device, imageView, pAllocator);
}

static void validate_vkCreateShaderModule(
    VkResult* validateResult,
    VkDevice device,
    const VkShaderModuleCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkShaderModule* pShaderModule)
{
}

VkResult goldfish_frontend_vkCreateShaderModule(
    VkDevice device,
    const VkShaderModuleCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkShaderModule* pShaderModule)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateShaderModule(&validateResult, device, pCreateInfo, pAllocator, pShaderModule);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateShaderModule(vkStream, device, pCreateInfo, pAllocator, pShaderModule);
    return res;
}

static void validate_vkDestroyShaderModule(
    VkResult* validateResult,
    VkDevice device,
    VkShaderModule shaderModule,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyShaderModule(
    VkDevice device,
    VkShaderModule shaderModule,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyShaderModule(&validateResult, device, shaderModule, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyShaderModule(vkStream, device, shaderModule, pAllocator);
}

static void validate_vkCreatePipelineCache(
    VkResult* validateResult,
    VkDevice device,
    const VkPipelineCacheCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineCache* pPipelineCache)
{
}

VkResult goldfish_frontend_vkCreatePipelineCache(
    VkDevice device,
    const VkPipelineCacheCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineCache* pPipelineCache)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreatePipelineCache(&validateResult, device, pCreateInfo, pAllocator, pPipelineCache);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreatePipelineCache(vkStream, device, pCreateInfo, pAllocator, pPipelineCache);
    return res;
}

static void validate_vkDestroyPipelineCache(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineCache pipelineCache,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyPipelineCache(
    VkDevice device,
    VkPipelineCache pipelineCache,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyPipelineCache(&validateResult, device, pipelineCache, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyPipelineCache(vkStream, device, pipelineCache, pAllocator);
}

static void validate_vkGetPipelineCacheData(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineCache pipelineCache,
    size_t* pDataSize,
    void* pData)
{
}

VkResult goldfish_frontend_vkGetPipelineCacheData(
    VkDevice device,
    VkPipelineCache pipelineCache,
    size_t* pDataSize,
    void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPipelineCacheData(&validateResult, device, pipelineCache, pDataSize, pData);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPipelineCacheData(vkStream, device, pipelineCache, pDataSize, pData);
    return res;
}

static void validate_vkMergePipelineCaches(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineCache dstCache,
    uint32_t srcCacheCount,
    const VkPipelineCache* pSrcCaches)
{
}

VkResult goldfish_frontend_vkMergePipelineCaches(
    VkDevice device,
    VkPipelineCache dstCache,
    uint32_t srcCacheCount,
    const VkPipelineCache* pSrcCaches)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkMergePipelineCaches(&validateResult, device, dstCache, srcCacheCount, pSrcCaches);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkMergePipelineCaches(vkStream, device, dstCache, srcCacheCount, pSrcCaches);
    return res;
}

static void validate_vkCreateGraphicsPipelines(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkGraphicsPipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
}

VkResult goldfish_frontend_vkCreateGraphicsPipelines(
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkGraphicsPipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateGraphicsPipelines(&validateResult, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateGraphicsPipelines(vkStream, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return res;
}

static void validate_vkCreateComputePipelines(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkComputePipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
}

VkResult goldfish_frontend_vkCreateComputePipelines(
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkComputePipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateComputePipelines(&validateResult, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateComputePipelines(vkStream, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return res;
}

static void validate_vkDestroyPipeline(
    VkResult* validateResult,
    VkDevice device,
    VkPipeline pipeline,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyPipeline(
    VkDevice device,
    VkPipeline pipeline,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyPipeline(&validateResult, device, pipeline, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyPipeline(vkStream, device, pipeline, pAllocator);
}

static void validate_vkCreatePipelineLayout(
    VkResult* validateResult,
    VkDevice device,
    const VkPipelineLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineLayout* pPipelineLayout)
{
}

VkResult goldfish_frontend_vkCreatePipelineLayout(
    VkDevice device,
    const VkPipelineLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineLayout* pPipelineLayout)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreatePipelineLayout(&validateResult, device, pCreateInfo, pAllocator, pPipelineLayout);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreatePipelineLayout(vkStream, device, pCreateInfo, pAllocator, pPipelineLayout);
    return res;
}

static void validate_vkDestroyPipelineLayout(
    VkResult* validateResult,
    VkDevice device,
    VkPipelineLayout pipelineLayout,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyPipelineLayout(
    VkDevice device,
    VkPipelineLayout pipelineLayout,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyPipelineLayout(&validateResult, device, pipelineLayout, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyPipelineLayout(vkStream, device, pipelineLayout, pAllocator);
}

static void validate_vkCreateSampler(
    VkResult* validateResult,
    VkDevice device,
    const VkSamplerCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSampler* pSampler)
{
}

VkResult goldfish_frontend_vkCreateSampler(
    VkDevice device,
    const VkSamplerCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSampler* pSampler)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSampler(&validateResult, device, pCreateInfo, pAllocator, pSampler);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSampler(vkStream, device, pCreateInfo, pAllocator, pSampler);
    return res;
}

static void validate_vkDestroySampler(
    VkResult* validateResult,
    VkDevice device,
    VkSampler sampler,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySampler(
    VkDevice device,
    VkSampler sampler,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySampler(&validateResult, device, sampler, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySampler(vkStream, device, sampler, pAllocator);
}

static void validate_vkCreateDescriptorSetLayout(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorSetLayout* pSetLayout)
{
}

VkResult goldfish_frontend_vkCreateDescriptorSetLayout(
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorSetLayout* pSetLayout)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDescriptorSetLayout(&validateResult, device, pCreateInfo, pAllocator, pSetLayout);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDescriptorSetLayout(vkStream, device, pCreateInfo, pAllocator, pSetLayout);
    return res;
}

static void validate_vkDestroyDescriptorSetLayout(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorSetLayout descriptorSetLayout,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDescriptorSetLayout(
    VkDevice device,
    VkDescriptorSetLayout descriptorSetLayout,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDescriptorSetLayout(&validateResult, device, descriptorSetLayout, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDescriptorSetLayout(vkStream, device, descriptorSetLayout, pAllocator);
}

static void validate_vkCreateDescriptorPool(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorPool* pDescriptorPool)
{
}

VkResult goldfish_frontend_vkCreateDescriptorPool(
    VkDevice device,
    const VkDescriptorPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorPool* pDescriptorPool)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDescriptorPool(&validateResult, device, pCreateInfo, pAllocator, pDescriptorPool);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDescriptorPool(vkStream, device, pCreateInfo, pAllocator, pDescriptorPool);
    return res;
}

static void validate_vkDestroyDescriptorPool(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDescriptorPool(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDescriptorPool(&validateResult, device, descriptorPool, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDescriptorPool(vkStream, device, descriptorPool, pAllocator);
}

static void validate_vkResetDescriptorPool(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    VkDescriptorPoolResetFlags flags)
{
}

VkResult goldfish_frontend_vkResetDescriptorPool(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    VkDescriptorPoolResetFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkResetDescriptorPool(&validateResult, device, descriptorPool, flags);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkResetDescriptorPool(vkStream, device, descriptorPool, flags);
    return res;
}

static void validate_vkAllocateDescriptorSets(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorSetAllocateInfo* pAllocateInfo,
    VkDescriptorSet* pDescriptorSets)
{
}

VkResult goldfish_frontend_vkAllocateDescriptorSets(
    VkDevice device,
    const VkDescriptorSetAllocateInfo* pAllocateInfo,
    VkDescriptorSet* pDescriptorSets)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAllocateDescriptorSets(&validateResult, device, pAllocateInfo, pDescriptorSets);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAllocateDescriptorSets(vkStream, device, pAllocateInfo, pDescriptorSets);
    return res;
}

static void validate_vkFreeDescriptorSets(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets)
{
}

VkResult goldfish_frontend_vkFreeDescriptorSets(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkFreeDescriptorSets(&validateResult, device, descriptorPool, descriptorSetCount, pDescriptorSets);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkFreeDescriptorSets(vkStream, device, descriptorPool, descriptorSetCount, pDescriptorSets);
    return res;
}

static void validate_vkUpdateDescriptorSets(
    VkResult* validateResult,
    VkDevice device,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites,
    uint32_t descriptorCopyCount,
    const VkCopyDescriptorSet* pDescriptorCopies)
{
}

void goldfish_frontend_vkUpdateDescriptorSets(
    VkDevice device,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites,
    uint32_t descriptorCopyCount,
    const VkCopyDescriptorSet* pDescriptorCopies)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkUpdateDescriptorSets(&validateResult, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkUpdateDescriptorSets(vkStream, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}

static void validate_vkCreateFramebuffer(
    VkResult* validateResult,
    VkDevice device,
    const VkFramebufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFramebuffer* pFramebuffer)
{
}

VkResult goldfish_frontend_vkCreateFramebuffer(
    VkDevice device,
    const VkFramebufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFramebuffer* pFramebuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateFramebuffer(&validateResult, device, pCreateInfo, pAllocator, pFramebuffer);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateFramebuffer(vkStream, device, pCreateInfo, pAllocator, pFramebuffer);
    return res;
}

static void validate_vkDestroyFramebuffer(
    VkResult* validateResult,
    VkDevice device,
    VkFramebuffer framebuffer,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyFramebuffer(
    VkDevice device,
    VkFramebuffer framebuffer,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyFramebuffer(&validateResult, device, framebuffer, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyFramebuffer(vkStream, device, framebuffer, pAllocator);
}

static void validate_vkCreateRenderPass(
    VkResult* validateResult,
    VkDevice device,
    const VkRenderPassCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
}

VkResult goldfish_frontend_vkCreateRenderPass(
    VkDevice device,
    const VkRenderPassCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateRenderPass(&validateResult, device, pCreateInfo, pAllocator, pRenderPass);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateRenderPass(vkStream, device, pCreateInfo, pAllocator, pRenderPass);
    return res;
}

static void validate_vkDestroyRenderPass(
    VkResult* validateResult,
    VkDevice device,
    VkRenderPass renderPass,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyRenderPass(
    VkDevice device,
    VkRenderPass renderPass,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyRenderPass(&validateResult, device, renderPass, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyRenderPass(vkStream, device, renderPass, pAllocator);
}

static void validate_vkGetRenderAreaGranularity(
    VkResult* validateResult,
    VkDevice device,
    VkRenderPass renderPass,
    VkExtent2D* pGranularity)
{
}

void goldfish_frontend_vkGetRenderAreaGranularity(
    VkDevice device,
    VkRenderPass renderPass,
    VkExtent2D* pGranularity)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetRenderAreaGranularity(&validateResult, device, renderPass, pGranularity);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetRenderAreaGranularity(vkStream, device, renderPass, pGranularity);
}

static void validate_vkCreateCommandPool(
    VkResult* validateResult,
    VkDevice device,
    const VkCommandPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkCommandPool* pCommandPool)
{
}

VkResult goldfish_frontend_vkCreateCommandPool(
    VkDevice device,
    const VkCommandPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkCommandPool* pCommandPool)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateCommandPool(&validateResult, device, pCreateInfo, pAllocator, pCommandPool);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateCommandPool(vkStream, device, pCreateInfo, pAllocator, pCommandPool);
    return res;
}

static void validate_vkDestroyCommandPool(
    VkResult* validateResult,
    VkDevice device,
    VkCommandPool commandPool,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyCommandPool(&validateResult, device, commandPool, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyCommandPool(vkStream, device, commandPool, pAllocator);
}

static void validate_vkResetCommandPool(
    VkResult* validateResult,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolResetFlags flags)
{
}

VkResult goldfish_frontend_vkResetCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolResetFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkResetCommandPool(&validateResult, device, commandPool, flags);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkResetCommandPool(vkStream, device, commandPool, flags);
    return res;
}

static void validate_vkAllocateCommandBuffers(
    VkResult* validateResult,
    VkDevice device,
    const VkCommandBufferAllocateInfo* pAllocateInfo,
    VkCommandBuffer* pCommandBuffers)
{
}

VkResult goldfish_frontend_vkAllocateCommandBuffers(
    VkDevice device,
    const VkCommandBufferAllocateInfo* pAllocateInfo,
    VkCommandBuffer* pCommandBuffers)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAllocateCommandBuffers(&validateResult, device, pAllocateInfo, pCommandBuffers);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAllocateCommandBuffers(vkStream, device, pAllocateInfo, pCommandBuffers);
    return res;
}

static void validate_vkFreeCommandBuffers(
    VkResult* validateResult,
    VkDevice device,
    VkCommandPool commandPool,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
}

void goldfish_frontend_vkFreeCommandBuffers(
    VkDevice device,
    VkCommandPool commandPool,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkFreeCommandBuffers(&validateResult, device, commandPool, commandBufferCount, pCommandBuffers);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkFreeCommandBuffers(vkStream, device, commandPool, commandBufferCount, pCommandBuffers);
}

static void validate_vkBeginCommandBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
}

VkResult goldfish_frontend_vkBeginCommandBuffer(
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBeginCommandBuffer(&validateResult, commandBuffer, pBeginInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBeginCommandBuffer(vkStream, commandBuffer, pBeginInfo);
    return res;
}

static void validate_vkEndCommandBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer)
{
}

VkResult goldfish_frontend_vkEndCommandBuffer(
    VkCommandBuffer commandBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEndCommandBuffer(&validateResult, commandBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEndCommandBuffer(vkStream, commandBuffer);
    return res;
}

static void validate_vkResetCommandBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
}

VkResult goldfish_frontend_vkResetCommandBuffer(
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkResetCommandBuffer(&validateResult, commandBuffer, flags);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkResetCommandBuffer(vkStream, commandBuffer, flags);
    return res;
}

static void validate_vkCmdBindPipeline(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipeline pipeline)
{
}

void goldfish_frontend_vkCmdBindPipeline(
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipeline pipeline)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBindPipeline(&validateResult, commandBuffer, pipelineBindPoint, pipeline);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBindPipeline(vkStream, commandBuffer, pipelineBindPoint, pipeline);
}

static void validate_vkCmdSetViewport(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewport* pViewports)
{
}

void goldfish_frontend_vkCmdSetViewport(
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewport* pViewports)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetViewport(&validateResult, commandBuffer, firstViewport, viewportCount, pViewports);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetViewport(vkStream, commandBuffer, firstViewport, viewportCount, pViewports);
}

static void validate_vkCmdSetScissor(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t firstScissor,
    uint32_t scissorCount,
    const VkRect2D* pScissors)
{
}

void goldfish_frontend_vkCmdSetScissor(
    VkCommandBuffer commandBuffer,
    uint32_t firstScissor,
    uint32_t scissorCount,
    const VkRect2D* pScissors)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetScissor(&validateResult, commandBuffer, firstScissor, scissorCount, pScissors);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetScissor(vkStream, commandBuffer, firstScissor, scissorCount, pScissors);
}

static void validate_vkCmdSetLineWidth(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    float lineWidth)
{
}

void goldfish_frontend_vkCmdSetLineWidth(
    VkCommandBuffer commandBuffer,
    float lineWidth)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetLineWidth(&validateResult, commandBuffer, lineWidth);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetLineWidth(vkStream, commandBuffer, lineWidth);
}

static void validate_vkCmdSetDepthBias(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    float depthBiasConstantFactor,
    float depthBiasClamp,
    float depthBiasSlopeFactor)
{
}

void goldfish_frontend_vkCmdSetDepthBias(
    VkCommandBuffer commandBuffer,
    float depthBiasConstantFactor,
    float depthBiasClamp,
    float depthBiasSlopeFactor)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetDepthBias(&validateResult, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetDepthBias(vkStream, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}

static void validate_vkCmdSetBlendConstants(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const float blendConstants)
{
}

void goldfish_frontend_vkCmdSetBlendConstants(
    VkCommandBuffer commandBuffer,
    const float blendConstants)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetBlendConstants(&validateResult, commandBuffer, blendConstants);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetBlendConstants(vkStream, commandBuffer, blendConstants);
}

static void validate_vkCmdSetDepthBounds(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    float minDepthBounds,
    float maxDepthBounds)
{
}

void goldfish_frontend_vkCmdSetDepthBounds(
    VkCommandBuffer commandBuffer,
    float minDepthBounds,
    float maxDepthBounds)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetDepthBounds(&validateResult, commandBuffer, minDepthBounds, maxDepthBounds);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetDepthBounds(vkStream, commandBuffer, minDepthBounds, maxDepthBounds);
}

static void validate_vkCmdSetStencilCompareMask(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t compareMask)
{
}

void goldfish_frontend_vkCmdSetStencilCompareMask(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t compareMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetStencilCompareMask(&validateResult, commandBuffer, faceMask, compareMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetStencilCompareMask(vkStream, commandBuffer, faceMask, compareMask);
}

static void validate_vkCmdSetStencilWriteMask(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t writeMask)
{
}

void goldfish_frontend_vkCmdSetStencilWriteMask(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t writeMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetStencilWriteMask(&validateResult, commandBuffer, faceMask, writeMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetStencilWriteMask(vkStream, commandBuffer, faceMask, writeMask);
}

static void validate_vkCmdSetStencilReference(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t reference)
{
}

void goldfish_frontend_vkCmdSetStencilReference(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t reference)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetStencilReference(&validateResult, commandBuffer, faceMask, reference);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetStencilReference(vkStream, commandBuffer, faceMask, reference);
}

static void validate_vkCmdBindDescriptorSets(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t firstSet,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount,
    const uint32_t* pDynamicOffsets)
{
}

void goldfish_frontend_vkCmdBindDescriptorSets(
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t firstSet,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount,
    const uint32_t* pDynamicOffsets)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBindDescriptorSets(&validateResult, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBindDescriptorSets(vkStream, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}

static void validate_vkCmdBindIndexBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkIndexType indexType)
{
}

void goldfish_frontend_vkCmdBindIndexBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkIndexType indexType)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBindIndexBuffer(&validateResult, commandBuffer, buffer, offset, indexType);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBindIndexBuffer(vkStream, commandBuffer, buffer, offset, indexType);
}

static void validate_vkCmdBindVertexBuffers(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t firstBinding,
    uint32_t bindingCount,
    const VkBuffer* pBuffers,
    const VkDeviceSize* pOffsets)
{
}

void goldfish_frontend_vkCmdBindVertexBuffers(
    VkCommandBuffer commandBuffer,
    uint32_t firstBinding,
    uint32_t bindingCount,
    const VkBuffer* pBuffers,
    const VkDeviceSize* pOffsets)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBindVertexBuffers(&validateResult, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBindVertexBuffers(vkStream, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}

static void validate_vkCmdDraw(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t vertexCount,
    uint32_t instanceCount,
    uint32_t firstVertex,
    uint32_t firstInstance)
{
}

void goldfish_frontend_vkCmdDraw(
    VkCommandBuffer commandBuffer,
    uint32_t vertexCount,
    uint32_t instanceCount,
    uint32_t firstVertex,
    uint32_t firstInstance)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDraw(&validateResult, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDraw(vkStream, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}

static void validate_vkCmdDrawIndexed(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t indexCount,
    uint32_t instanceCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t firstInstance)
{
}

void goldfish_frontend_vkCmdDrawIndexed(
    VkCommandBuffer commandBuffer,
    uint32_t indexCount,
    uint32_t instanceCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t firstInstance)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndexed(&validateResult, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndexed(vkStream, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}

static void validate_vkCmdDrawIndirect(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndirect(&validateResult, commandBuffer, buffer, offset, drawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndirect(vkStream, commandBuffer, buffer, offset, drawCount, stride);
}

static void validate_vkCmdDrawIndexedIndirect(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndexedIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndexedIndirect(&validateResult, commandBuffer, buffer, offset, drawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndexedIndirect(vkStream, commandBuffer, buffer, offset, drawCount, stride);
}

static void validate_vkCmdDispatch(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
}

void goldfish_frontend_vkCmdDispatch(
    VkCommandBuffer commandBuffer,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDispatch(&validateResult, commandBuffer, groupCountX, groupCountY, groupCountZ);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDispatch(vkStream, commandBuffer, groupCountX, groupCountY, groupCountZ);
}

static void validate_vkCmdDispatchIndirect(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset)
{
}

void goldfish_frontend_vkCmdDispatchIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDispatchIndirect(&validateResult, commandBuffer, buffer, offset);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDispatchIndirect(vkStream, commandBuffer, buffer, offset);
}

static void validate_vkCmdCopyBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferCopy* pRegions)
{
}

void goldfish_frontend_vkCmdCopyBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferCopy* pRegions)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdCopyBuffer(&validateResult, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdCopyBuffer(vkStream, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}

static void validate_vkCmdCopyImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageCopy* pRegions)
{
}

void goldfish_frontend_vkCmdCopyImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageCopy* pRegions)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdCopyImage(&validateResult, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdCopyImage(vkStream, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}

static void validate_vkCmdBlitImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageBlit* pRegions,
    VkFilter filter)
{
}

void goldfish_frontend_vkCmdBlitImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageBlit* pRegions,
    VkFilter filter)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBlitImage(&validateResult, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBlitImage(vkStream, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}

static void validate_vkCmdCopyBufferToImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
}

void goldfish_frontend_vkCmdCopyBufferToImage(
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdCopyBufferToImage(&validateResult, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdCopyBufferToImage(vkStream, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}

static void validate_vkCmdCopyImageToBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
}

void goldfish_frontend_vkCmdCopyImageToBuffer(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdCopyImageToBuffer(&validateResult, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdCopyImageToBuffer(vkStream, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}

static void validate_vkCmdUpdateBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize dataSize,
    const void* pData)
{
}

void goldfish_frontend_vkCmdUpdateBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize dataSize,
    const void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdUpdateBuffer(&validateResult, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdUpdateBuffer(vkStream, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}

static void validate_vkCmdFillBuffer(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize size,
    uint32_t data)
{
}

void goldfish_frontend_vkCmdFillBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize size,
    uint32_t data)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdFillBuffer(&validateResult, commandBuffer, dstBuffer, dstOffset, size, data);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdFillBuffer(vkStream, commandBuffer, dstBuffer, dstOffset, size, data);
}

static void validate_vkCmdClearColorImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearColorValue* pColor,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
}

void goldfish_frontend_vkCmdClearColorImage(
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearColorValue* pColor,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdClearColorImage(&validateResult, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdClearColorImage(vkStream, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}

static void validate_vkCmdClearDepthStencilImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearDepthStencilValue* pDepthStencil,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
}

void goldfish_frontend_vkCmdClearDepthStencilImage(
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearDepthStencilValue* pDepthStencil,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdClearDepthStencilImage(&validateResult, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdClearDepthStencilImage(vkStream, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}

static void validate_vkCmdClearAttachments(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t attachmentCount,
    const VkClearAttachment* pAttachments,
    uint32_t rectCount,
    const VkClearRect* pRects)
{
}

void goldfish_frontend_vkCmdClearAttachments(
    VkCommandBuffer commandBuffer,
    uint32_t attachmentCount,
    const VkClearAttachment* pAttachments,
    uint32_t rectCount,
    const VkClearRect* pRects)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdClearAttachments(&validateResult, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdClearAttachments(vkStream, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}

static void validate_vkCmdResolveImage(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageResolve* pRegions)
{
}

void goldfish_frontend_vkCmdResolveImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageResolve* pRegions)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdResolveImage(&validateResult, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdResolveImage(vkStream, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}

static void validate_vkCmdSetEvent(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
}

void goldfish_frontend_vkCmdSetEvent(
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetEvent(&validateResult, commandBuffer, event, stageMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetEvent(vkStream, commandBuffer, event, stageMask);
}

static void validate_vkCmdResetEvent(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
}

void goldfish_frontend_vkCmdResetEvent(
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdResetEvent(&validateResult, commandBuffer, event, stageMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdResetEvent(vkStream, commandBuffer, event, stageMask);
}

static void validate_vkCmdWaitEvents(
    VkResult* validateResult,
    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)
{
}

void goldfish_frontend_vkCmdWaitEvents(
    VkCommandBuffer commandBuffer,
    uint32_t eventCount,
    const VkEvent* pEvents,
    VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask,
    uint32_t memoryBarrierCount,
    const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdWaitEvents(&validateResult, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdWaitEvents(vkStream, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}

static void validate_vkCmdPipelineBarrier(
    VkResult* validateResult,
    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)
{
}

void goldfish_frontend_vkCmdPipelineBarrier(
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask,
    VkDependencyFlags dependencyFlags,
    uint32_t memoryBarrierCount,
    const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdPipelineBarrier(&validateResult, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdPipelineBarrier(vkStream, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}

static void validate_vkCmdBeginQuery(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query,
    VkQueryControlFlags flags)
{
}

void goldfish_frontend_vkCmdBeginQuery(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query,
    VkQueryControlFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBeginQuery(&validateResult, commandBuffer, queryPool, query, flags);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBeginQuery(vkStream, commandBuffer, queryPool, query, flags);
}

static void validate_vkCmdEndQuery(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query)
{
}

void goldfish_frontend_vkCmdEndQuery(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdEndQuery(&validateResult, commandBuffer, queryPool, query);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdEndQuery(vkStream, commandBuffer, queryPool, query);
}

static void validate_vkCmdResetQueryPool(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount)
{
}

void goldfish_frontend_vkCmdResetQueryPool(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdResetQueryPool(&validateResult, commandBuffer, queryPool, firstQuery, queryCount);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdResetQueryPool(vkStream, commandBuffer, queryPool, firstQuery, queryCount);
}

static void validate_vkCmdWriteTimestamp(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkQueryPool queryPool,
    uint32_t query)
{
}

void goldfish_frontend_vkCmdWriteTimestamp(
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkQueryPool queryPool,
    uint32_t query)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdWriteTimestamp(&validateResult, commandBuffer, pipelineStage, queryPool, query);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdWriteTimestamp(vkStream, commandBuffer, pipelineStage, queryPool, query);
}

static void validate_vkCmdCopyQueryPoolResults(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
}

void goldfish_frontend_vkCmdCopyQueryPoolResults(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdCopyQueryPoolResults(&validateResult, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdCopyQueryPoolResults(vkStream, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}

static void validate_vkCmdPushConstants(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineLayout layout,
    VkShaderStageFlags stageFlags,
    uint32_t offset,
    uint32_t size,
    const void* pValues)
{
}

void goldfish_frontend_vkCmdPushConstants(
    VkCommandBuffer commandBuffer,
    VkPipelineLayout layout,
    VkShaderStageFlags stageFlags,
    uint32_t offset,
    uint32_t size,
    const void* pValues)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdPushConstants(&validateResult, commandBuffer, layout, stageFlags, offset, size, pValues);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdPushConstants(vkStream, commandBuffer, layout, stageFlags, offset, size, pValues);
}

static void validate_vkCmdBeginRenderPass(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    VkSubpassContents contents)
{
}

void goldfish_frontend_vkCmdBeginRenderPass(
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    VkSubpassContents contents)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBeginRenderPass(&validateResult, commandBuffer, pRenderPassBegin, contents);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBeginRenderPass(vkStream, commandBuffer, pRenderPassBegin, contents);
}

static void validate_vkCmdNextSubpass(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkSubpassContents contents)
{
}

void goldfish_frontend_vkCmdNextSubpass(
    VkCommandBuffer commandBuffer,
    VkSubpassContents contents)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdNextSubpass(&validateResult, commandBuffer, contents);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdNextSubpass(vkStream, commandBuffer, contents);
}

static void validate_vkCmdEndRenderPass(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer)
{
}

void goldfish_frontend_vkCmdEndRenderPass(
    VkCommandBuffer commandBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdEndRenderPass(&validateResult, commandBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdEndRenderPass(vkStream, commandBuffer);
}

static void validate_vkCmdExecuteCommands(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
}

void goldfish_frontend_vkCmdExecuteCommands(
    VkCommandBuffer commandBuffer,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdExecuteCommands(&validateResult, commandBuffer, commandBufferCount, pCommandBuffers);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdExecuteCommands(vkStream, commandBuffer, commandBufferCount, pCommandBuffers);
}

#endif
#ifdef VK_VERSION_1_1
static void validate_vkEnumerateInstanceVersion(
    VkResult* validateResult,
    uint32_t* pApiVersion)
{
}

VkResult goldfish_frontend_vkEnumerateInstanceVersion(
    uint32_t* pApiVersion)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumerateInstanceVersion(&validateResult, pApiVersion);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumerateInstanceVersion(vkStream, pApiVersion);
    return res;
}

static void validate_vkBindBufferMemory2(
    VkResult* validateResult,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
}

VkResult goldfish_frontend_vkBindBufferMemory2(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindBufferMemory2(&validateResult, device, bindInfoCount, pBindInfos);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindBufferMemory2(vkStream, device, bindInfoCount, pBindInfos);
    return res;
}

static void validate_vkBindImageMemory2(
    VkResult* validateResult,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
}

VkResult goldfish_frontend_vkBindImageMemory2(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindImageMemory2(&validateResult, device, bindInfoCount, pBindInfos);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindImageMemory2(vkStream, device, bindInfoCount, pBindInfos);
    return res;
}

static void validate_vkGetDeviceGroupPeerMemoryFeatures(
    VkResult* validateResult,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
}

void goldfish_frontend_vkGetDeviceGroupPeerMemoryFeatures(
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceGroupPeerMemoryFeatures(&validateResult, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDeviceGroupPeerMemoryFeatures(vkStream, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}

static void validate_vkCmdSetDeviceMask(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
}

void goldfish_frontend_vkCmdSetDeviceMask(
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetDeviceMask(&validateResult, commandBuffer, deviceMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetDeviceMask(vkStream, commandBuffer, deviceMask);
}

static void validate_vkCmdDispatchBase(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
}

void goldfish_frontend_vkCmdDispatchBase(
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDispatchBase(&validateResult, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDispatchBase(vkStream, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}

static void validate_vkEnumeratePhysicalDeviceGroups(
    VkResult* validateResult,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
}

VkResult goldfish_frontend_vkEnumeratePhysicalDeviceGroups(
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumeratePhysicalDeviceGroups(&validateResult, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumeratePhysicalDeviceGroups(vkStream, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
    return res;
}

static void validate_vkGetImageMemoryRequirements2(
    VkResult* validateResult,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageMemoryRequirements2(
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageMemoryRequirements2(&validateResult, device, pInfo, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageMemoryRequirements2(vkStream, device, pInfo, pMemoryRequirements);
}

static void validate_vkGetBufferMemoryRequirements2(
    VkResult* validateResult,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetBufferMemoryRequirements2(
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetBufferMemoryRequirements2(&validateResult, device, pInfo, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetBufferMemoryRequirements2(vkStream, device, pInfo, pMemoryRequirements);
}

static void validate_vkGetImageSparseMemoryRequirements2(
    VkResult* validateResult,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageSparseMemoryRequirements2(
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageSparseMemoryRequirements2(&validateResult, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageSparseMemoryRequirements2(vkStream, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}

static void validate_vkGetPhysicalDeviceFeatures2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFeatures2(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFeatures2(&validateResult, physicalDevice, pFeatures);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFeatures2(vkStream, physicalDevice, pFeatures);
}

static void validate_vkGetPhysicalDeviceProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceProperties2(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceProperties2(&validateResult, physicalDevice, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceProperties2(vkStream, physicalDevice, pProperties);
}

static void validate_vkGetPhysicalDeviceFormatProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFormatProperties2(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFormatProperties2(&validateResult, physicalDevice, format, pFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFormatProperties2(vkStream, physicalDevice, format, pFormatProperties);
}

static void validate_vkGetPhysicalDeviceImageFormatProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceImageFormatProperties2(&validateResult, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceImageFormatProperties2(vkStream, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    return res;
}

static void validate_vkGetPhysicalDeviceQueueFamilyProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceQueueFamilyProperties2(
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceQueueFamilyProperties2(&validateResult, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceQueueFamilyProperties2(vkStream, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}

static void validate_vkGetPhysicalDeviceMemoryProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceMemoryProperties2(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceMemoryProperties2(&validateResult, physicalDevice, pMemoryProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceMemoryProperties2(vkStream, physicalDevice, pMemoryProperties);
}

static void validate_vkGetPhysicalDeviceSparseImageFormatProperties2(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceSparseImageFormatProperties2(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSparseImageFormatProperties2(&validateResult, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceSparseImageFormatProperties2(vkStream, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}

static void validate_vkTrimCommandPool(
    VkResult* validateResult,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
}

void goldfish_frontend_vkTrimCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkTrimCommandPool(&validateResult, device, commandPool, flags);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkTrimCommandPool(vkStream, device, commandPool, flags);
}

static void validate_vkGetDeviceQueue2(
    VkResult* validateResult,
    VkDevice device,
    const VkDeviceQueueInfo2* pQueueInfo,
    VkQueue* pQueue)
{
}

void goldfish_frontend_vkGetDeviceQueue2(
    VkDevice device,
    const VkDeviceQueueInfo2* pQueueInfo,
    VkQueue* pQueue)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceQueue2(&validateResult, device, pQueueInfo, pQueue);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDeviceQueue2(vkStream, device, pQueueInfo, pQueue);
}

static void validate_vkCreateSamplerYcbcrConversion(
    VkResult* validateResult,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
}

VkResult goldfish_frontend_vkCreateSamplerYcbcrConversion(
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSamplerYcbcrConversion(&validateResult, device, pCreateInfo, pAllocator, pYcbcrConversion);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSamplerYcbcrConversion(vkStream, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return res;
}

static void validate_vkDestroySamplerYcbcrConversion(
    VkResult* validateResult,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySamplerYcbcrConversion(
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySamplerYcbcrConversion(&validateResult, device, ycbcrConversion, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySamplerYcbcrConversion(vkStream, device, ycbcrConversion, pAllocator);
}

static void validate_vkCreateDescriptorUpdateTemplate(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
}

VkResult goldfish_frontend_vkCreateDescriptorUpdateTemplate(
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDescriptorUpdateTemplate(&validateResult, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDescriptorUpdateTemplate(vkStream, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    return res;
}

static void validate_vkDestroyDescriptorUpdateTemplate(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDescriptorUpdateTemplate(
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDescriptorUpdateTemplate(&validateResult, device, descriptorUpdateTemplate, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDescriptorUpdateTemplate(vkStream, device, descriptorUpdateTemplate, pAllocator);
}

static void validate_vkUpdateDescriptorSetWithTemplate(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
}

void goldfish_frontend_vkUpdateDescriptorSetWithTemplate(
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkUpdateDescriptorSetWithTemplate(&validateResult, device, descriptorSet, descriptorUpdateTemplate, pData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkUpdateDescriptorSetWithTemplate(vkStream, device, descriptorSet, descriptorUpdateTemplate, pData);
}

static void validate_vkGetPhysicalDeviceExternalBufferProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalBufferProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalBufferProperties(&validateResult, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalBufferProperties(vkStream, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}

static void validate_vkGetPhysicalDeviceExternalFenceProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalFenceProperties(&validateResult, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalFenceProperties(vkStream, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}

static void validate_vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalSemaphoreProperties(&validateResult, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalSemaphoreProperties(vkStream, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}

static void validate_vkGetDescriptorSetLayoutSupport(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
}

void goldfish_frontend_vkGetDescriptorSetLayoutSupport(
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDescriptorSetLayoutSupport(&validateResult, device, pCreateInfo, pSupport);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDescriptorSetLayoutSupport(vkStream, device, pCreateInfo, pSupport);
}

#endif
#ifdef VK_KHR_surface
static void validate_vkDestroySurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    VkSurfaceKHR surface,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySurfaceKHR(
    VkInstance instance,
    VkSurfaceKHR surface,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySurfaceKHR(&validateResult, instance, surface, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySurfaceKHR(vkStream, instance, surface, pAllocator);
}

static void validate_vkGetPhysicalDeviceSurfaceSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    VkSurfaceKHR surface,
    VkBool32* pSupported)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    VkSurfaceKHR surface,
    VkBool32* pSupported)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceSupportKHR(&validateResult, physicalDevice, queueFamilyIndex, surface, pSupported);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceSupportKHR(vkStream, physicalDevice, queueFamilyIndex, surface, pSupported);
    return res;
}

static void validate_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(&validateResult, physicalDevice, surface, pSurfaceCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vkStream, physicalDevice, surface, pSurfaceCapabilities);
    return res;
}

static void validate_vkGetPhysicalDeviceSurfaceFormatsKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormatKHR* pSurfaceFormats)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceFormatsKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormatKHR* pSurfaceFormats)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceFormatsKHR(&validateResult, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceFormatsKHR(vkStream, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
    return res;
}

static void validate_vkGetPhysicalDeviceSurfacePresentModesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pPresentModeCount,
    VkPresentModeKHR* pPresentModes)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfacePresentModesKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pPresentModeCount,
    VkPresentModeKHR* pPresentModes)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfacePresentModesKHR(&validateResult, physicalDevice, surface, pPresentModeCount, pPresentModes);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfacePresentModesKHR(vkStream, physicalDevice, surface, pPresentModeCount, pPresentModes);
    return res;
}

#endif
#ifdef VK_KHR_swapchain
static void validate_vkCreateSwapchainKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkSwapchainCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchain)
{
}

VkResult goldfish_frontend_vkCreateSwapchainKHR(
    VkDevice device,
    const VkSwapchainCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchain)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSwapchainKHR(&validateResult, device, pCreateInfo, pAllocator, pSwapchain);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSwapchainKHR(vkStream, device, pCreateInfo, pAllocator, pSwapchain);
    return res;
}

static void validate_vkDestroySwapchainKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySwapchainKHR(
    VkDevice device,
    VkSwapchainKHR swapchain,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySwapchainKHR(&validateResult, device, swapchain, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySwapchainKHR(vkStream, device, swapchain, pAllocator);
}

static void validate_vkGetSwapchainImagesKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pSwapchainImageCount,
    VkImage* pSwapchainImages)
{
}

VkResult goldfish_frontend_vkGetSwapchainImagesKHR(
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pSwapchainImageCount,
    VkImage* pSwapchainImages)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetSwapchainImagesKHR(&validateResult, device, swapchain, pSwapchainImageCount, pSwapchainImages);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetSwapchainImagesKHR(vkStream, device, swapchain, pSwapchainImageCount, pSwapchainImages);
    return res;
}

static void validate_vkAcquireNextImageKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint64_t timeout,
    VkSemaphore semaphore,
    VkFence fence,
    uint32_t* pImageIndex)
{
}

VkResult goldfish_frontend_vkAcquireNextImageKHR(
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint64_t timeout,
    VkSemaphore semaphore,
    VkFence fence,
    uint32_t* pImageIndex)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAcquireNextImageKHR(&validateResult, device, swapchain, timeout, semaphore, fence, pImageIndex);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAcquireNextImageKHR(vkStream, device, swapchain, timeout, semaphore, fence, pImageIndex);
    return res;
}

static void validate_vkQueuePresentKHR(
    VkResult* validateResult,
    VkQueue queue,
    const VkPresentInfoKHR* pPresentInfo)
{
}

VkResult goldfish_frontend_vkQueuePresentKHR(
    VkQueue queue,
    const VkPresentInfoKHR* pPresentInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueuePresentKHR(&validateResult, queue, pPresentInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkQueuePresentKHR(vkStream, queue, pPresentInfo);
    return res;
}

static void validate_vkGetDeviceGroupPresentCapabilitiesKHR(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
}

VkResult goldfish_frontend_vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice device,
    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceGroupPresentCapabilitiesKHR(&validateResult, device, pDeviceGroupPresentCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDeviceGroupPresentCapabilitiesKHR(vkStream, device, pDeviceGroupPresentCapabilities);
    return res;
}

static void validate_vkGetDeviceGroupSurfacePresentModesKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSurfaceKHR surface,
    VkDeviceGroupPresentModeFlagsKHR* pModes)
{
}

VkResult goldfish_frontend_vkGetDeviceGroupSurfacePresentModesKHR(
    VkDevice device,
    VkSurfaceKHR surface,
    VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceGroupSurfacePresentModesKHR(&validateResult, device, surface, pModes);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDeviceGroupSurfacePresentModesKHR(vkStream, device, surface, pModes);
    return res;
}

static void validate_vkGetPhysicalDevicePresentRectanglesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pRectCount,
    VkRect2D* pRects)
{
}

VkResult goldfish_frontend_vkGetPhysicalDevicePresentRectanglesKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pRectCount,
    VkRect2D* pRects)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDevicePresentRectanglesKHR(&validateResult, physicalDevice, surface, pRectCount, pRects);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDevicePresentRectanglesKHR(vkStream, physicalDevice, surface, pRectCount, pRects);
    return res;
}

static void validate_vkAcquireNextImage2KHR(
    VkResult* validateResult,
    VkDevice device,
    const VkAcquireNextImageInfoKHR* pAcquireInfo,
    uint32_t* pImageIndex)
{
}

VkResult goldfish_frontend_vkAcquireNextImage2KHR(
    VkDevice device,
    const VkAcquireNextImageInfoKHR* pAcquireInfo,
    uint32_t* pImageIndex)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAcquireNextImage2KHR(&validateResult, device, pAcquireInfo, pImageIndex);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAcquireNextImage2KHR(vkStream, device, pAcquireInfo, pImageIndex);
    return res;
}

#endif
#ifdef VK_KHR_display
static void validate_vkGetPhysicalDeviceDisplayPropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPropertiesKHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceDisplayPropertiesKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPropertiesKHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceDisplayPropertiesKHR(&validateResult, physicalDevice, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceDisplayPropertiesKHR(vkStream, physicalDevice, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlanePropertiesKHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlanePropertiesKHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(&validateResult, physicalDevice, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(vkStream, physicalDevice, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetDisplayPlaneSupportedDisplaysKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t planeIndex,
    uint32_t* pDisplayCount,
    VkDisplayKHR* pDisplays)
{
}

VkResult goldfish_frontend_vkGetDisplayPlaneSupportedDisplaysKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t planeIndex,
    uint32_t* pDisplayCount,
    VkDisplayKHR* pDisplays)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDisplayPlaneSupportedDisplaysKHR(&validateResult, physicalDevice, planeIndex, pDisplayCount, pDisplays);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDisplayPlaneSupportedDisplaysKHR(vkStream, physicalDevice, planeIndex, pDisplayCount, pDisplays);
    return res;
}

static void validate_vkGetDisplayModePropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModePropertiesKHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetDisplayModePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModePropertiesKHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDisplayModePropertiesKHR(&validateResult, physicalDevice, display, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDisplayModePropertiesKHR(vkStream, physicalDevice, display, pPropertyCount, pProperties);
    return res;
}

static void validate_vkCreateDisplayModeKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    const VkDisplayModeCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDisplayModeKHR* pMode)
{
}

VkResult goldfish_frontend_vkCreateDisplayModeKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    const VkDisplayModeCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDisplayModeKHR* pMode)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDisplayModeKHR(&validateResult, physicalDevice, display, pCreateInfo, pAllocator, pMode);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDisplayModeKHR(vkStream, physicalDevice, display, pCreateInfo, pAllocator, pMode);
    return res;
}

static void validate_vkGetDisplayPlaneCapabilitiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDisplayModeKHR mode,
    uint32_t planeIndex,
    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
}

VkResult goldfish_frontend_vkGetDisplayPlaneCapabilitiesKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayModeKHR mode,
    uint32_t planeIndex,
    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDisplayPlaneCapabilitiesKHR(&validateResult, physicalDevice, mode, planeIndex, pCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDisplayPlaneCapabilitiesKHR(vkStream, physicalDevice, mode, planeIndex, pCapabilities);
    return res;
}

static void validate_vkCreateDisplayPlaneSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateDisplayPlaneSurfaceKHR(
    VkInstance instance,
    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDisplayPlaneSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDisplayPlaneSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

#endif
#ifdef VK_KHR_display_swapchain
static void validate_vkCreateSharedSwapchainsKHR(
    VkResult* validateResult,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainCreateInfoKHR* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchains)
{
}

VkResult goldfish_frontend_vkCreateSharedSwapchainsKHR(
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainCreateInfoKHR* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchains)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSharedSwapchainsKHR(&validateResult, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSharedSwapchainsKHR(vkStream, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
    return res;
}

#endif
#ifdef VK_KHR_xlib_surface
static void validate_vkCreateXlibSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateXlibSurfaceKHR(
    VkInstance instance,
    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateXlibSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateXlibSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

static void validate_vkGetPhysicalDeviceXlibPresentationSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    Display* dpy,
    VisualID visualID)
{
}

VkBool32 goldfish_frontend_vkGetPhysicalDeviceXlibPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    Display* dpy,
    VisualID visualID)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceXlibPresentationSupportKHR(&validateResult, physicalDevice, queueFamilyIndex, dpy, visualID);
    if (validateResult != VK_SUCCESS)
    {
        return (VkBool32)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkBool32 res = marshal_vkGetPhysicalDeviceXlibPresentationSupportKHR(vkStream, physicalDevice, queueFamilyIndex, dpy, visualID);
    return res;
}

#endif
#ifdef VK_KHR_xcb_surface
static void validate_vkCreateXcbSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateXcbSurfaceKHR(
    VkInstance instance,
    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateXcbSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateXcbSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

static void validate_vkGetPhysicalDeviceXcbPresentationSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    xcb_connection_t* connection,
    xcb_visualid_t visual_id)
{
}

VkBool32 goldfish_frontend_vkGetPhysicalDeviceXcbPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    xcb_connection_t* connection,
    xcb_visualid_t visual_id)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceXcbPresentationSupportKHR(&validateResult, physicalDevice, queueFamilyIndex, connection, visual_id);
    if (validateResult != VK_SUCCESS)
    {
        return (VkBool32)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkBool32 res = marshal_vkGetPhysicalDeviceXcbPresentationSupportKHR(vkStream, physicalDevice, queueFamilyIndex, connection, visual_id);
    return res;
}

#endif
#ifdef VK_KHR_wayland_surface
static void validate_vkCreateWaylandSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateWaylandSurfaceKHR(
    VkInstance instance,
    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateWaylandSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateWaylandSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

static void validate_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    wl_display* display)
{
}

VkBool32 goldfish_frontend_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    wl_display* display)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceWaylandPresentationSupportKHR(&validateResult, physicalDevice, queueFamilyIndex, display);
    if (validateResult != VK_SUCCESS)
    {
        return (VkBool32)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkBool32 res = marshal_vkGetPhysicalDeviceWaylandPresentationSupportKHR(vkStream, physicalDevice, queueFamilyIndex, display);
    return res;
}

#endif
#ifdef VK_KHR_mir_surface
static void validate_vkCreateMirSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateMirSurfaceKHR(
    VkInstance instance,
    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateMirSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateMirSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

static void validate_vkGetPhysicalDeviceMirPresentationSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    MirConnection* connection)
{
}

VkBool32 goldfish_frontend_vkGetPhysicalDeviceMirPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    MirConnection* connection)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceMirPresentationSupportKHR(&validateResult, physicalDevice, queueFamilyIndex, connection);
    if (validateResult != VK_SUCCESS)
    {
        return (VkBool32)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkBool32 res = marshal_vkGetPhysicalDeviceMirPresentationSupportKHR(vkStream, physicalDevice, queueFamilyIndex, connection);
    return res;
}

#endif
#ifdef VK_KHR_android_surface
static void validate_vkCreateAndroidSurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateAndroidSurfaceKHR(
    VkInstance instance,
    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateAndroidSurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateAndroidSurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

#endif
#ifdef VK_KHR_win32_surface
static void validate_vkCreateWin32SurfaceKHR(
    VkResult* validateResult,
    VkInstance instance,
    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateWin32SurfaceKHR(
    VkInstance instance,
    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateWin32SurfaceKHR(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateWin32SurfaceKHR(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

static void validate_vkGetPhysicalDeviceWin32PresentationSupportKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex)
{
}

VkBool32 goldfish_frontend_vkGetPhysicalDeviceWin32PresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceWin32PresentationSupportKHR(&validateResult, physicalDevice, queueFamilyIndex);
    if (validateResult != VK_SUCCESS)
    {
        return (VkBool32)0;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkBool32 res = marshal_vkGetPhysicalDeviceWin32PresentationSupportKHR(vkStream, physicalDevice, queueFamilyIndex);
    return res;
}

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
static void validate_vkGetPhysicalDeviceFeatures2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFeatures2KHR(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFeatures2KHR(&validateResult, physicalDevice, pFeatures);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFeatures2KHR(vkStream, physicalDevice, pFeatures);
}

static void validate_vkGetPhysicalDeviceProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceProperties2KHR(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceProperties2KHR(&validateResult, physicalDevice, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceProperties2KHR(vkStream, physicalDevice, pProperties);
}

static void validate_vkGetPhysicalDeviceFormatProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceFormatProperties2KHR(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceFormatProperties2KHR(&validateResult, physicalDevice, format, pFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceFormatProperties2KHR(vkStream, physicalDevice, format, pFormatProperties);
}

static void validate_vkGetPhysicalDeviceImageFormatProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceImageFormatProperties2KHR(&validateResult, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceImageFormatProperties2KHR(vkStream, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    return res;
}

static void validate_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceQueueFamilyProperties2KHR(&validateResult, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceQueueFamilyProperties2KHR(vkStream, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}

static void validate_vkGetPhysicalDeviceMemoryProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceMemoryProperties2KHR(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceMemoryProperties2KHR(&validateResult, physicalDevice, pMemoryProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceMemoryProperties2KHR(vkStream, physicalDevice, pMemoryProperties);
}

static void validate_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(&validateResult, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(vkStream, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}

#endif
#ifdef VK_KHR_device_group
static void validate_vkGetDeviceGroupPeerMemoryFeaturesKHR(
    VkResult* validateResult,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
}

void goldfish_frontend_vkGetDeviceGroupPeerMemoryFeaturesKHR(
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDeviceGroupPeerMemoryFeaturesKHR(&validateResult, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDeviceGroupPeerMemoryFeaturesKHR(vkStream, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}

static void validate_vkCmdSetDeviceMaskKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
}

void goldfish_frontend_vkCmdSetDeviceMaskKHR(
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetDeviceMaskKHR(&validateResult, commandBuffer, deviceMask);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetDeviceMaskKHR(vkStream, commandBuffer, deviceMask);
}

static void validate_vkCmdDispatchBaseKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
}

void goldfish_frontend_vkCmdDispatchBaseKHR(
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDispatchBaseKHR(&validateResult, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDispatchBaseKHR(vkStream, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}

#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
static void validate_vkTrimCommandPoolKHR(
    VkResult* validateResult,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
}

void goldfish_frontend_vkTrimCommandPoolKHR(
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkTrimCommandPoolKHR(&validateResult, device, commandPool, flags);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkTrimCommandPoolKHR(vkStream, device, commandPool, flags);
}

#endif
#ifdef VK_KHR_device_group_creation
static void validate_vkEnumeratePhysicalDeviceGroupsKHR(
    VkResult* validateResult,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
}

VkResult goldfish_frontend_vkEnumeratePhysicalDeviceGroupsKHR(
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkEnumeratePhysicalDeviceGroupsKHR(&validateResult, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkEnumeratePhysicalDeviceGroupsKHR(vkStream, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
    return res;
}

#endif
#ifdef VK_KHR_external_memory_capabilities
static void validate_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalBufferPropertiesKHR(&validateResult, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalBufferPropertiesKHR(vkStream, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}

#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
static void validate_vkGetMemoryWin32HandleKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
}

VkResult goldfish_frontend_vkGetMemoryWin32HandleKHR(
    VkDevice device,
    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryWin32HandleKHR(&validateResult, device, pGetWin32HandleInfo, pHandle);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryWin32HandleKHR(vkStream, device, pGetWin32HandleInfo, pHandle);
    return res;
}

static void validate_vkGetMemoryWin32HandlePropertiesKHR(
    VkResult* validateResult,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    HANDLE handle,
    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
}

VkResult goldfish_frontend_vkGetMemoryWin32HandlePropertiesKHR(
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    HANDLE handle,
    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryWin32HandlePropertiesKHR(&validateResult, device, handleType, handle, pMemoryWin32HandleProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryWin32HandlePropertiesKHR(vkStream, device, handleType, handle, pMemoryWin32HandleProperties);
    return res;
}

#endif
#ifdef VK_KHR_external_memory_fd
static void validate_vkGetMemoryFdKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkMemoryGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
}

VkResult goldfish_frontend_vkGetMemoryFdKHR(
    VkDevice device,
    const VkMemoryGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryFdKHR(&validateResult, device, pGetFdInfo, pFd);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryFdKHR(vkStream, device, pGetFdInfo, pFd);
    return res;
}

static void validate_vkGetMemoryFdPropertiesKHR(
    VkResult* validateResult,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    int fd,
    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
}

VkResult goldfish_frontend_vkGetMemoryFdPropertiesKHR(
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    int fd,
    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryFdPropertiesKHR(&validateResult, device, handleType, fd, pMemoryFdProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryFdPropertiesKHR(vkStream, device, handleType, fd, pMemoryFdProperties);
    return res;
}

#endif
#ifdef VK_KHR_win32_keyed_mutex
#endif
#ifdef VK_KHR_external_semaphore_capabilities
static void validate_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(&validateResult, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(vkStream, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}

#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
static void validate_vkImportSemaphoreWin32HandleKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
}

VkResult goldfish_frontend_vkImportSemaphoreWin32HandleKHR(
    VkDevice device,
    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkImportSemaphoreWin32HandleKHR(&validateResult, device, pImportSemaphoreWin32HandleInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkImportSemaphoreWin32HandleKHR(vkStream, device, pImportSemaphoreWin32HandleInfo);
    return res;
}

static void validate_vkGetSemaphoreWin32HandleKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
}

VkResult goldfish_frontend_vkGetSemaphoreWin32HandleKHR(
    VkDevice device,
    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetSemaphoreWin32HandleKHR(&validateResult, device, pGetWin32HandleInfo, pHandle);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetSemaphoreWin32HandleKHR(vkStream, device, pGetWin32HandleInfo, pHandle);
    return res;
}

#endif
#ifdef VK_KHR_external_semaphore_fd
static void validate_vkImportSemaphoreFdKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
}

VkResult goldfish_frontend_vkImportSemaphoreFdKHR(
    VkDevice device,
    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkImportSemaphoreFdKHR(&validateResult, device, pImportSemaphoreFdInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkImportSemaphoreFdKHR(vkStream, device, pImportSemaphoreFdInfo);
    return res;
}

static void validate_vkGetSemaphoreFdKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
}

VkResult goldfish_frontend_vkGetSemaphoreFdKHR(
    VkDevice device,
    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetSemaphoreFdKHR(&validateResult, device, pGetFdInfo, pFd);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetSemaphoreFdKHR(vkStream, device, pGetFdInfo, pFd);
    return res;
}

#endif
#ifdef VK_KHR_push_descriptor
static void validate_vkCmdPushDescriptorSetKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t set,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites)
{
}

void goldfish_frontend_vkCmdPushDescriptorSetKHR(
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t set,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdPushDescriptorSetKHR(&validateResult, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdPushDescriptorSetKHR(vkStream, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}

static void validate_vkCmdPushDescriptorSetWithTemplateKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    VkPipelineLayout layout,
    uint32_t set,
    const void* pData)
{
}

void goldfish_frontend_vkCmdPushDescriptorSetWithTemplateKHR(
    VkCommandBuffer commandBuffer,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    VkPipelineLayout layout,
    uint32_t set,
    const void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdPushDescriptorSetWithTemplateKHR(&validateResult, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdPushDescriptorSetWithTemplateKHR(vkStream, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}

#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
#endif
#ifdef VK_KHR_descriptor_update_template
static void validate_vkCreateDescriptorUpdateTemplateKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
}

VkResult goldfish_frontend_vkCreateDescriptorUpdateTemplateKHR(
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDescriptorUpdateTemplateKHR(&validateResult, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDescriptorUpdateTemplateKHR(vkStream, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    return res;
}

static void validate_vkDestroyDescriptorUpdateTemplateKHR(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDescriptorUpdateTemplateKHR(
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDescriptorUpdateTemplateKHR(&validateResult, device, descriptorUpdateTemplate, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDescriptorUpdateTemplateKHR(vkStream, device, descriptorUpdateTemplate, pAllocator);
}

static void validate_vkUpdateDescriptorSetWithTemplateKHR(
    VkResult* validateResult,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
}

void goldfish_frontend_vkUpdateDescriptorSetWithTemplateKHR(
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkUpdateDescriptorSetWithTemplateKHR(&validateResult, device, descriptorSet, descriptorUpdateTemplate, pData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkUpdateDescriptorSetWithTemplateKHR(vkStream, device, descriptorSet, descriptorUpdateTemplate, pData);
}

#endif
#ifdef VK_KHR_create_renderpass2
static void validate_vkCreateRenderPass2KHR(
    VkResult* validateResult,
    VkDevice device,
    const VkRenderPassCreateInfo2KHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
}

VkResult goldfish_frontend_vkCreateRenderPass2KHR(
    VkDevice device,
    const VkRenderPassCreateInfo2KHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateRenderPass2KHR(&validateResult, device, pCreateInfo, pAllocator, pRenderPass);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateRenderPass2KHR(vkStream, device, pCreateInfo, pAllocator, pRenderPass);
    return res;
}

static void validate_vkCmdBeginRenderPass2KHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
{
}

void goldfish_frontend_vkCmdBeginRenderPass2KHR(
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBeginRenderPass2KHR(&validateResult, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBeginRenderPass2KHR(vkStream, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}

static void validate_vkCmdNextSubpass2KHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
}

void goldfish_frontend_vkCmdNextSubpass2KHR(
    VkCommandBuffer commandBuffer,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdNextSubpass2KHR(&validateResult, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdNextSubpass2KHR(vkStream, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
}

static void validate_vkCmdEndRenderPass2KHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
}

void goldfish_frontend_vkCmdEndRenderPass2KHR(
    VkCommandBuffer commandBuffer,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdEndRenderPass2KHR(&validateResult, commandBuffer, pSubpassEndInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdEndRenderPass2KHR(vkStream, commandBuffer, pSubpassEndInfo);
}

#endif
#ifdef VK_KHR_shared_presentable_image
static void validate_vkGetSwapchainStatusKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain)
{
}

VkResult goldfish_frontend_vkGetSwapchainStatusKHR(
    VkDevice device,
    VkSwapchainKHR swapchain)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetSwapchainStatusKHR(&validateResult, device, swapchain);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetSwapchainStatusKHR(vkStream, device, swapchain);
    return res;
}

#endif
#ifdef VK_KHR_external_fence_capabilities
static void validate_vkGetPhysicalDeviceExternalFencePropertiesKHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceExternalFencePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalFencePropertiesKHR(&validateResult, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceExternalFencePropertiesKHR(vkStream, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}

#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
static void validate_vkImportFenceWin32HandleKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
}

VkResult goldfish_frontend_vkImportFenceWin32HandleKHR(
    VkDevice device,
    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkImportFenceWin32HandleKHR(&validateResult, device, pImportFenceWin32HandleInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkImportFenceWin32HandleKHR(vkStream, device, pImportFenceWin32HandleInfo);
    return res;
}

static void validate_vkGetFenceWin32HandleKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
}

VkResult goldfish_frontend_vkGetFenceWin32HandleKHR(
    VkDevice device,
    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetFenceWin32HandleKHR(&validateResult, device, pGetWin32HandleInfo, pHandle);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetFenceWin32HandleKHR(vkStream, device, pGetWin32HandleInfo, pHandle);
    return res;
}

#endif
#ifdef VK_KHR_external_fence_fd
static void validate_vkImportFenceFdKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
}

VkResult goldfish_frontend_vkImportFenceFdKHR(
    VkDevice device,
    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkImportFenceFdKHR(&validateResult, device, pImportFenceFdInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkImportFenceFdKHR(vkStream, device, pImportFenceFdInfo);
    return res;
}

static void validate_vkGetFenceFdKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkFenceGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
}

VkResult goldfish_frontend_vkGetFenceFdKHR(
    VkDevice device,
    const VkFenceGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetFenceFdKHR(&validateResult, device, pGetFdInfo, pFd);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetFenceFdKHR(vkStream, device, pGetFdInfo, pFd);
    return res;
}

#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
static void validate_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceCapabilities2KHR(&validateResult, physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceCapabilities2KHR(vkStream, physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
    return res;
}

static void validate_vkGetPhysicalDeviceSurfaceFormats2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormat2KHR* pSurfaceFormats)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceFormats2KHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormat2KHR* pSurfaceFormats)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceFormats2KHR(&validateResult, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceFormats2KHR(vkStream, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
    return res;
}

#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
static void validate_vkGetPhysicalDeviceDisplayProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayProperties2KHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceDisplayProperties2KHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayProperties2KHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceDisplayProperties2KHR(&validateResult, physicalDevice, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceDisplayProperties2KHR(vkStream, physicalDevice, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlaneProperties2KHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlaneProperties2KHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(&validateResult, physicalDevice, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(vkStream, physicalDevice, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetDisplayModeProperties2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModeProperties2KHR* pProperties)
{
}

VkResult goldfish_frontend_vkGetDisplayModeProperties2KHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModeProperties2KHR* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDisplayModeProperties2KHR(&validateResult, physicalDevice, display, pPropertyCount, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDisplayModeProperties2KHR(vkStream, physicalDevice, display, pPropertyCount, pProperties);
    return res;
}

static void validate_vkGetDisplayPlaneCapabilities2KHR(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
}

VkResult goldfish_frontend_vkGetDisplayPlaneCapabilities2KHR(
    VkPhysicalDevice physicalDevice,
    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDisplayPlaneCapabilities2KHR(&validateResult, physicalDevice, pDisplayPlaneInfo, pCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetDisplayPlaneCapabilities2KHR(vkStream, physicalDevice, pDisplayPlaneInfo, pCapabilities);
    return res;
}

#endif
#ifdef VK_KHR_dedicated_allocation
#endif
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
static void validate_vkGetImageMemoryRequirements2KHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageMemoryRequirements2KHR(
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageMemoryRequirements2KHR(&validateResult, device, pInfo, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageMemoryRequirements2KHR(vkStream, device, pInfo, pMemoryRequirements);
}

static void validate_vkGetBufferMemoryRequirements2KHR(
    VkResult* validateResult,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
}

void goldfish_frontend_vkGetBufferMemoryRequirements2KHR(
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetBufferMemoryRequirements2KHR(&validateResult, device, pInfo, pMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetBufferMemoryRequirements2KHR(vkStream, device, pInfo, pMemoryRequirements);
}

static void validate_vkGetImageSparseMemoryRequirements2KHR(
    VkResult* validateResult,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
}

void goldfish_frontend_vkGetImageSparseMemoryRequirements2KHR(
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetImageSparseMemoryRequirements2KHR(&validateResult, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetImageSparseMemoryRequirements2KHR(vkStream, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}

#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
static void validate_vkCreateSamplerYcbcrConversionKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
}

VkResult goldfish_frontend_vkCreateSamplerYcbcrConversionKHR(
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateSamplerYcbcrConversionKHR(&validateResult, device, pCreateInfo, pAllocator, pYcbcrConversion);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateSamplerYcbcrConversionKHR(vkStream, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return res;
}

static void validate_vkDestroySamplerYcbcrConversionKHR(
    VkResult* validateResult,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroySamplerYcbcrConversionKHR(
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroySamplerYcbcrConversionKHR(&validateResult, device, ycbcrConversion, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroySamplerYcbcrConversionKHR(vkStream, device, ycbcrConversion, pAllocator);
}

#endif
#ifdef VK_KHR_bind_memory2
static void validate_vkBindBufferMemory2KHR(
    VkResult* validateResult,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
}

VkResult goldfish_frontend_vkBindBufferMemory2KHR(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindBufferMemory2KHR(&validateResult, device, bindInfoCount, pBindInfos);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindBufferMemory2KHR(vkStream, device, bindInfoCount, pBindInfos);
    return res;
}

static void validate_vkBindImageMemory2KHR(
    VkResult* validateResult,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
}

VkResult goldfish_frontend_vkBindImageMemory2KHR(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkBindImageMemory2KHR(&validateResult, device, bindInfoCount, pBindInfos);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkBindImageMemory2KHR(vkStream, device, bindInfoCount, pBindInfos);
    return res;
}

#endif
#ifdef VK_KHR_maintenance3
static void validate_vkGetDescriptorSetLayoutSupportKHR(
    VkResult* validateResult,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
}

void goldfish_frontend_vkGetDescriptorSetLayoutSupportKHR(
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetDescriptorSetLayoutSupportKHR(&validateResult, device, pCreateInfo, pSupport);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetDescriptorSetLayoutSupportKHR(vkStream, device, pCreateInfo, pSupport);
}

#endif
#ifdef VK_KHR_draw_indirect_count
static void validate_vkCmdDrawIndirectCountKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndirectCountKHR(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndirectCountKHR(&validateResult, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndirectCountKHR(vkStream, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}

static void validate_vkCmdDrawIndexedIndirectCountKHR(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndexedIndirectCountKHR(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndexedIndirectCountKHR(&validateResult, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndexedIndirectCountKHR(vkStream, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}

#endif
#ifdef VK_KHR_8bit_storage
#endif
#ifdef VK_EXT_debug_report
static void validate_vkCreateDebugReportCallbackEXT(
    VkResult* validateResult,
    VkInstance instance,
    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugReportCallbackEXT* pCallback)
{
}

VkResult goldfish_frontend_vkCreateDebugReportCallbackEXT(
    VkInstance instance,
    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugReportCallbackEXT* pCallback)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDebugReportCallbackEXT(&validateResult, instance, pCreateInfo, pAllocator, pCallback);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDebugReportCallbackEXT(vkStream, instance, pCreateInfo, pAllocator, pCallback);
    return res;
}

static void validate_vkDestroyDebugReportCallbackEXT(
    VkResult* validateResult,
    VkInstance instance,
    VkDebugReportCallbackEXT callback,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDebugReportCallbackEXT(
    VkInstance instance,
    VkDebugReportCallbackEXT callback,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDebugReportCallbackEXT(&validateResult, instance, callback, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDebugReportCallbackEXT(vkStream, instance, callback, pAllocator);
}

static void validate_vkDebugReportMessageEXT(
    VkResult* validateResult,
    VkInstance instance,
    VkDebugReportFlagsEXT flags,
    VkDebugReportObjectTypeEXT objectType,
    uint64_t object,
    size_t location,
    int32_t messageCode,
    const char* pLayerPrefix,
    const char* pMessage)
{
}

void goldfish_frontend_vkDebugReportMessageEXT(
    VkInstance instance,
    VkDebugReportFlagsEXT flags,
    VkDebugReportObjectTypeEXT objectType,
    uint64_t object,
    size_t location,
    int32_t messageCode,
    const char* pLayerPrefix,
    const char* pMessage)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDebugReportMessageEXT(&validateResult, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDebugReportMessageEXT(vkStream, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
}

#endif
#ifdef VK_NV_glsl_shader
#endif
#ifdef VK_EXT_depth_range_unrestricted
#endif
#ifdef VK_IMG_filter_cubic
#endif
#ifdef VK_AMD_rasterization_order
#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
static void validate_vkDebugMarkerSetObjectTagEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
}

VkResult goldfish_frontend_vkDebugMarkerSetObjectTagEXT(
    VkDevice device,
    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDebugMarkerSetObjectTagEXT(&validateResult, device, pTagInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkDebugMarkerSetObjectTagEXT(vkStream, device, pTagInfo);
    return res;
}

static void validate_vkDebugMarkerSetObjectNameEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
}

VkResult goldfish_frontend_vkDebugMarkerSetObjectNameEXT(
    VkDevice device,
    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDebugMarkerSetObjectNameEXT(&validateResult, device, pNameInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkDebugMarkerSetObjectNameEXT(vkStream, device, pNameInfo);
    return res;
}

static void validate_vkCmdDebugMarkerBeginEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
}

void goldfish_frontend_vkCmdDebugMarkerBeginEXT(
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDebugMarkerBeginEXT(&validateResult, commandBuffer, pMarkerInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDebugMarkerBeginEXT(vkStream, commandBuffer, pMarkerInfo);
}

static void validate_vkCmdDebugMarkerEndEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer)
{
}

void goldfish_frontend_vkCmdDebugMarkerEndEXT(
    VkCommandBuffer commandBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDebugMarkerEndEXT(&validateResult, commandBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDebugMarkerEndEXT(vkStream, commandBuffer);
}

static void validate_vkCmdDebugMarkerInsertEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
}

void goldfish_frontend_vkCmdDebugMarkerInsertEXT(
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDebugMarkerInsertEXT(&validateResult, commandBuffer, pMarkerInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDebugMarkerInsertEXT(vkStream, commandBuffer, pMarkerInfo);
}

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
#endif
#ifdef VK_AMD_draw_indirect_count
static void validate_vkCmdDrawIndirectCountAMD(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndirectCountAMD(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndirectCountAMD(&validateResult, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndirectCountAMD(vkStream, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}

static void validate_vkCmdDrawIndexedIndirectCountAMD(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
}

void goldfish_frontend_vkCmdDrawIndexedIndirectCountAMD(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdDrawIndexedIndirectCountAMD(&validateResult, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdDrawIndexedIndirectCountAMD(vkStream, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}

#endif
#ifdef VK_AMD_negative_viewport_height
#endif
#ifdef VK_AMD_gpu_shader_half_float
#endif
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
static void validate_vkGetShaderInfoAMD(
    VkResult* validateResult,
    VkDevice device,
    VkPipeline pipeline,
    VkShaderStageFlagBits shaderStage,
    VkShaderInfoTypeAMD infoType,
    size_t* pInfoSize,
    void* pInfo)
{
}

VkResult goldfish_frontend_vkGetShaderInfoAMD(
    VkDevice device,
    VkPipeline pipeline,
    VkShaderStageFlagBits shaderStage,
    VkShaderInfoTypeAMD infoType,
    size_t* pInfoSize,
    void* pInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetShaderInfoAMD(&validateResult, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetShaderInfoAMD(vkStream, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
    return res;
}

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
static void validate_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(&validateResult, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(vkStream, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
    return res;
}

#endif
#ifdef VK_NV_external_memory
#endif
#ifdef VK_NV_external_memory_win32
static void validate_vkGetMemoryWin32HandleNV(
    VkResult* validateResult,
    VkDevice device,
    VkDeviceMemory memory,
    VkExternalMemoryHandleTypeFlagsNV handleType,
    HANDLE* pHandle)
{
}

VkResult goldfish_frontend_vkGetMemoryWin32HandleNV(
    VkDevice device,
    VkDeviceMemory memory,
    VkExternalMemoryHandleTypeFlagsNV handleType,
    HANDLE* pHandle)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryWin32HandleNV(&validateResult, device, memory, handleType, pHandle);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryWin32HandleNV(vkStream, device, memory, handleType, pHandle);
    return res;
}

#endif
#ifdef VK_NV_win32_keyed_mutex
#endif
#ifdef VK_EXT_validation_flags
#endif
#ifdef VK_NN_vi_surface
static void validate_vkCreateViSurfaceNN(
    VkResult* validateResult,
    VkInstance instance,
    const VkViSurfaceCreateInfoNN* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateViSurfaceNN(
    VkInstance instance,
    const VkViSurfaceCreateInfoNN* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateViSurfaceNN(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateViSurfaceNN(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_conditional_rendering
static void validate_vkCmdBeginConditionalRenderingEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
}

void goldfish_frontend_vkCmdBeginConditionalRenderingEXT(
    VkCommandBuffer commandBuffer,
    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBeginConditionalRenderingEXT(&validateResult, commandBuffer, pConditionalRenderingBegin);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBeginConditionalRenderingEXT(vkStream, commandBuffer, pConditionalRenderingBegin);
}

static void validate_vkCmdEndConditionalRenderingEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer)
{
}

void goldfish_frontend_vkCmdEndConditionalRenderingEXT(
    VkCommandBuffer commandBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdEndConditionalRenderingEXT(&validateResult, commandBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdEndConditionalRenderingEXT(vkStream, commandBuffer);
}

#endif
#ifdef VK_NVX_device_generated_commands
static void validate_vkCmdProcessCommandsNVX(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
}

void goldfish_frontend_vkCmdProcessCommandsNVX(
    VkCommandBuffer commandBuffer,
    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdProcessCommandsNVX(&validateResult, commandBuffer, pProcessCommandsInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdProcessCommandsNVX(vkStream, commandBuffer, pProcessCommandsInfo);
}

static void validate_vkCmdReserveSpaceForCommandsNVX(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
{
}

void goldfish_frontend_vkCmdReserveSpaceForCommandsNVX(
    VkCommandBuffer commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdReserveSpaceForCommandsNVX(&validateResult, commandBuffer, pReserveSpaceInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdReserveSpaceForCommandsNVX(vkStream, commandBuffer, pReserveSpaceInfo);
}

static void validate_vkCreateIndirectCommandsLayoutNVX(
    VkResult* validateResult,
    VkDevice device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
{
}

VkResult goldfish_frontend_vkCreateIndirectCommandsLayoutNVX(
    VkDevice device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateIndirectCommandsLayoutNVX(&validateResult, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateIndirectCommandsLayoutNVX(vkStream, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
    return res;
}

static void validate_vkDestroyIndirectCommandsLayoutNVX(
    VkResult* validateResult,
    VkDevice device,
    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyIndirectCommandsLayoutNVX(
    VkDevice device,
    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyIndirectCommandsLayoutNVX(&validateResult, device, indirectCommandsLayout, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyIndirectCommandsLayoutNVX(vkStream, device, indirectCommandsLayout, pAllocator);
}

static void validate_vkCreateObjectTableNVX(
    VkResult* validateResult,
    VkDevice device,
    const VkObjectTableCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkObjectTableNVX* pObjectTable)
{
}

VkResult goldfish_frontend_vkCreateObjectTableNVX(
    VkDevice device,
    const VkObjectTableCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkObjectTableNVX* pObjectTable)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateObjectTableNVX(&validateResult, device, pCreateInfo, pAllocator, pObjectTable);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateObjectTableNVX(vkStream, device, pCreateInfo, pAllocator, pObjectTable);
    return res;
}

static void validate_vkDestroyObjectTableNVX(
    VkResult* validateResult,
    VkDevice device,
    VkObjectTableNVX objectTable,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyObjectTableNVX(
    VkDevice device,
    VkObjectTableNVX objectTable,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyObjectTableNVX(&validateResult, device, objectTable, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyObjectTableNVX(vkStream, device, objectTable, pAllocator);
}

static void validate_vkRegisterObjectsNVX(
    VkResult* validateResult,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
    const uint32_t* pObjectIndices)
{
}

VkResult goldfish_frontend_vkRegisterObjectsNVX(
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
    const uint32_t* pObjectIndices)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkRegisterObjectsNVX(&validateResult, device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkRegisterObjectsNVX(vkStream, device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
    return res;
}

static void validate_vkUnregisterObjectsNVX(
    VkResult* validateResult,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectEntryTypeNVX* pObjectEntryTypes,
    const uint32_t* pObjectIndices)
{
}

VkResult goldfish_frontend_vkUnregisterObjectsNVX(
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectEntryTypeNVX* pObjectEntryTypes,
    const uint32_t* pObjectIndices)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkUnregisterObjectsNVX(&validateResult, device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkUnregisterObjectsNVX(vkStream, device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
    return res;
}

static void validate_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
{
}

void goldfish_frontend_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    VkPhysicalDevice physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(&validateResult, physicalDevice, pFeatures, pLimits);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(vkStream, physicalDevice, pFeatures, pLimits);
}

#endif
#ifdef VK_NV_clip_space_w_scaling
static void validate_vkCmdSetViewportWScalingNV(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewportWScalingNV* pViewportWScalings)
{
}

void goldfish_frontend_vkCmdSetViewportWScalingNV(
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewportWScalingNV* pViewportWScalings)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetViewportWScalingNV(&validateResult, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetViewportWScalingNV(vkStream, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}

#endif
#ifdef VK_EXT_direct_mode_display
static void validate_vkReleaseDisplayEXT(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display)
{
}

VkResult goldfish_frontend_vkReleaseDisplayEXT(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkReleaseDisplayEXT(&validateResult, physicalDevice, display);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkReleaseDisplayEXT(vkStream, physicalDevice, display);
    return res;
}

#endif
#ifdef VK_EXT_acquire_xlib_display
static void validate_vkAcquireXlibDisplayEXT(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    VkDisplayKHR display)
{
}

VkResult goldfish_frontend_vkAcquireXlibDisplayEXT(
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    VkDisplayKHR display)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkAcquireXlibDisplayEXT(&validateResult, physicalDevice, dpy, display);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkAcquireXlibDisplayEXT(vkStream, physicalDevice, dpy, display);
    return res;
}

static void validate_vkGetRandROutputDisplayEXT(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    RROutput rrOutput,
    VkDisplayKHR* pDisplay)
{
}

VkResult goldfish_frontend_vkGetRandROutputDisplayEXT(
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    RROutput rrOutput,
    VkDisplayKHR* pDisplay)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetRandROutputDisplayEXT(&validateResult, physicalDevice, dpy, rrOutput, pDisplay);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetRandROutputDisplayEXT(vkStream, physicalDevice, dpy, rrOutput, pDisplay);
    return res;
}

#endif
#ifdef VK_EXT_display_surface_counter
static void validate_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
}

VkResult goldfish_frontend_vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceSurfaceCapabilities2EXT(&validateResult, physicalDevice, surface, pSurfaceCapabilities);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPhysicalDeviceSurfaceCapabilities2EXT(vkStream, physicalDevice, surface, pSurfaceCapabilities);
    return res;
}

#endif
#ifdef VK_EXT_display_control
static void validate_vkDisplayPowerControlEXT(
    VkResult* validateResult,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
}

VkResult goldfish_frontend_vkDisplayPowerControlEXT(
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDisplayPowerControlEXT(&validateResult, device, display, pDisplayPowerInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkDisplayPowerControlEXT(vkStream, device, display, pDisplayPowerInfo);
    return res;
}

static void validate_vkRegisterDeviceEventEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkDeviceEventInfoEXT* pDeviceEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
}

VkResult goldfish_frontend_vkRegisterDeviceEventEXT(
    VkDevice device,
    const VkDeviceEventInfoEXT* pDeviceEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkRegisterDeviceEventEXT(&validateResult, device, pDeviceEventInfo, pAllocator, pFence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkRegisterDeviceEventEXT(vkStream, device, pDeviceEventInfo, pAllocator, pFence);
    return res;
}

static void validate_vkRegisterDisplayEventEXT(
    VkResult* validateResult,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayEventInfoEXT* pDisplayEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
}

VkResult goldfish_frontend_vkRegisterDisplayEventEXT(
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayEventInfoEXT* pDisplayEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkRegisterDisplayEventEXT(&validateResult, device, display, pDisplayEventInfo, pAllocator, pFence);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkRegisterDisplayEventEXT(vkStream, device, display, pDisplayEventInfo, pAllocator, pFence);
    return res;
}

static void validate_vkGetSwapchainCounterEXT(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkSurfaceCounterFlagBitsEXT counter,
    uint64_t* pCounterValue)
{
}

VkResult goldfish_frontend_vkGetSwapchainCounterEXT(
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkSurfaceCounterFlagBitsEXT counter,
    uint64_t* pCounterValue)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetSwapchainCounterEXT(&validateResult, device, swapchain, counter, pCounterValue);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetSwapchainCounterEXT(vkStream, device, swapchain, counter, pCounterValue);
    return res;
}

#endif
#ifdef VK_GOOGLE_display_timing
static void validate_vkGetRefreshCycleDurationGOOGLE(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
}

VkResult goldfish_frontend_vkGetRefreshCycleDurationGOOGLE(
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetRefreshCycleDurationGOOGLE(&validateResult, device, swapchain, pDisplayTimingProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetRefreshCycleDurationGOOGLE(vkStream, device, swapchain, pDisplayTimingProperties);
    return res;
}

static void validate_vkGetPastPresentationTimingGOOGLE(
    VkResult* validateResult,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
}

VkResult goldfish_frontend_vkGetPastPresentationTimingGOOGLE(
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPastPresentationTimingGOOGLE(&validateResult, device, swapchain, pPresentationTimingCount, pPresentationTimings);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetPastPresentationTimingGOOGLE(vkStream, device, swapchain, pPresentationTimingCount, pPresentationTimings);
    return res;
}

#endif
#ifdef VK_NV_sample_mask_override_coverage
#endif
#ifdef VK_NV_geometry_shader_passthrough
#endif
#ifdef VK_NV_viewport_array2
#endif
#ifdef VK_NVX_multiview_per_view_attributes
#endif
#ifdef VK_NV_viewport_swizzle
#endif
#ifdef VK_EXT_discard_rectangles
static void validate_vkCmdSetDiscardRectangleEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    uint32_t firstDiscardRectangle,
    uint32_t discardRectangleCount,
    const VkRect2D* pDiscardRectangles)
{
}

void goldfish_frontend_vkCmdSetDiscardRectangleEXT(
    VkCommandBuffer commandBuffer,
    uint32_t firstDiscardRectangle,
    uint32_t discardRectangleCount,
    const VkRect2D* pDiscardRectangles)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetDiscardRectangleEXT(&validateResult, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetDiscardRectangleEXT(vkStream, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
}

#endif
#ifdef VK_EXT_conservative_rasterization
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
static void validate_vkSetHdrMetadataEXT(
    VkResult* validateResult,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainKHR* pSwapchains,
    const VkHdrMetadataEXT* pMetadata)
{
}

void goldfish_frontend_vkSetHdrMetadataEXT(
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainKHR* pSwapchains,
    const VkHdrMetadataEXT* pMetadata)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkSetHdrMetadataEXT(&validateResult, device, swapchainCount, pSwapchains, pMetadata);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkSetHdrMetadataEXT(vkStream, device, swapchainCount, pSwapchains, pMetadata);
}

#endif
#ifdef VK_MVK_ios_surface
static void validate_vkCreateIOSSurfaceMVK(
    VkResult* validateResult,
    VkInstance instance,
    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateIOSSurfaceMVK(
    VkInstance instance,
    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateIOSSurfaceMVK(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateIOSSurfaceMVK(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

#endif
#ifdef VK_MVK_macos_surface
static void validate_vkCreateMacOSSurfaceMVK(
    VkResult* validateResult,
    VkInstance instance,
    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
}

VkResult goldfish_frontend_vkCreateMacOSSurfaceMVK(
    VkInstance instance,
    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateMacOSSurfaceMVK(&validateResult, instance, pCreateInfo, pAllocator, pSurface);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateMacOSSurfaceMVK(vkStream, instance, pCreateInfo, pAllocator, pSurface);
    return res;
}

#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
static void validate_vkSetDebugUtilsObjectNameEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
}

VkResult goldfish_frontend_vkSetDebugUtilsObjectNameEXT(
    VkDevice device,
    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkSetDebugUtilsObjectNameEXT(&validateResult, device, pNameInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkSetDebugUtilsObjectNameEXT(vkStream, device, pNameInfo);
    return res;
}

static void validate_vkSetDebugUtilsObjectTagEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
}

VkResult goldfish_frontend_vkSetDebugUtilsObjectTagEXT(
    VkDevice device,
    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkSetDebugUtilsObjectTagEXT(&validateResult, device, pTagInfo);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkSetDebugUtilsObjectTagEXT(vkStream, device, pTagInfo);
    return res;
}

static void validate_vkQueueBeginDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
}

void goldfish_frontend_vkQueueBeginDebugUtilsLabelEXT(
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueBeginDebugUtilsLabelEXT(&validateResult, queue, pLabelInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkQueueBeginDebugUtilsLabelEXT(vkStream, queue, pLabelInfo);
}

static void validate_vkQueueEndDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkQueue queue)
{
}

void goldfish_frontend_vkQueueEndDebugUtilsLabelEXT(
    VkQueue queue)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueEndDebugUtilsLabelEXT(&validateResult, queue);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkQueueEndDebugUtilsLabelEXT(vkStream, queue);
}

static void validate_vkQueueInsertDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
}

void goldfish_frontend_vkQueueInsertDebugUtilsLabelEXT(
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkQueueInsertDebugUtilsLabelEXT(&validateResult, queue, pLabelInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkQueueInsertDebugUtilsLabelEXT(vkStream, queue, pLabelInfo);
}

static void validate_vkCmdBeginDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
}

void goldfish_frontend_vkCmdBeginDebugUtilsLabelEXT(
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdBeginDebugUtilsLabelEXT(&validateResult, commandBuffer, pLabelInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdBeginDebugUtilsLabelEXT(vkStream, commandBuffer, pLabelInfo);
}

static void validate_vkCmdEndDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer)
{
}

void goldfish_frontend_vkCmdEndDebugUtilsLabelEXT(
    VkCommandBuffer commandBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdEndDebugUtilsLabelEXT(&validateResult, commandBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdEndDebugUtilsLabelEXT(vkStream, commandBuffer);
}

static void validate_vkCmdInsertDebugUtilsLabelEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
}

void goldfish_frontend_vkCmdInsertDebugUtilsLabelEXT(
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdInsertDebugUtilsLabelEXT(&validateResult, commandBuffer, pLabelInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdInsertDebugUtilsLabelEXT(vkStream, commandBuffer, pLabelInfo);
}

static void validate_vkCreateDebugUtilsMessengerEXT(
    VkResult* validateResult,
    VkInstance instance,
    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugUtilsMessengerEXT* pMessenger)
{
}

VkResult goldfish_frontend_vkCreateDebugUtilsMessengerEXT(
    VkInstance instance,
    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugUtilsMessengerEXT* pMessenger)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateDebugUtilsMessengerEXT(&validateResult, instance, pCreateInfo, pAllocator, pMessenger);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateDebugUtilsMessengerEXT(vkStream, instance, pCreateInfo, pAllocator, pMessenger);
    return res;
}

static void validate_vkDestroyDebugUtilsMessengerEXT(
    VkResult* validateResult,
    VkInstance instance,
    VkDebugUtilsMessengerEXT messenger,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyDebugUtilsMessengerEXT(
    VkInstance instance,
    VkDebugUtilsMessengerEXT messenger,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyDebugUtilsMessengerEXT(&validateResult, instance, messenger, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyDebugUtilsMessengerEXT(vkStream, instance, messenger, pAllocator);
}

static void validate_vkSubmitDebugUtilsMessageEXT(
    VkResult* validateResult,
    VkInstance instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
}

void goldfish_frontend_vkSubmitDebugUtilsMessageEXT(
    VkInstance instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkSubmitDebugUtilsMessageEXT(&validateResult, instance, messageSeverity, messageTypes, pCallbackData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkSubmitDebugUtilsMessageEXT(vkStream, instance, messageSeverity, messageTypes, pCallbackData);
}

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
static void validate_vkGetAndroidHardwareBufferPropertiesANDROID(
    VkResult* validateResult,
    VkDevice device,
    const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
}

VkResult goldfish_frontend_vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice device,
    const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetAndroidHardwareBufferPropertiesANDROID(&validateResult, device, buffer, pProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetAndroidHardwareBufferPropertiesANDROID(vkStream, device, buffer, pProperties);
    return res;
}

static void validate_vkGetMemoryAndroidHardwareBufferANDROID(
    VkResult* validateResult,
    VkDevice device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer)
{
}

VkResult goldfish_frontend_vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryAndroidHardwareBufferANDROID(&validateResult, device, pInfo, pBuffer);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryAndroidHardwareBufferANDROID(vkStream, device, pInfo, pBuffer);
    return res;
}

#endif
#ifdef VK_EXT_sampler_filter_minmax
#endif
#ifdef VK_AMD_gpu_shader_int16
#endif
#ifdef VK_AMD_mixed_attachment_samples
#endif
#ifdef VK_AMD_shader_fragment_mask
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
static void validate_vkCmdSetSampleLocationsEXT(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
}

void goldfish_frontend_vkCmdSetSampleLocationsEXT(
    VkCommandBuffer commandBuffer,
    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetSampleLocationsEXT(&validateResult, commandBuffer, pSampleLocationsInfo);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetSampleLocationsEXT(vkStream, commandBuffer, pSampleLocationsInfo);
}

static void validate_vkGetPhysicalDeviceMultisamplePropertiesEXT(
    VkResult* validateResult,
    VkPhysicalDevice physicalDevice,
    VkSampleCountFlagBits samples,
    VkMultisamplePropertiesEXT* pMultisampleProperties)
{
}

void goldfish_frontend_vkGetPhysicalDeviceMultisamplePropertiesEXT(
    VkPhysicalDevice physicalDevice,
    VkSampleCountFlagBits samples,
    VkMultisamplePropertiesEXT* pMultisampleProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetPhysicalDeviceMultisamplePropertiesEXT(&validateResult, physicalDevice, samples, pMultisampleProperties);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetPhysicalDeviceMultisamplePropertiesEXT(vkStream, physicalDevice, samples, pMultisampleProperties);
}

#endif
#ifdef VK_EXT_blend_operation_advanced
#endif
#ifdef VK_NV_fragment_coverage_to_color
#endif
#ifdef VK_NV_framebuffer_mixed_samples
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_validation_cache
static void validate_vkCreateValidationCacheEXT(
    VkResult* validateResult,
    VkDevice device,
    const VkValidationCacheCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkValidationCacheEXT* pValidationCache)
{
}

VkResult goldfish_frontend_vkCreateValidationCacheEXT(
    VkDevice device,
    const VkValidationCacheCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkValidationCacheEXT* pValidationCache)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCreateValidationCacheEXT(&validateResult, device, pCreateInfo, pAllocator, pValidationCache);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkCreateValidationCacheEXT(vkStream, device, pCreateInfo, pAllocator, pValidationCache);
    return res;
}

static void validate_vkDestroyValidationCacheEXT(
    VkResult* validateResult,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    const VkAllocationCallbacks* pAllocator)
{
}

void goldfish_frontend_vkDestroyValidationCacheEXT(
    VkDevice device,
    VkValidationCacheEXT validationCache,
    const VkAllocationCallbacks* pAllocator)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkDestroyValidationCacheEXT(&validateResult, device, validationCache, pAllocator);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkDestroyValidationCacheEXT(vkStream, device, validationCache, pAllocator);
}

static void validate_vkMergeValidationCachesEXT(
    VkResult* validateResult,
    VkDevice device,
    VkValidationCacheEXT dstCache,
    uint32_t srcCacheCount,
    const VkValidationCacheEXT* pSrcCaches)
{
}

VkResult goldfish_frontend_vkMergeValidationCachesEXT(
    VkDevice device,
    VkValidationCacheEXT dstCache,
    uint32_t srcCacheCount,
    const VkValidationCacheEXT* pSrcCaches)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkMergeValidationCachesEXT(&validateResult, device, dstCache, srcCacheCount, pSrcCaches);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkMergeValidationCachesEXT(vkStream, device, dstCache, srcCacheCount, pSrcCaches);
    return res;
}

static void validate_vkGetValidationCacheDataEXT(
    VkResult* validateResult,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    size_t* pDataSize,
    void* pData)
{
}

VkResult goldfish_frontend_vkGetValidationCacheDataEXT(
    VkDevice device,
    VkValidationCacheEXT validationCache,
    size_t* pDataSize,
    void* pData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetValidationCacheDataEXT(&validateResult, device, validationCache, pDataSize, pData);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetValidationCacheDataEXT(vkStream, device, validationCache, pDataSize, pData);
    return res;
}

#endif
#ifdef VK_EXT_descriptor_indexing
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_EXT_global_priority
#endif
#ifdef VK_EXT_external_memory_host
static void validate_vkGetMemoryHostPointerPropertiesEXT(
    VkResult* validateResult,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    const void* pHostPointer,
    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
}

VkResult goldfish_frontend_vkGetMemoryHostPointerPropertiesEXT(
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    const void* pHostPointer,
    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetMemoryHostPointerPropertiesEXT(&validateResult, device, handleType, pHostPointer, pMemoryHostPointerProperties);
    if (validateResult != VK_SUCCESS)
    {
        return validateResult;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    VkResult res = marshal_vkGetMemoryHostPointerPropertiesEXT(vkStream, device, handleType, pHostPointer, pMemoryHostPointerProperties);
    return res;
}

#endif
#ifdef VK_AMD_buffer_marker
static void validate_vkCmdWriteBufferMarkerAMD(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    uint32_t marker)
{
}

void goldfish_frontend_vkCmdWriteBufferMarkerAMD(
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    uint32_t marker)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdWriteBufferMarkerAMD(&validateResult, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdWriteBufferMarkerAMD(vkStream, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
}

#endif
#ifdef VK_AMD_shader_core_properties
#endif
#ifdef VK_EXT_vertex_attribute_divisor
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
static void validate_vkCmdSetCheckpointNV(
    VkResult* validateResult,
    VkCommandBuffer commandBuffer,
    const void* pCheckpointMarker)
{
}

void goldfish_frontend_vkCmdSetCheckpointNV(
    VkCommandBuffer commandBuffer,
    const void* pCheckpointMarker)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkCmdSetCheckpointNV(&validateResult, commandBuffer, pCheckpointMarker);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkCmdSetCheckpointNV(vkStream, commandBuffer, pCheckpointMarker);
}

static void validate_vkGetQueueCheckpointDataNV(
    VkResult* validateResult,
    VkQueue queue,
    uint32_t* pCheckpointDataCount,
    VkCheckpointDataNV* pCheckpointData)
{
}

void goldfish_frontend_vkGetQueueCheckpointDataNV(
    VkQueue queue,
    uint32_t* pCheckpointDataCount,
    VkCheckpointDataNV* pCheckpointData)
{
    VkResult validateResult = VK_SUCCESS;
    validate_vkGetQueueCheckpointDataNV(&validateResult, queue, pCheckpointDataCount, pCheckpointData);
    if (validateResult != VK_SUCCESS)
    {
        return;
    }
    // VULKAN_STREAM_GET();
    VulkanStream* vkStream = nullptr;
    marshal_vkGetQueueCheckpointDataNV(vkStream, queue, pCheckpointDataCount, pCheckpointData);
}

#endif

} // namespace goldfish_vk