text: typedef struct ANativeWindow ANativeWindow;
  typedef uint32_t VkSampleMask;
  typedef uint32_t VkBool32;
  typedef uint32_t VkFlags;
  typedef uint64_t VkDeviceSize;
  typedef VkFlags VkFramebufferCreateFlags;
  typedef VkFlags VkQueryPoolCreateFlags;
  typedef VkFlags VkRenderPassCreateFlags;
  typedef VkFlags VkSamplerCreateFlags;
  typedef VkFlags VkPipelineLayoutCreateFlags;
  typedef VkFlags VkPipelineCacheCreateFlags;
  typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
  typedef VkFlags VkPipelineDynamicStateCreateFlags;
  typedef VkFlags VkPipelineColorBlendStateCreateFlags;
  typedef VkFlags VkPipelineMultisampleStateCreateFlags;
  typedef VkFlags VkPipelineRasterizationStateCreateFlags;
  typedef VkFlags VkPipelineViewportStateCreateFlags;
  typedef VkFlags VkPipelineTessellationStateCreateFlags;
  typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
  typedef VkFlags VkPipelineVertexInputStateCreateFlags;
  typedef VkFlags VkPipelineShaderStageCreateFlags;
  typedef VkFlags VkDescriptorSetLayoutCreateFlags;
  typedef VkFlags VkBufferViewCreateFlags;
  typedef VkFlags VkInstanceCreateFlags;
  typedef VkFlags VkDeviceCreateFlags;
  typedef VkFlags VkDeviceQueueCreateFlags;
  typedef VkFlags VkQueueFlags;
  typedef VkFlags VkMemoryPropertyFlags;
  typedef VkFlags VkMemoryHeapFlags;
  typedef VkFlags VkAccessFlags;
  typedef VkFlags VkBufferUsageFlags;
  typedef VkFlags VkBufferCreateFlags;
  typedef VkFlags VkShaderStageFlags;
  typedef VkFlags VkImageUsageFlags;
  typedef VkFlags VkImageCreateFlags;
  typedef VkFlags VkImageViewCreateFlags;
  typedef VkFlags VkPipelineCreateFlags;
  typedef VkFlags VkColorComponentFlags;
  typedef VkFlags VkFenceCreateFlags;
  typedef VkFlags VkSemaphoreCreateFlags;
  typedef VkFlags VkFormatFeatureFlags;
  typedef VkFlags VkQueryControlFlags;
  typedef VkFlags VkQueryResultFlags;
  typedef VkFlags VkShaderModuleCreateFlags;
  typedef VkFlags VkEventCreateFlags;
  typedef VkFlags VkCommandPoolCreateFlags;
  typedef VkFlags VkCommandPoolResetFlags;
  typedef VkFlags VkCommandBufferResetFlags;
  typedef VkFlags VkCommandBufferUsageFlags;
  typedef VkFlags VkQueryPipelineStatisticFlags;
  typedef VkFlags VkMemoryMapFlags;
  typedef VkFlags VkImageAspectFlags;
  typedef VkFlags VkSparseMemoryBindFlags;
  typedef VkFlags VkSparseImageFormatFlags;
  typedef VkFlags VkSubpassDescriptionFlags;
  typedef VkFlags VkPipelineStageFlags;
  typedef VkFlags VkSampleCountFlags;
  typedef VkFlags VkAttachmentDescriptionFlags;
  typedef VkFlags VkStencilFaceFlags;
  typedef VkFlags VkCullModeFlags;
  typedef VkFlags VkDescriptorPoolCreateFlags;
  typedef VkFlags VkDescriptorPoolResetFlags;
  typedef VkFlags VkDependencyFlags;
  typedef VkFlags VkCompositeAlphaFlagsKHR;
  typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
  typedef VkFlags VkSurfaceTransformFlagsKHR;
  typedef VkFlags VkSwapchainCreateFlagsKHR;
  typedef VkFlags VkDisplayModeCreateFlagsKHR;
  typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;
  typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;
  typedef VkFlags VkDebugReportFlagsEXT;
  typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;
  typedef VkFlags VkExternalMemoryFeatureFlagsNV;
  typedef struct VkInstance_T *VkInstance;
  typedef struct VkPhysicalDevice_T *VkPhysicalDevice;
  typedef struct VkDevice_T *VkDevice;
  typedef struct VkQueue_T *VkQueue;
  typedef struct VkCommandBuffer_T *VkCommandBuffer;
  typedef uint64_t VkDeviceMemory;
  typedef uint64_t VkCommandPool;
  typedef uint64_t VkBuffer;
  typedef uint64_t VkBufferView;
  typedef uint64_t VkImage;
  typedef uint64_t VkImageView;
  typedef uint64_t VkShaderModule;
  typedef uint64_t VkPipeline;
  typedef uint64_t VkPipelineLayout;
  typedef uint64_t VkSampler;
  typedef uint64_t VkDescriptorSet;
  typedef uint64_t VkDescriptorSetLayout;
  typedef uint64_t VkDescriptorPool;
  typedef uint64_t VkFence;
  typedef uint64_t VkSemaphore;
  typedef uint64_t VkEvent;
  typedef uint64_t VkQueryPool;
  typedef uint64_t VkFramebuffer;
  typedef uint64_t VkRenderPass;
  typedef uint64_t VkPipelineCache;
  typedef uint64_t VkDisplayKHR;
  typedef uint64_t VkDisplayModeKHR;
  typedef uint64_t VkSurfaceKHR;
  typedef uint64_t VkSwapchainKHR;
  typedef uint64_t VkDebugReportCallbackEXT;
  typedef enum VkAttachmentLoadOp{
  	VK_ATTACHMENT_LOAD_OP_LOAD = 0,
  	VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
  	VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2
  } VkAttachmentLoadOp;
  typedef enum VkAttachmentStoreOp{
  	VK_ATTACHMENT_STORE_OP_STORE = 0,
  	VK_ATTACHMENT_STORE_OP_DONT_CARE = 1
  } VkAttachmentStoreOp;
  typedef enum VkBlendFactor{
  	VK_BLEND_FACTOR_ZERO = 0,
  	VK_BLEND_FACTOR_ONE = 1,
  	VK_BLEND_FACTOR_SRC_COLOR = 2,
  	VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
  	VK_BLEND_FACTOR_DST_COLOR = 4,
  	VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
  	VK_BLEND_FACTOR_SRC_ALPHA = 6,
  	VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
  	VK_BLEND_FACTOR_DST_ALPHA = 8,
  	VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
  	VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
  	VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
  	VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
  	VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
  	VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
  	VK_BLEND_FACTOR_SRC1_COLOR = 15,
  	VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
  	VK_BLEND_FACTOR_SRC1_ALPHA = 17,
  	VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18
  } VkBlendFactor;
  typedef enum VkBlendOp{
  	VK_BLEND_OP_ADD = 0,
  	VK_BLEND_OP_SUBTRACT = 1,
  	VK_BLEND_OP_REVERSE_SUBTRACT = 2,
  	VK_BLEND_OP_MIN = 3,
  	VK_BLEND_OP_MAX = 4
  } VkBlendOp;
  typedef enum VkBorderColor{
  	VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
  	VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
  	VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
  	VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
  	VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
  	VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5
  } VkBorderColor;
  typedef enum VkPipelineCacheHeaderVersion{
  	VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1
  } VkPipelineCacheHeaderVersion;
  typedef enum VkBufferCreateFlagBits{
  	VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
  	VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
  	VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4
  } VkBufferCreateFlagBits;
  typedef enum VkBufferUsageFlagBits{
  	VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
  	VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
  	VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 4,
  	VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 8,
  	VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 16,
  	VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 32,
  	VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 64,
  	VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 128,
  	VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256
  } VkBufferUsageFlagBits;
  typedef enum VkColorComponentFlagBits{
  	VK_COLOR_COMPONENT_R_BIT = 1,
  	VK_COLOR_COMPONENT_G_BIT = 2,
  	VK_COLOR_COMPONENT_B_BIT = 4,
  	VK_COLOR_COMPONENT_A_BIT = 8
  } VkColorComponentFlagBits;
  typedef enum VkComponentSwizzle{
  	VK_COMPONENT_SWIZZLE_IDENTITY = 0,
  	VK_COMPONENT_SWIZZLE_ZERO = 1,
  	VK_COMPONENT_SWIZZLE_ONE = 2,
  	VK_COMPONENT_SWIZZLE_R = 3,
  	VK_COMPONENT_SWIZZLE_G = 4,
  	VK_COMPONENT_SWIZZLE_B = 5,
  	VK_COMPONENT_SWIZZLE_A = 6
  } VkComponentSwizzle;
  typedef enum VkCommandPoolCreateFlagBits{
  	VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
  	VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2
  } VkCommandPoolCreateFlagBits;
  typedef enum VkCommandPoolResetFlagBits{
  	VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1
  } VkCommandPoolResetFlagBits;
  typedef enum VkCommandBufferResetFlagBits{
  	VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1
  } VkCommandBufferResetFlagBits;
  typedef enum VkCommandBufferLevel{
  	VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
  	VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1
  } VkCommandBufferLevel;
  typedef enum VkCommandBufferUsageFlagBits{
  	VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
  	VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
  	VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4
  } VkCommandBufferUsageFlagBits;
  typedef enum VkCompareOp{
  	VK_COMPARE_OP_NEVER = 0,
  	VK_COMPARE_OP_LESS = 1,
  	VK_COMPARE_OP_EQUAL = 2,
  	VK_COMPARE_OP_LESS_OR_EQUAL = 3,
  	VK_COMPARE_OP_GREATER = 4,
  	VK_COMPARE_OP_NOT_EQUAL = 5,
  	VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
  	VK_COMPARE_OP_ALWAYS = 7
  } VkCompareOp;
  typedef enum VkCullModeFlagBits{
  	VK_CULL_MODE_NONE = 0,
  	VK_CULL_MODE_FRONT_BIT = 1,
  	VK_CULL_MODE_BACK_BIT = 2,
  	VK_CULL_MODE_FRONT_AND_BACK = 0x00000003
  } VkCullModeFlagBits;
  typedef enum VkDescriptorType{
  	VK_DESCRIPTOR_TYPE_SAMPLER = 0,
  	VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
  	VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
  	VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
  	VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
  	VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
  	VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
  	VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
  	VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
  	VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
  	VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10
  } VkDescriptorType;
  typedef enum VkDynamicState{
  	VK_DYNAMIC_STATE_VIEWPORT = 0,
  	VK_DYNAMIC_STATE_SCISSOR = 1,
  	VK_DYNAMIC_STATE_LINE_WIDTH = 2,
  	VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
  	VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
  	VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
  	VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
  	VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
  	VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8
  } VkDynamicState;
  typedef enum VkFenceCreateFlagBits{
  	VK_FENCE_CREATE_SIGNALED_BIT = 1
  } VkFenceCreateFlagBits;
  typedef enum VkPolygonMode{
  	VK_POLYGON_MODE_FILL = 0,
  	VK_POLYGON_MODE_LINE = 1,
  	VK_POLYGON_MODE_POINT = 2
  } VkPolygonMode;
  typedef enum VkFormat{
  	VK_FORMAT_UNDEFINED = 0,
  	VK_FORMAT_R4G4_UNORM_PACK8 = 1,
  	VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
  	VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
  	VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
  	VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
  	VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
  	VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
  	VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
  	VK_FORMAT_R8_UNORM = 9,
  	VK_FORMAT_R8_SNORM = 10,
  	VK_FORMAT_R8_USCALED = 11,
  	VK_FORMAT_R8_SSCALED = 12,
  	VK_FORMAT_R8_UINT = 13,
  	VK_FORMAT_R8_SINT = 14,
  	VK_FORMAT_R8_SRGB = 15,
  	VK_FORMAT_R8G8_UNORM = 16,
  	VK_FORMAT_R8G8_SNORM = 17,
  	VK_FORMAT_R8G8_USCALED = 18,
  	VK_FORMAT_R8G8_SSCALED = 19,
  	VK_FORMAT_R8G8_UINT = 20,
  	VK_FORMAT_R8G8_SINT = 21,
  	VK_FORMAT_R8G8_SRGB = 22,
  	VK_FORMAT_R8G8B8_UNORM = 23,
  	VK_FORMAT_R8G8B8_SNORM = 24,
  	VK_FORMAT_R8G8B8_USCALED = 25,
  	VK_FORMAT_R8G8B8_SSCALED = 26,
  	VK_FORMAT_R8G8B8_UINT = 27,
  	VK_FORMAT_R8G8B8_SINT = 28,
  	VK_FORMAT_R8G8B8_SRGB = 29,
  	VK_FORMAT_B8G8R8_UNORM = 30,
  	VK_FORMAT_B8G8R8_SNORM = 31,
  	VK_FORMAT_B8G8R8_USCALED = 32,
  	VK_FORMAT_B8G8R8_SSCALED = 33,
  	VK_FORMAT_B8G8R8_UINT = 34,
  	VK_FORMAT_B8G8R8_SINT = 35,
  	VK_FORMAT_B8G8R8_SRGB = 36,
  	VK_FORMAT_R8G8B8A8_UNORM = 37,
  	VK_FORMAT_R8G8B8A8_SNORM = 38,
  	VK_FORMAT_R8G8B8A8_USCALED = 39,
  	VK_FORMAT_R8G8B8A8_SSCALED = 40,
  	VK_FORMAT_R8G8B8A8_UINT = 41,
  	VK_FORMAT_R8G8B8A8_SINT = 42,
  	VK_FORMAT_R8G8B8A8_SRGB = 43,
  	VK_FORMAT_B8G8R8A8_UNORM = 44,
  	VK_FORMAT_B8G8R8A8_SNORM = 45,
  	VK_FORMAT_B8G8R8A8_USCALED = 46,
  	VK_FORMAT_B8G8R8A8_SSCALED = 47,
  	VK_FORMAT_B8G8R8A8_UINT = 48,
  	VK_FORMAT_B8G8R8A8_SINT = 49,
  	VK_FORMAT_B8G8R8A8_SRGB = 50,
  	VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
  	VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
  	VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
  	VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
  	VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
  	VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
  	VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
  	VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
  	VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
  	VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
  	VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
  	VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
  	VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
  	VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
  	VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
  	VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
  	VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
  	VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
  	VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
  	VK_FORMAT_R16_UNORM = 70,
  	VK_FORMAT_R16_SNORM = 71,
  	VK_FORMAT_R16_USCALED = 72,
  	VK_FORMAT_R16_SSCALED = 73,
  	VK_FORMAT_R16_UINT = 74,
  	VK_FORMAT_R16_SINT = 75,
  	VK_FORMAT_R16_SFLOAT = 76,
  	VK_FORMAT_R16G16_UNORM = 77,
  	VK_FORMAT_R16G16_SNORM = 78,
  	VK_FORMAT_R16G16_USCALED = 79,
  	VK_FORMAT_R16G16_SSCALED = 80,
  	VK_FORMAT_R16G16_UINT = 81,
  	VK_FORMAT_R16G16_SINT = 82,
  	VK_FORMAT_R16G16_SFLOAT = 83,
  	VK_FORMAT_R16G16B16_UNORM = 84,
  	VK_FORMAT_R16G16B16_SNORM = 85,
  	VK_FORMAT_R16G16B16_USCALED = 86,
  	VK_FORMAT_R16G16B16_SSCALED = 87,
  	VK_FORMAT_R16G16B16_UINT = 88,
  	VK_FORMAT_R16G16B16_SINT = 89,
  	VK_FORMAT_R16G16B16_SFLOAT = 90,
  	VK_FORMAT_R16G16B16A16_UNORM = 91,
  	VK_FORMAT_R16G16B16A16_SNORM = 92,
  	VK_FORMAT_R16G16B16A16_USCALED = 93,
  	VK_FORMAT_R16G16B16A16_SSCALED = 94,
  	VK_FORMAT_R16G16B16A16_UINT = 95,
  	VK_FORMAT_R16G16B16A16_SINT = 96,
  	VK_FORMAT_R16G16B16A16_SFLOAT = 97,
  	VK_FORMAT_R32_UINT = 98,
  	VK_FORMAT_R32_SINT = 99,
  	VK_FORMAT_R32_SFLOAT = 100,
  	VK_FORMAT_R32G32_UINT = 101,
  	VK_FORMAT_R32G32_SINT = 102,
  	VK_FORMAT_R32G32_SFLOAT = 103,
  	VK_FORMAT_R32G32B32_UINT = 104,
  	VK_FORMAT_R32G32B32_SINT = 105,
  	VK_FORMAT_R32G32B32_SFLOAT = 106,
  	VK_FORMAT_R32G32B32A32_UINT = 107,
  	VK_FORMAT_R32G32B32A32_SINT = 108,
  	VK_FORMAT_R32G32B32A32_SFLOAT = 109,
  	VK_FORMAT_R64_UINT = 110,
  	VK_FORMAT_R64_SINT = 111,
  	VK_FORMAT_R64_SFLOAT = 112,
  	VK_FORMAT_R64G64_UINT = 113,
  	VK_FORMAT_R64G64_SINT = 114,
  	VK_FORMAT_R64G64_SFLOAT = 115,
  	VK_FORMAT_R64G64B64_UINT = 116,
  	VK_FORMAT_R64G64B64_SINT = 117,
  	VK_FORMAT_R64G64B64_SFLOAT = 118,
  	VK_FORMAT_R64G64B64A64_UINT = 119,
  	VK_FORMAT_R64G64B64A64_SINT = 120,
  	VK_FORMAT_R64G64B64A64_SFLOAT = 121,
  	VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
  	VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
  	VK_FORMAT_D16_UNORM = 124,
  	VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
  	VK_FORMAT_D32_SFLOAT = 126,
  	VK_FORMAT_S8_UINT = 127,
  	VK_FORMAT_D16_UNORM_S8_UINT = 128,
  	VK_FORMAT_D24_UNORM_S8_UINT = 129,
  	VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
  	VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
  	VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
  	VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
  	VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
  	VK_FORMAT_BC2_UNORM_BLOCK = 135,
  	VK_FORMAT_BC2_SRGB_BLOCK = 136,
  	VK_FORMAT_BC3_UNORM_BLOCK = 137,
  	VK_FORMAT_BC3_SRGB_BLOCK = 138,
  	VK_FORMAT_BC4_UNORM_BLOCK = 139,
  	VK_FORMAT_BC4_SNORM_BLOCK = 140,
  	VK_FORMAT_BC5_UNORM_BLOCK = 141,
  	VK_FORMAT_BC5_SNORM_BLOCK = 142,
  	VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
  	VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
  	VK_FORMAT_BC7_UNORM_BLOCK = 145,
  	VK_FORMAT_BC7_SRGB_BLOCK = 146,
  	VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
  	VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
  	VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
  	VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
  	VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
  	VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
  	VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
  	VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
  	VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
  	VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
  	VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
  	VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
  	VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
  	VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
  	VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
  	VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
  	VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
  	VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
  	VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
  	VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
  	VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
  	VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
  	VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
  	VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
  	VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
  	VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
  	VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
  	VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
  	VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
  	VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
  	VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
  	VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
  	VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
  	VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
  	VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
  	VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
  	VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
  	VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
  	VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,
  	VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,
  	VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,
  	VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,
  	VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,
  	VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,
  	VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,
  	VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007
  } VkFormat;
  typedef enum VkFormatFeatureFlagBits{
  	VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
  	VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
  	VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 4,
  	VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 8,
  	VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 16,
  	VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 32,
  	VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 64,
  	VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 128,
  	VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 256,
  	VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 512,
  	VK_FORMAT_FEATURE_BLIT_SRC_BIT = 1024,
  	VK_FORMAT_FEATURE_BLIT_DST_BIT = 2048,
  	VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096,
  	VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 8192
  } VkFormatFeatureFlagBits;
  typedef enum VkFrontFace{
  	VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
  	VK_FRONT_FACE_CLOCKWISE = 1
  } VkFrontFace;
  typedef enum VkImageAspectFlagBits{
  	VK_IMAGE_ASPECT_COLOR_BIT = 1,
  	VK_IMAGE_ASPECT_DEPTH_BIT = 2,
  	VK_IMAGE_ASPECT_STENCIL_BIT = 4,
  	VK_IMAGE_ASPECT_METADATA_BIT = 8
  } VkImageAspectFlagBits;
  typedef enum VkImageCreateFlagBits{
  	VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
  	VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
  	VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 4,
  	VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 8,
  	VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16
  } VkImageCreateFlagBits;
  typedef enum VkImageLayout{
  	VK_IMAGE_LAYOUT_UNDEFINED = 0,
  	VK_IMAGE_LAYOUT_GENERAL = 1,
  	VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
  	VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
  	VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
  	VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
  	VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
  	VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
  	VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
  	VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002
  } VkImageLayout;
  typedef enum VkImageTiling{
  	VK_IMAGE_TILING_OPTIMAL = 0,
  	VK_IMAGE_TILING_LINEAR = 1
  } VkImageTiling;
  typedef enum VkImageType{
  	VK_IMAGE_TYPE_1D = 0,
  	VK_IMAGE_TYPE_2D = 1,
  	VK_IMAGE_TYPE_3D = 2
  } VkImageType;
  typedef enum VkImageUsageFlagBits{
  	VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
  	VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
  	VK_IMAGE_USAGE_SAMPLED_BIT = 4,
  	VK_IMAGE_USAGE_STORAGE_BIT = 8,
  	VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 16,
  	VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 32,
  	VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 64,
  	VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128
  } VkImageUsageFlagBits;
  typedef enum VkImageViewType{
  	VK_IMAGE_VIEW_TYPE_1D = 0,
  	VK_IMAGE_VIEW_TYPE_2D = 1,
  	VK_IMAGE_VIEW_TYPE_3D = 2,
  	VK_IMAGE_VIEW_TYPE_CUBE = 3,
  	VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
  	VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
  	VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6
  } VkImageViewType;
  typedef enum VkSharingMode{
  	VK_SHARING_MODE_EXCLUSIVE = 0,
  	VK_SHARING_MODE_CONCURRENT = 1
  } VkSharingMode;
  typedef enum VkIndexType{
  	VK_INDEX_TYPE_UINT16 = 0,
  	VK_INDEX_TYPE_UINT32 = 1
  } VkIndexType;
  typedef enum VkLogicOp{
  	VK_LOGIC_OP_CLEAR = 0,
  	VK_LOGIC_OP_AND = 1,
  	VK_LOGIC_OP_AND_REVERSE = 2,
  	VK_LOGIC_OP_COPY = 3,
  	VK_LOGIC_OP_AND_INVERTED = 4,
  	VK_LOGIC_OP_NO_OP = 5,
  	VK_LOGIC_OP_XOR = 6,
  	VK_LOGIC_OP_OR = 7,
  	VK_LOGIC_OP_NOR = 8,
  	VK_LOGIC_OP_EQUIVALENT = 9,
  	VK_LOGIC_OP_INVERT = 10,
  	VK_LOGIC_OP_OR_REVERSE = 11,
  	VK_LOGIC_OP_COPY_INVERTED = 12,
  	VK_LOGIC_OP_OR_INVERTED = 13,
  	VK_LOGIC_OP_NAND = 14,
  	VK_LOGIC_OP_SET = 15
  } VkLogicOp;
  typedef enum VkMemoryHeapFlagBits{
  	VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1
  } VkMemoryHeapFlagBits;
  typedef enum VkAccessFlagBits{
  	VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
  	VK_ACCESS_INDEX_READ_BIT = 2,
  	VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 4,
  	VK_ACCESS_UNIFORM_READ_BIT = 8,
  	VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 16,
  	VK_ACCESS_SHADER_READ_BIT = 32,
  	VK_ACCESS_SHADER_WRITE_BIT = 64,
  	VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 128,
  	VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 256,
  	VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 512,
  	VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 1024,
  	VK_ACCESS_TRANSFER_READ_BIT = 2048,
  	VK_ACCESS_TRANSFER_WRITE_BIT = 4096,
  	VK_ACCESS_HOST_READ_BIT = 8192,
  	VK_ACCESS_HOST_WRITE_BIT = 16384,
  	VK_ACCESS_MEMORY_READ_BIT = 32768,
  	VK_ACCESS_MEMORY_WRITE_BIT = 65536
  } VkAccessFlagBits;
  typedef enum VkMemoryPropertyFlagBits{
  	VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
  	VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
  	VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 4,
  	VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 8,
  	VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16
  } VkMemoryPropertyFlagBits;
  typedef enum VkPhysicalDeviceType{
  	VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
  	VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
  	VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
  	VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
  	VK_PHYSICAL_DEVICE_TYPE_CPU = 4
  } VkPhysicalDeviceType;
  typedef enum VkPipelineBindPoint{
  	VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
  	VK_PIPELINE_BIND_POINT_COMPUTE = 1
  } VkPipelineBindPoint;
  typedef enum VkPipelineCreateFlagBits{
  	VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
  	VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
  	VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4
  } VkPipelineCreateFlagBits;
  typedef enum VkPrimitiveTopology{
  	VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
  	VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
  	VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
  	VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
  	VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
  	VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
  	VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
  	VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
  	VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
  	VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
  	VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10
  } VkPrimitiveTopology;
  typedef enum VkQueryControlFlagBits{
  	VK_QUERY_CONTROL_PRECISE_BIT = 1
  } VkQueryControlFlagBits;
  typedef enum VkQueryPipelineStatisticFlagBits{
  	VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
  	VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
  	VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 4,
  	VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 8,
  	VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 16,
  	VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 32,
  	VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 64,
  	VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 128,
  	VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 256,
  	VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 512,
  	VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024
  } VkQueryPipelineStatisticFlagBits;
  typedef enum VkQueryResultFlagBits{
  	VK_QUERY_RESULT_64_BIT = 1,
  	VK_QUERY_RESULT_WAIT_BIT = 2,
  	VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 4,
  	VK_QUERY_RESULT_PARTIAL_BIT = 8
  } VkQueryResultFlagBits;
  typedef enum VkQueryType{
  	VK_QUERY_TYPE_OCCLUSION = 0,
  	VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
  	VK_QUERY_TYPE_TIMESTAMP = 2
  } VkQueryType;
  typedef enum VkQueueFlagBits{
  	VK_QUEUE_GRAPHICS_BIT = 1,
  	VK_QUEUE_COMPUTE_BIT = 2,
  	VK_QUEUE_TRANSFER_BIT = 4,
  	VK_QUEUE_SPARSE_BINDING_BIT = 8
  } VkQueueFlagBits;
  typedef enum VkSubpassContents{
  	VK_SUBPASS_CONTENTS_INLINE = 0,
  	VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1
  } VkSubpassContents;
  typedef enum VkResult{
  	VK_SUCCESS = 0,
  	VK_NOT_READY = 1,
  	VK_TIMEOUT = 2,
  	VK_EVENT_SET = 3,
  	VK_EVENT_RESET = 4,
  	VK_INCOMPLETE = 5,
  	VK_ERROR_OUT_OF_HOST_MEMORY = -1,
  	VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
  	VK_ERROR_INITIALIZATION_FAILED = -3,
  	VK_ERROR_DEVICE_LOST = -4,
  	VK_ERROR_MEMORY_MAP_FAILED = -5,
  	VK_ERROR_LAYER_NOT_PRESENT = -6,
  	VK_ERROR_EXTENSION_NOT_PRESENT = -7,
  	VK_ERROR_FEATURE_NOT_PRESENT = -8,
  	VK_ERROR_INCOMPATIBLE_DRIVER = -9,
  	VK_ERROR_TOO_MANY_OBJECTS = -10,
  	VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
  	VK_ERROR_FRAGMENTED_POOL = -12,
  	VK_ERROR_SURFACE_LOST_KHR = -1000000000,
  	VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
  	VK_SUBOPTIMAL_KHR = 1000001003,
  	VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
  	VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
  	VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
  	VK_ERROR_INVALID_SHADER_NV = -1000012000
  } VkResult;
  typedef enum VkShaderStageFlagBits{
  	VK_SHADER_STAGE_VERTEX_BIT = 1,
  	VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
  	VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 4,
  	VK_SHADER_STAGE_GEOMETRY_BIT = 8,
  	VK_SHADER_STAGE_FRAGMENT_BIT = 16,
  	VK_SHADER_STAGE_COMPUTE_BIT = 32,
  	VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,
  	VK_SHADER_STAGE_ALL = 0x7FFFFFFF
  } VkShaderStageFlagBits;
  typedef enum VkSparseMemoryBindFlagBits{
  	VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1
  } VkSparseMemoryBindFlagBits;
  typedef enum VkStencilFaceFlagBits{
  	VK_STENCIL_FACE_FRONT_BIT = 1,
  	VK_STENCIL_FACE_BACK_BIT = 2,
  	VK_STENCIL_FRONT_AND_BACK = 0x00000003
  } VkStencilFaceFlagBits;
  typedef enum VkStencilOp{
  	VK_STENCIL_OP_KEEP = 0,
  	VK_STENCIL_OP_ZERO = 1,
  	VK_STENCIL_OP_REPLACE = 2,
  	VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
  	VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
  	VK_STENCIL_OP_INVERT = 5,
  	VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
  	VK_STENCIL_OP_DECREMENT_AND_WRAP = 7
  } VkStencilOp;
  typedef enum VkStructureType{
  	VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
  	VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
  	VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
  	VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
  	VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
  	VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
  	VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
  	VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
  	VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
  	VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
  	VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
  	VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
  	VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
  	VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
  	VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
  	VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
  	VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
  	VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
  	VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
  	VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
  	VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
  	VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
  	VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
  	VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
  	VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
  	VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
  	VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
  	VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
  	VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
  	VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
  	VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
  	VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
  	VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
  	VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
  	VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
  	VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
  	VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
  	VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
  	VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
  	VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
  	VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
  	VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
  	VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
  	VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
  	VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
  	VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
  	VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
  	VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
  	VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
  	VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
  	VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
  	VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
  	VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
  	VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
  	VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
  	VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
  	VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
  	VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
  	VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
  	VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
  	VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,
  	VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,
  	VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,
  	VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,
  	VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,
  	VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,
  	VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,
  	VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,
  	VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,
  	VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,
  	VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,
  	VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,
  	VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,
  	VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000
  } VkStructureType;
  typedef enum VkSystemAllocationScope{
  	VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
  	VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
  	VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
  	VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
  	VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4
  } VkSystemAllocationScope;
  typedef enum VkInternalAllocationType{
  	VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0
  } VkInternalAllocationType;
  typedef enum VkSamplerAddressMode{
  	VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
  	VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
  	VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
  	VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
  	VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4
  } VkSamplerAddressMode;
  typedef enum VkFilter{
  	VK_FILTER_NEAREST = 0,
  	VK_FILTER_LINEAR = 1,
  	VK_FILTER_CUBIC_IMG = 1000015000
  } VkFilter;
  typedef enum VkSamplerMipmapMode{
  	VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
  	VK_SAMPLER_MIPMAP_MODE_LINEAR = 1
  } VkSamplerMipmapMode;
  typedef enum VkVertexInputRate{
  	VK_VERTEX_INPUT_RATE_VERTEX = 0,
  	VK_VERTEX_INPUT_RATE_INSTANCE = 1
  } VkVertexInputRate;
  typedef enum VkPipelineStageFlagBits{
  	VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
  	VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
  	VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 4,
  	VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 8,
  	VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 16,
  	VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 32,
  	VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 64,
  	VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 128,
  	VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 256,
  	VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 512,
  	VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 1024,
  	VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 2048,
  	VK_PIPELINE_STAGE_TRANSFER_BIT = 4096,
  	VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 8192,
  	VK_PIPELINE_STAGE_HOST_BIT = 16384,
  	VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 32768,
  	VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536
  } VkPipelineStageFlagBits;
  typedef enum VkSparseImageFormatFlagBits{
  	VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
  	VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
  	VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4
  } VkSparseImageFormatFlagBits;
  typedef enum VkSampleCountFlagBits{
  	VK_SAMPLE_COUNT_1_BIT = 1,
  	VK_SAMPLE_COUNT_2_BIT = 2,
  	VK_SAMPLE_COUNT_4_BIT = 4,
  	VK_SAMPLE_COUNT_8_BIT = 8,
  	VK_SAMPLE_COUNT_16_BIT = 16,
  	VK_SAMPLE_COUNT_32_BIT = 32,
  	VK_SAMPLE_COUNT_64_BIT = 64
  } VkSampleCountFlagBits;
  typedef enum VkAttachmentDescriptionFlagBits{
  	VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1
  } VkAttachmentDescriptionFlagBits;
  typedef enum VkDescriptorPoolCreateFlagBits{
  	VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1
  } VkDescriptorPoolCreateFlagBits;
  typedef enum VkDependencyFlagBits{
  	VK_DEPENDENCY_BY_REGION_BIT = 1
  } VkDependencyFlagBits;
  typedef enum VkColorSpaceKHR{
  	VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0
  } VkColorSpaceKHR;
  typedef enum VkCompositeAlphaFlagBitsKHR{
  	VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 1,
  	VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 2,
  	VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 4,
  	VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 8,
  	VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 2147483647
  } VkCompositeAlphaFlagBitsKHR;
  typedef enum VkDisplayPlaneAlphaFlagBitsKHR{
  	VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 1,
  	VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 2,
  	VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 4,
  	VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 8
  } VkDisplayPlaneAlphaFlagBitsKHR;
  typedef enum VkPresentModeKHR{
  	VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
  	VK_PRESENT_MODE_MAILBOX_KHR = 1,
  	VK_PRESENT_MODE_FIFO_KHR = 2,
  	VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3
  } VkPresentModeKHR;
  typedef enum VkSurfaceTransformFlagBitsKHR{
  	VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 1,
  	VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 2,
  	VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 4,
  	VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 8,
  	VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 16,
  	VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 32,
  	VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 64,
  	VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 128,
  	VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 256
  } VkSurfaceTransformFlagBitsKHR;
  typedef enum VkDebugReportFlagBitsEXT{
  	VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 1,
  	VK_DEBUG_REPORT_WARNING_BIT_EXT = 2,
  	VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 4,
  	VK_DEBUG_REPORT_ERROR_BIT_EXT = 8,
  	VK_DEBUG_REPORT_DEBUG_BIT_EXT = 16
  } VkDebugReportFlagBitsEXT;
  typedef enum VkDebugReportObjectTypeEXT{
  	VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
  	VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
  	VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
  	VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
  	VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
  	VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
  	VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
  	VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
  	VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
  	VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
  	VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
  	VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
  	VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
  	VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
  	VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
  	VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
  	VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
  	VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
  	VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
  	VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
  	VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
  	VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
  	VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
  	VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28
  } VkDebugReportObjectTypeEXT;
  typedef enum VkDebugReportErrorEXT{
  	VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
  	VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1
  } VkDebugReportErrorEXT;
  typedef enum VkRasterizationOrderAMD{
  	VK_RASTERIZATION_ORDER_STRICT_AMD = 0,
  	VK_RASTERIZATION_ORDER_RELAXED_AMD = 1
  } VkRasterizationOrderAMD;
  typedef enum VkExternalMemoryHandleTypeFlagBitsNV{
  	VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 1,
  	VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 2,
  	VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 4,
  	VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 8
  } VkExternalMemoryHandleTypeFlagBitsNV;
  typedef enum VkExternalMemoryFeatureFlagBitsNV{
  	VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 1,
  	VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 2,
  	VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 4
  } VkExternalMemoryFeatureFlagBitsNV;
  typedef enum VkValidationCheckEXT{
  	VK_VALIDATION_CHECK_ALL_EXT = 0
  } VkValidationCheckEXT;
  typedef void (*PFN_vkInternalAllocationNotification)(void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
  typedef void (*PFN_vkInternalFreeNotification)(void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope);
  typedef void* (*PFN_vkReallocationFunction)(void* pUserData, void* pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope);
  typedef void* (*PFN_vkAllocationFunction)(void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope);
  typedef void (*PFN_vkFreeFunction)(void* pUserData, void* pMemory);
  typedef void (*PFN_vkVoidFunction)(void);
  typedef VkBool32 (*PFN_vkDebugReportCallbackEXT)(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData);
  typedef struct VkOffset2D{
  	int32_t x;
  	int32_t y;
  } VkOffset2D;
  typedef struct VkOffset3D{
  	int32_t x;
  	int32_t y;
  	int32_t z;
  } VkOffset3D;
  typedef struct VkExtent2D{
  	uint32_t width;
  	uint32_t height;
  } VkExtent2D;
  typedef struct VkExtent3D{
  	uint32_t width;
  	uint32_t height;
  	uint32_t depth;
  } VkExtent3D;
  typedef struct VkViewport{
  	float x;
  	float y;
  	float width;
  	float height;
  	float minDepth;
  	float maxDepth;
  } VkViewport;
  typedef struct VkRect2D{
  	VkOffset2D offset;
  	VkExtent2D extent;
  } VkRect2D;
  typedef struct VkRect3D{
  	VkOffset3D offset;
  	VkExtent3D extent;
  } VkRect3D;
  typedef struct VkClearRect{
  	VkRect2D rect;
  	uint32_t baseArrayLayer;
  	uint32_t layerCount;
  } VkClearRect;
  typedef struct VkComponentMapping{
  	VkComponentSwizzle r;
  	VkComponentSwizzle g;
  	VkComponentSwizzle b;
  	VkComponentSwizzle a;
  } VkComponentMapping;
  typedef struct VkPhysicalDeviceLimits{
  	uint32_t maxImageDimension1D;
  	uint32_t maxImageDimension2D;
  	uint32_t maxImageDimension3D;
  	uint32_t maxImageDimensionCube;
  	uint32_t maxImageArrayLayers;
  	uint32_t maxTexelBufferElements;
  	uint32_t maxUniformBufferRange;
  	uint32_t maxStorageBufferRange;
  	uint32_t maxPushConstantsSize;
  	uint32_t maxMemoryAllocationCount;
  	uint32_t maxSamplerAllocationCount;
  	VkDeviceSize bufferImageGranularity;
  	VkDeviceSize sparseAddressSpaceSize;
  	uint32_t maxBoundDescriptorSets;
  	uint32_t maxPerStageDescriptorSamplers;
  	uint32_t maxPerStageDescriptorUniformBuffers;
  	uint32_t maxPerStageDescriptorStorageBuffers;
  	uint32_t maxPerStageDescriptorSampledImages;
  	uint32_t maxPerStageDescriptorStorageImages;
  	uint32_t maxPerStageDescriptorInputAttachments;
  	uint32_t maxPerStageResources;
  	uint32_t maxDescriptorSetSamplers;
  	uint32_t maxDescriptorSetUniformBuffers;
  	uint32_t maxDescriptorSetUniformBuffersDynamic;
  	uint32_t maxDescriptorSetStorageBuffers;
  	uint32_t maxDescriptorSetStorageBuffersDynamic;
  	uint32_t maxDescriptorSetSampledImages;
  	uint32_t maxDescriptorSetStorageImages;
  	uint32_t maxDescriptorSetInputAttachments;
  	uint32_t maxVertexInputAttributes;
  	uint32_t maxVertexInputBindings;
  	uint32_t maxVertexInputAttributeOffset;
  	uint32_t maxVertexInputBindingStride;
  	uint32_t maxVertexOutputComponents;
  	uint32_t maxTessellationGenerationLevel;
  	uint32_t maxTessellationPatchSize;
  	uint32_t maxTessellationControlPerVertexInputComponents;
  	uint32_t maxTessellationControlPerVertexOutputComponents;
  	uint32_t maxTessellationControlPerPatchOutputComponents;
  	uint32_t maxTessellationControlTotalOutputComponents;
  	uint32_t maxTessellationEvaluationInputComponents;
  	uint32_t maxTessellationEvaluationOutputComponents;
  	uint32_t maxGeometryShaderInvocations;
  	uint32_t maxGeometryInputComponents;
  	uint32_t maxGeometryOutputComponents;
  	uint32_t maxGeometryOutputVertices;
  	uint32_t maxGeometryTotalOutputComponents;
  	uint32_t maxFragmentInputComponents;
  	uint32_t maxFragmentOutputAttachments;
  	uint32_t maxFragmentDualSrcAttachments;
  	uint32_t maxFragmentCombinedOutputResources;
  	uint32_t maxComputeSharedMemorySize;
  	uint32_t maxComputeWorkGroupCount[3];
  	uint32_t maxComputeWorkGroupInvocations;
  	uint32_t maxComputeWorkGroupSize[3];
  	uint32_t subPixelPrecisionBits;
  	uint32_t subTexelPrecisionBits;
  	uint32_t mipmapPrecisionBits;
  	uint32_t maxDrawIndexedIndexValue;
  	uint32_t maxDrawIndirectCount;
  	float maxSamplerLodBias;
  	float maxSamplerAnisotropy;
  	uint32_t maxViewports;
  	uint32_t maxViewportDimensions[2];
  	float viewportBoundsRange[2];
  	uint32_t viewportSubPixelBits;
  	size_t minMemoryMapAlignment;
  	VkDeviceSize minTexelBufferOffsetAlignment;
  	VkDeviceSize minUniformBufferOffsetAlignment;
  	VkDeviceSize minStorageBufferOffsetAlignment;
  	int32_t minTexelOffset;
  	uint32_t maxTexelOffset;
  	int32_t minTexelGatherOffset;
  	uint32_t maxTexelGatherOffset;
  	float minInterpolationOffset;
  	float maxInterpolationOffset;
  	uint32_t subPixelInterpolationOffsetBits;
  	uint32_t maxFramebufferWidth;
  	uint32_t maxFramebufferHeight;
  	uint32_t maxFramebufferLayers;
  	VkSampleCountFlags framebufferColorSampleCounts;
  	VkSampleCountFlags framebufferDepthSampleCounts;
  	VkSampleCountFlags framebufferStencilSampleCounts;
  	VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
  	uint32_t maxColorAttachments;
  	VkSampleCountFlags sampledImageColorSampleCounts;
  	VkSampleCountFlags sampledImageIntegerSampleCounts;
  	VkSampleCountFlags sampledImageDepthSampleCounts;
  	VkSampleCountFlags sampledImageStencilSampleCounts;
  	VkSampleCountFlags storageImageSampleCounts;
  	uint32_t maxSampleMaskWords;
  	VkBool32 timestampComputeAndGraphics;
  	float timestampPeriod;
  	uint32_t maxClipDistances;
  	uint32_t maxCullDistances;
  	uint32_t maxCombinedClipAndCullDistances;
  	uint32_t discreteQueuePriorities;
  	float pointSizeRange[2];
  	float lineWidthRange[2];
  	float pointSizeGranularity;
  	float lineWidthGranularity;
  	VkBool32 strictLines;
  	VkBool32 standardSampleLocations;
  	VkDeviceSize optimalBufferCopyOffsetAlignment;
  	VkDeviceSize optimalBufferCopyRowPitchAlignment;
  	VkDeviceSize nonCoherentAtomSize;
  } VkPhysicalDeviceLimits;
  typedef struct VkPhysicalDeviceSparseProperties{
  	VkBool32 residencyStandard2DBlockShape;
  	VkBool32 residencyStandard2DMultisampleBlockShape;
  	VkBool32 residencyStandard3DBlockShape;
  	VkBool32 residencyAlignedMipSize;
  	VkBool32 residencyNonResidentStrict;
  } VkPhysicalDeviceSparseProperties;
  typedef struct VkPhysicalDeviceProperties{
  	uint32_t apiVersion;
  	uint32_t driverVersion;
  	uint32_t vendorID;
  	uint32_t deviceID;
  	VkPhysicalDeviceType deviceType;
  	char deviceName[256];
  	uint8_t pipelineCacheUUID[16];
  	VkPhysicalDeviceLimits limits;
  	VkPhysicalDeviceSparseProperties sparseProperties;
  } VkPhysicalDeviceProperties;
  typedef struct VkExtensionProperties{
  	char extensionName[256];
  	uint32_t specVersion;
  } VkExtensionProperties;
  typedef struct VkLayerProperties{
  	char layerName[256];
  	uint32_t specVersion;
  	uint32_t implementationVersion;
  	char description[256];
  } VkLayerProperties;
  typedef struct VkApplicationInfo{
  	VkStructureType sType;
  	void* pNext;
  	char* pApplicationName;
  	uint32_t applicationVersion;
  	char* pEngineName;
  	uint32_t engineVersion;
  	uint32_t apiVersion;
  } VkApplicationInfo;
  typedef struct VkAllocationCallbacks{
  	void* pUserData;
  	PFN_vkAllocationFunction pfnAllocation;
  	PFN_vkReallocationFunction pfnReallocation;
  	PFN_vkFreeFunction pfnFree;
  	PFN_vkInternalAllocationNotification pfnInternalAllocation;
  	PFN_vkInternalFreeNotification pfnInternalFree;
  } VkAllocationCallbacks;
  typedef struct VkDeviceQueueCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDeviceQueueCreateFlags flags;
  	uint32_t queueFamilyIndex;
  	uint32_t queueCount;
  	float* pQueuePriorities;
  } VkDeviceQueueCreateInfo;
  typedef struct VkPhysicalDeviceFeatures{
  	VkBool32 robustBufferAccess;
  	VkBool32 fullDrawIndexUint32;
  	VkBool32 imageCubeArray;
  	VkBool32 independentBlend;
  	VkBool32 geometryShader;
  	VkBool32 tessellationShader;
  	VkBool32 sampleRateShading;
  	VkBool32 dualSrcBlend;
  	VkBool32 logicOp;
  	VkBool32 multiDrawIndirect;
  	VkBool32 drawIndirectFirstInstance;
  	VkBool32 depthClamp;
  	VkBool32 depthBiasClamp;
  	VkBool32 fillModeNonSolid;
  	VkBool32 depthBounds;
  	VkBool32 wideLines;
  	VkBool32 largePoints;
  	VkBool32 alphaToOne;
  	VkBool32 multiViewport;
  	VkBool32 samplerAnisotropy;
  	VkBool32 textureCompressionETC2;
  	VkBool32 textureCompressionASTC_LDR;
  	VkBool32 textureCompressionBC;
  	VkBool32 occlusionQueryPrecise;
  	VkBool32 pipelineStatisticsQuery;
  	VkBool32 vertexPipelineStoresAndAtomics;
  	VkBool32 fragmentStoresAndAtomics;
  	VkBool32 shaderTessellationAndGeometryPointSize;
  	VkBool32 shaderImageGatherExtended;
  	VkBool32 shaderStorageImageExtendedFormats;
  	VkBool32 shaderStorageImageMultisample;
  	VkBool32 shaderStorageImageReadWithoutFormat;
  	VkBool32 shaderStorageImageWriteWithoutFormat;
  	VkBool32 shaderUniformBufferArrayDynamicIndexing;
  	VkBool32 shaderSampledImageArrayDynamicIndexing;
  	VkBool32 shaderStorageBufferArrayDynamicIndexing;
  	VkBool32 shaderStorageImageArrayDynamicIndexing;
  	VkBool32 shaderClipDistance;
  	VkBool32 shaderCullDistance;
  	VkBool32 shaderFloat64;
  	VkBool32 shaderInt64;
  	VkBool32 shaderInt16;
  	VkBool32 shaderResourceResidency;
  	VkBool32 shaderResourceMinLod;
  	VkBool32 sparseBinding;
  	VkBool32 sparseResidencyBuffer;
  	VkBool32 sparseResidencyImage2D;
  	VkBool32 sparseResidencyImage3D;
  	VkBool32 sparseResidency2Samples;
  	VkBool32 sparseResidency4Samples;
  	VkBool32 sparseResidency8Samples;
  	VkBool32 sparseResidency16Samples;
  	VkBool32 sparseResidencyAliased;
  	VkBool32 variableMultisampleRate;
  	VkBool32 inheritedQueries;
  } VkPhysicalDeviceFeatures;
  typedef struct VkDeviceCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDeviceCreateFlags flags;
  	uint32_t queueCreateInfoCount;
  	VkDeviceQueueCreateInfo* pQueueCreateInfos;
  	uint32_t enabledLayerCount;
  	char* const* ppEnabledLayerNames;
  	uint32_t enabledExtensionCount;
  	char* const* ppEnabledExtensionNames;
  	VkPhysicalDeviceFeatures* pEnabledFeatures;
  } VkDeviceCreateInfo;
  typedef struct VkInstanceCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkInstanceCreateFlags flags;
  	VkApplicationInfo* pApplicationInfo;
  	uint32_t enabledLayerCount;
  	char* const* ppEnabledLayerNames;
  	uint32_t enabledExtensionCount;
  	char* const* ppEnabledExtensionNames;
  } VkInstanceCreateInfo;
  typedef struct VkQueueFamilyProperties{
  	VkQueueFlags queueFlags;
  	uint32_t queueCount;
  	uint32_t timestampValidBits;
  	VkExtent3D minImageTransferGranularity;
  } VkQueueFamilyProperties;
  typedef struct VkMemoryType{
  	VkMemoryPropertyFlags propertyFlags;
  	uint32_t heapIndex;
  } VkMemoryType;
  typedef struct VkMemoryHeap{
  	VkDeviceSize size;
  	VkMemoryHeapFlags flags;
  } VkMemoryHeap;
  typedef struct VkPhysicalDeviceMemoryProperties{
  	uint32_t memoryTypeCount;
  	VkMemoryType memoryTypes[32];
  	uint32_t memoryHeapCount;
  	VkMemoryHeap memoryHeaps[16];
  } VkPhysicalDeviceMemoryProperties;
  typedef struct VkMemoryAllocateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDeviceSize allocationSize;
  	uint32_t memoryTypeIndex;
  } VkMemoryAllocateInfo;
  typedef struct VkMemoryRequirements{
  	VkDeviceSize size;
  	VkDeviceSize alignment;
  	uint32_t memoryTypeBits;
  } VkMemoryRequirements;
  typedef struct VkSparseImageFormatProperties{
  	VkImageAspectFlags aspectMask;
  	VkExtent3D imageGranularity;
  	VkSparseImageFormatFlags flags;
  } VkSparseImageFormatProperties;
  typedef struct VkSparseImageMemoryRequirements{
  	VkSparseImageFormatProperties formatProperties;
  	uint32_t imageMipTailFirstLod;
  	VkDeviceSize imageMipTailSize;
  	VkDeviceSize imageMipTailOffset;
  	VkDeviceSize imageMipTailStride;
  } VkSparseImageMemoryRequirements;
  typedef struct VkMappedMemoryRange{
  	VkStructureType sType;
  	void* pNext;
  	VkDeviceMemory memory;
  	VkDeviceSize offset;
  	VkDeviceSize size;
  } VkMappedMemoryRange;
  typedef struct VkFormatProperties{
  	VkFormatFeatureFlags linearTilingFeatures;
  	VkFormatFeatureFlags optimalTilingFeatures;
  	VkFormatFeatureFlags bufferFeatures;
  } VkFormatProperties;
  typedef struct VkImageFormatProperties{
  	VkExtent3D maxExtent;
  	uint32_t maxMipLevels;
  	uint32_t maxArrayLayers;
  	VkSampleCountFlags sampleCounts;
  	VkDeviceSize maxResourceSize;
  } VkImageFormatProperties;
  typedef struct VkDescriptorBufferInfo{
  	VkBuffer buffer;
  	VkDeviceSize offset;
  	VkDeviceSize range;
  } VkDescriptorBufferInfo;
  typedef struct VkDescriptorImageInfo{
  	VkSampler sampler;
  	VkImageView imageView;
  	VkImageLayout imageLayout;
  } VkDescriptorImageInfo;
  typedef struct VkWriteDescriptorSet{
  	VkStructureType sType;
  	void* pNext;
  	VkDescriptorSet dstSet;
  	uint32_t dstBinding;
  	uint32_t dstArrayElement;
  	uint32_t descriptorCount;
  	VkDescriptorType descriptorType;
  	VkDescriptorImageInfo* pImageInfo;
  	VkDescriptorBufferInfo* pBufferInfo;
  	VkBufferView* pTexelBufferView;
  } VkWriteDescriptorSet;
  typedef struct VkCopyDescriptorSet{
  	VkStructureType sType;
  	void* pNext;
  	VkDescriptorSet srcSet;
  	uint32_t srcBinding;
  	uint32_t srcArrayElement;
  	VkDescriptorSet dstSet;
  	uint32_t dstBinding;
  	uint32_t dstArrayElement;
  	uint32_t descriptorCount;
  } VkCopyDescriptorSet;
  typedef struct VkBufferCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkBufferCreateFlags flags;
  	VkDeviceSize size;
  	VkBufferUsageFlags usage;
  	VkSharingMode sharingMode;
  	uint32_t queueFamilyIndexCount;
  	uint32_t* pQueueFamilyIndices;
  } VkBufferCreateInfo;
  typedef struct VkBufferViewCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkBufferViewCreateFlags flags;
  	VkBuffer buffer;
  	VkFormat format;
  	VkDeviceSize offset;
  	VkDeviceSize range;
  } VkBufferViewCreateInfo;
  typedef struct VkImageSubresource{
  	VkImageAspectFlags aspectMask;
  	uint32_t mipLevel;
  	uint32_t arrayLayer;
  } VkImageSubresource;
  typedef struct VkImageSubresourceLayers{
  	VkImageAspectFlags aspectMask;
  	uint32_t mipLevel;
  	uint32_t baseArrayLayer;
  	uint32_t layerCount;
  } VkImageSubresourceLayers;
  typedef struct VkImageSubresourceRange{
  	VkImageAspectFlags aspectMask;
  	uint32_t baseMipLevel;
  	uint32_t levelCount;
  	uint32_t baseArrayLayer;
  	uint32_t layerCount;
  } VkImageSubresourceRange;
  typedef struct VkMemoryBarrier{
  	VkStructureType sType;
  	void* pNext;
  	VkAccessFlags srcAccessMask;
  	VkAccessFlags dstAccessMask;
  } VkMemoryBarrier;
  typedef struct VkBufferMemoryBarrier{
  	VkStructureType sType;
  	void* pNext;
  	VkAccessFlags srcAccessMask;
  	VkAccessFlags dstAccessMask;
  	uint32_t srcQueueFamilyIndex;
  	uint32_t dstQueueFamilyIndex;
  	VkBuffer buffer;
  	VkDeviceSize offset;
  	VkDeviceSize size;
  } VkBufferMemoryBarrier;
  typedef struct VkImageMemoryBarrier{
  	VkStructureType sType;
  	void* pNext;
  	VkAccessFlags srcAccessMask;
  	VkAccessFlags dstAccessMask;
  	VkImageLayout oldLayout;
  	VkImageLayout newLayout;
  	uint32_t srcQueueFamilyIndex;
  	uint32_t dstQueueFamilyIndex;
  	VkImage image;
  	VkImageSubresourceRange subresourceRange;
  } VkImageMemoryBarrier;
  typedef struct VkImageCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkImageCreateFlags flags;
  	VkImageType imageType;
  	VkFormat format;
  	VkExtent3D extent;
  	uint32_t mipLevels;
  	uint32_t arrayLayers;
  	VkSampleCountFlagBits samples;
  	VkImageTiling tiling;
  	VkImageUsageFlags usage;
  	VkSharingMode sharingMode;
  	uint32_t queueFamilyIndexCount;
  	uint32_t* pQueueFamilyIndices;
  	VkImageLayout initialLayout;
  } VkImageCreateInfo;
  typedef struct VkSubresourceLayout{
  	VkDeviceSize offset;
  	VkDeviceSize size;
  	VkDeviceSize rowPitch;
  	VkDeviceSize arrayPitch;
  	VkDeviceSize depthPitch;
  } VkSubresourceLayout;
  typedef struct VkImageViewCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkImageViewCreateFlags flags;
  	VkImage image;
  	VkImageViewType viewType;
  	VkFormat format;
  	VkComponentMapping components;
  	VkImageSubresourceRange subresourceRange;
  } VkImageViewCreateInfo;
  typedef struct VkBufferCopy{
  	VkDeviceSize srcOffset;
  	VkDeviceSize dstOffset;
  	VkDeviceSize size;
  } VkBufferCopy;
  typedef struct VkSparseMemoryBind{
  	VkDeviceSize resourceOffset;
  	VkDeviceSize size;
  	VkDeviceMemory memory;
  	VkDeviceSize memoryOffset;
  	VkSparseMemoryBindFlags flags;
  } VkSparseMemoryBind;
  typedef struct VkSparseImageMemoryBind{
  	VkImageSubresource subresource;
  	VkOffset3D offset;
  	VkExtent3D extent;
  	VkDeviceMemory memory;
  	VkDeviceSize memoryOffset;
  	VkSparseMemoryBindFlags flags;
  } VkSparseImageMemoryBind;
  typedef struct VkSparseBufferMemoryBindInfo{
  	VkBuffer buffer;
  	uint32_t bindCount;
  	VkSparseMemoryBind* pBinds;
  } VkSparseBufferMemoryBindInfo;
  typedef struct VkSparseImageOpaqueMemoryBindInfo{
  	VkImage image;
  	uint32_t bindCount;
  	VkSparseMemoryBind* pBinds;
  } VkSparseImageOpaqueMemoryBindInfo;
  typedef struct VkSparseImageMemoryBindInfo{
  	VkImage image;
  	uint32_t bindCount;
  	VkSparseImageMemoryBind* pBinds;
  } VkSparseImageMemoryBindInfo;
  typedef struct VkBindSparseInfo{
  	VkStructureType sType;
  	void* pNext;
  	uint32_t waitSemaphoreCount;
  	VkSemaphore* pWaitSemaphores;
  	uint32_t bufferBindCount;
  	VkSparseBufferMemoryBindInfo* pBufferBinds;
  	uint32_t imageOpaqueBindCount;
  	VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
  	uint32_t imageBindCount;
  	VkSparseImageMemoryBindInfo* pImageBinds;
  	uint32_t signalSemaphoreCount;
  	VkSemaphore* pSignalSemaphores;
  } VkBindSparseInfo;
  typedef struct VkImageCopy{
  	VkImageSubresourceLayers srcSubresource;
  	VkOffset3D srcOffset;
  	VkImageSubresourceLayers dstSubresource;
  	VkOffset3D dstOffset;
  	VkExtent3D extent;
  } VkImageCopy;
  typedef struct VkImageBlit{
  	VkImageSubresourceLayers srcSubresource;
  	VkOffset3D srcOffsets[2];
  	VkImageSubresourceLayers dstSubresource;
  	VkOffset3D dstOffsets[2];
  } VkImageBlit;
  typedef struct VkBufferImageCopy{
  	VkDeviceSize bufferOffset;
  	uint32_t bufferRowLength;
  	uint32_t bufferImageHeight;
  	VkImageSubresourceLayers imageSubresource;
  	VkOffset3D imageOffset;
  	VkExtent3D imageExtent;
  } VkBufferImageCopy;
  typedef struct VkImageResolve{
  	VkImageSubresourceLayers srcSubresource;
  	VkOffset3D srcOffset;
  	VkImageSubresourceLayers dstSubresource;
  	VkOffset3D dstOffset;
  	VkExtent3D extent;
  } VkImageResolve;
  typedef struct VkShaderModuleCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkShaderModuleCreateFlags flags;
  	size_t codeSize;
  	uint32_t* pCode;
  } VkShaderModuleCreateInfo;
  typedef struct VkDescriptorSetLayoutBinding{
  	uint32_t binding;
  	VkDescriptorType descriptorType;
  	uint32_t descriptorCount;
  	VkShaderStageFlags stageFlags;
  	VkSampler* pImmutableSamplers;
  } VkDescriptorSetLayoutBinding;
  typedef struct VkDescriptorSetLayoutCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDescriptorSetLayoutCreateFlags flags;
  	uint32_t bindingCount;
  	VkDescriptorSetLayoutBinding* pBindings;
  } VkDescriptorSetLayoutCreateInfo;
  typedef struct VkDescriptorPoolSize{
  	VkDescriptorType type;
  	uint32_t descriptorCount;
  } VkDescriptorPoolSize;
  typedef struct VkDescriptorPoolCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDescriptorPoolCreateFlags flags;
  	uint32_t maxSets;
  	uint32_t poolSizeCount;
  	VkDescriptorPoolSize* pPoolSizes;
  } VkDescriptorPoolCreateInfo;
  typedef struct VkDescriptorSetAllocateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkDescriptorPool descriptorPool;
  	uint32_t descriptorSetCount;
  	VkDescriptorSetLayout* pSetLayouts;
  } VkDescriptorSetAllocateInfo;
  typedef struct VkSpecializationMapEntry{
  	uint32_t constantID;
  	uint32_t offset;
  	size_t size;
  } VkSpecializationMapEntry;
  typedef struct VkSpecializationInfo{
  	uint32_t mapEntryCount;
  	VkSpecializationMapEntry* pMapEntries;
  	size_t dataSize;
  	void* pData;
  } VkSpecializationInfo;
  typedef struct VkPipelineShaderStageCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineShaderStageCreateFlags flags;
  	VkShaderStageFlagBits stage;
  	VkShaderModule module;
  	char* pName;
  	VkSpecializationInfo* pSpecializationInfo;
  } VkPipelineShaderStageCreateInfo;
  typedef struct VkComputePipelineCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineCreateFlags flags;
  	VkPipelineShaderStageCreateInfo stage;
  	VkPipelineLayout layout;
  	VkPipeline basePipelineHandle;
  	int32_t basePipelineIndex;
  } VkComputePipelineCreateInfo;
  typedef struct VkVertexInputBindingDescription{
  	uint32_t binding;
  	uint32_t stride;
  	VkVertexInputRate inputRate;
  } VkVertexInputBindingDescription;
  typedef struct VkVertexInputAttributeDescription{
  	uint32_t location;
  	uint32_t binding;
  	VkFormat format;
  	uint32_t offset;
  } VkVertexInputAttributeDescription;
  typedef struct VkPipelineVertexInputStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineVertexInputStateCreateFlags flags;
  	uint32_t vertexBindingDescriptionCount;
  	VkVertexInputBindingDescription* pVertexBindingDescriptions;
  	uint32_t vertexAttributeDescriptionCount;
  	VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
  } VkPipelineVertexInputStateCreateInfo;
  typedef struct VkPipelineInputAssemblyStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineInputAssemblyStateCreateFlags flags;
  	VkPrimitiveTopology topology;
  	VkBool32 primitiveRestartEnable;
  } VkPipelineInputAssemblyStateCreateInfo;
  typedef struct VkPipelineTessellationStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineTessellationStateCreateFlags flags;
  	uint32_t patchControlPoints;
  } VkPipelineTessellationStateCreateInfo;
  typedef struct VkPipelineViewportStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineViewportStateCreateFlags flags;
  	uint32_t viewportCount;
  	VkViewport* pViewports;
  	uint32_t scissorCount;
  	VkRect2D* pScissors;
  } VkPipelineViewportStateCreateInfo;
  typedef struct VkPipelineRasterizationStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineRasterizationStateCreateFlags flags;
  	VkBool32 depthClampEnable;
  	VkBool32 rasterizerDiscardEnable;
  	VkPolygonMode polygonMode;
  	VkCullModeFlags cullMode;
  	VkFrontFace frontFace;
  	VkBool32 depthBiasEnable;
  	float depthBiasConstantFactor;
  	float depthBiasClamp;
  	float depthBiasSlopeFactor;
  	float lineWidth;
  } VkPipelineRasterizationStateCreateInfo;
  typedef struct VkPipelineMultisampleStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineMultisampleStateCreateFlags flags;
  	VkSampleCountFlagBits rasterizationSamples;
  	VkBool32 sampleShadingEnable;
  	float minSampleShading;
  	VkSampleMask* pSampleMask;
  	VkBool32 alphaToCoverageEnable;
  	VkBool32 alphaToOneEnable;
  } VkPipelineMultisampleStateCreateInfo;
  typedef struct VkPipelineColorBlendAttachmentState{
  	VkBool32 blendEnable;
  	VkBlendFactor srcColorBlendFactor;
  	VkBlendFactor dstColorBlendFactor;
  	VkBlendOp colorBlendOp;
  	VkBlendFactor srcAlphaBlendFactor;
  	VkBlendFactor dstAlphaBlendFactor;
  	VkBlendOp alphaBlendOp;
  	VkColorComponentFlags colorWriteMask;
  } VkPipelineColorBlendAttachmentState;
  typedef struct VkPipelineColorBlendStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineColorBlendStateCreateFlags flags;
  	VkBool32 logicOpEnable;
  	VkLogicOp logicOp;
  	uint32_t attachmentCount;
  	VkPipelineColorBlendAttachmentState* pAttachments;
  	float blendConstants[4];
  } VkPipelineColorBlendStateCreateInfo;
  typedef struct VkPipelineDynamicStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineDynamicStateCreateFlags flags;
  	uint32_t dynamicStateCount;
  	VkDynamicState* pDynamicStates;
  } VkPipelineDynamicStateCreateInfo;
  typedef struct VkStencilOpState{
  	VkStencilOp failOp;
  	VkStencilOp passOp;
  	VkStencilOp depthFailOp;
  	VkCompareOp compareOp;
  	uint32_t compareMask;
  	uint32_t writeMask;
  	uint32_t reference;
  } VkStencilOpState;
  typedef struct VkPipelineDepthStencilStateCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineDepthStencilStateCreateFlags flags;
  	VkBool32 depthTestEnable;
  	VkBool32 depthWriteEnable;
  	VkCompareOp depthCompareOp;
  	VkBool32 depthBoundsTestEnable;
  	VkBool32 stencilTestEnable;
  	VkStencilOpState front;
  	VkStencilOpState back;
  	float minDepthBounds;
  	float maxDepthBounds;
  } VkPipelineDepthStencilStateCreateInfo;
  typedef struct VkGraphicsPipelineCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineCreateFlags flags;
  	uint32_t stageCount;
  	VkPipelineShaderStageCreateInfo* pStages;
  	VkPipelineVertexInputStateCreateInfo* pVertexInputState;
  	VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
  	VkPipelineTessellationStateCreateInfo* pTessellationState;
  	VkPipelineViewportStateCreateInfo* pViewportState;
  	VkPipelineRasterizationStateCreateInfo* pRasterizationState;
  	VkPipelineMultisampleStateCreateInfo* pMultisampleState;
  	VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
  	VkPipelineColorBlendStateCreateInfo* pColorBlendState;
  	VkPipelineDynamicStateCreateInfo* pDynamicState;
  	VkPipelineLayout layout;
  	VkRenderPass renderPass;
  	uint32_t subpass;
  	VkPipeline basePipelineHandle;
  	int32_t basePipelineIndex;
  } VkGraphicsPipelineCreateInfo;
  typedef struct VkPipelineCacheCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineCacheCreateFlags flags;
  	size_t initialDataSize;
  	void* pInitialData;
  } VkPipelineCacheCreateInfo;
  typedef struct VkPushConstantRange{
  	VkShaderStageFlags stageFlags;
  	uint32_t offset;
  	uint32_t size;
  } VkPushConstantRange;
  typedef struct VkPipelineLayoutCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkPipelineLayoutCreateFlags flags;
  	uint32_t setLayoutCount;
  	VkDescriptorSetLayout* pSetLayouts;
  	uint32_t pushConstantRangeCount;
  	VkPushConstantRange* pPushConstantRanges;
  } VkPipelineLayoutCreateInfo;
  typedef struct VkSamplerCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkSamplerCreateFlags flags;
  	VkFilter magFilter;
  	VkFilter minFilter;
  	VkSamplerMipmapMode mipmapMode;
  	VkSamplerAddressMode addressModeU;
  	VkSamplerAddressMode addressModeV;
  	VkSamplerAddressMode addressModeW;
  	float mipLodBias;
  	VkBool32 anisotropyEnable;
  	float maxAnisotropy;
  	VkBool32 compareEnable;
  	VkCompareOp compareOp;
  	float minLod;
  	float maxLod;
  	VkBorderColor borderColor;
  	VkBool32 unnormalizedCoordinates;
  } VkSamplerCreateInfo;
  typedef struct VkCommandPoolCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkCommandPoolCreateFlags flags;
  	uint32_t queueFamilyIndex;
  } VkCommandPoolCreateInfo;
  typedef struct VkCommandBufferAllocateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkCommandPool commandPool;
  	VkCommandBufferLevel level;
  	uint32_t commandBufferCount;
  } VkCommandBufferAllocateInfo;
  typedef struct VkCommandBufferInheritanceInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkRenderPass renderPass;
  	uint32_t subpass;
  	VkFramebuffer framebuffer;
  	VkBool32 occlusionQueryEnable;
  	VkQueryControlFlags queryFlags;
  	VkQueryPipelineStatisticFlags pipelineStatistics;
  } VkCommandBufferInheritanceInfo;
  typedef struct VkCommandBufferBeginInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkCommandBufferUsageFlags flags;
  	VkCommandBufferInheritanceInfo* pInheritanceInfo;
  } VkCommandBufferBeginInfo;
  typedef union VkClearColorValue{
  	float float32[4];
  	int32_t int32[4];
  	uint32_t uint32[4];
  } VkClearColorValue;
  typedef struct VkClearDepthStencilValue{
  	float depth;
  	uint32_t stencil;
  } VkClearDepthStencilValue;
  typedef union VkClearValue{
  	VkClearColorValue color;
  	VkClearDepthStencilValue depthStencil;
  } VkClearValue;
  typedef struct VkRenderPassBeginInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkRenderPass renderPass;
  	VkFramebuffer framebuffer;
  	VkRect2D renderArea;
  	uint32_t clearValueCount;
  	VkClearValue* pClearValues;
  } VkRenderPassBeginInfo;
  typedef struct VkClearAttachment{
  	VkImageAspectFlags aspectMask;
  	uint32_t colorAttachment;
  	VkClearValue clearValue;
  } VkClearAttachment;
  typedef struct VkAttachmentDescription{
  	VkAttachmentDescriptionFlags flags;
  	VkFormat format;
  	VkSampleCountFlagBits samples;
  	VkAttachmentLoadOp loadOp;
  	VkAttachmentStoreOp storeOp;
  	VkAttachmentLoadOp stencilLoadOp;
  	VkAttachmentStoreOp stencilStoreOp;
  	VkImageLayout initialLayout;
  	VkImageLayout finalLayout;
  } VkAttachmentDescription;
  typedef struct VkAttachmentReference{
  	uint32_t attachment;
  	VkImageLayout layout;
  } VkAttachmentReference;
  typedef struct VkSubpassDescription{
  	VkSubpassDescriptionFlags flags;
  	VkPipelineBindPoint pipelineBindPoint;
  	uint32_t inputAttachmentCount;
  	VkAttachmentReference* pInputAttachments;
  	uint32_t colorAttachmentCount;
  	VkAttachmentReference* pColorAttachments;
  	VkAttachmentReference* pResolveAttachments;
  	VkAttachmentReference* pDepthStencilAttachment;
  	uint32_t preserveAttachmentCount;
  	uint32_t* pPreserveAttachments;
  } VkSubpassDescription;
  typedef struct VkSubpassDependency{
  	uint32_t srcSubpass;
  	uint32_t dstSubpass;
  	VkPipelineStageFlags srcStageMask;
  	VkPipelineStageFlags dstStageMask;
  	VkAccessFlags srcAccessMask;
  	VkAccessFlags dstAccessMask;
  	VkDependencyFlags dependencyFlags;
  } VkSubpassDependency;
  typedef struct VkRenderPassCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkRenderPassCreateFlags flags;
  	uint32_t attachmentCount;
  	VkAttachmentDescription* pAttachments;
  	uint32_t subpassCount;
  	VkSubpassDescription* pSubpasses;
  	uint32_t dependencyCount;
  	VkSubpassDependency* pDependencies;
  } VkRenderPassCreateInfo;
  typedef struct VkEventCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkEventCreateFlags flags;
  } VkEventCreateInfo;
  typedef struct VkFenceCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkFenceCreateFlags flags;
  } VkFenceCreateInfo;
  typedef struct VkSemaphoreCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkSemaphoreCreateFlags flags;
  } VkSemaphoreCreateInfo;
  typedef struct VkQueryPoolCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkQueryPoolCreateFlags flags;
  	VkQueryType queryType;
  	uint32_t queryCount;
  	VkQueryPipelineStatisticFlags pipelineStatistics;
  } VkQueryPoolCreateInfo;
  typedef struct VkFramebufferCreateInfo{
  	VkStructureType sType;
  	void* pNext;
  	VkFramebufferCreateFlags flags;
  	VkRenderPass renderPass;
  	uint32_t attachmentCount;
  	VkImageView* pAttachments;
  	uint32_t width;
  	uint32_t height;
  	uint32_t layers;
  } VkFramebufferCreateInfo;
  typedef struct VkDrawIndirectCommand{
  	uint32_t vertexCount;
  	uint32_t instanceCount;
  	uint32_t firstVertex;
  	uint32_t firstInstance;
  } VkDrawIndirectCommand;
  typedef struct VkDrawIndexedIndirectCommand{
  	uint32_t indexCount;
  	uint32_t instanceCount;
  	uint32_t firstIndex;
  	int32_t vertexOffset;
  	uint32_t firstInstance;
  } VkDrawIndexedIndirectCommand;
  typedef struct VkDispatchIndirectCommand{
  	uint32_t x;
  	uint32_t y;
  	uint32_t z;
  } VkDispatchIndirectCommand;
  typedef struct VkSubmitInfo{
  	VkStructureType sType;
  	void* pNext;
  	uint32_t waitSemaphoreCount;
  	VkSemaphore* pWaitSemaphores;
  	VkPipelineStageFlags* pWaitDstStageMask;
  	uint32_t commandBufferCount;
  	VkCommandBuffer* pCommandBuffers;
  	uint32_t signalSemaphoreCount;
  	VkSemaphore* pSignalSemaphores;
  } VkSubmitInfo;
  typedef struct VkDisplayPropertiesKHR{
  	VkDisplayKHR display;
  	char* displayName;
  	VkExtent2D physicalDimensions;
  	VkExtent2D physicalResolution;
  	VkSurfaceTransformFlagsKHR supportedTransforms;
  	VkBool32 planeReorderPossible;
  	VkBool32 persistentContent;
  } VkDisplayPropertiesKHR;
  typedef struct VkDisplayPlanePropertiesKHR{
  	VkDisplayKHR currentDisplay;
  	uint32_t currentStackIndex;
  } VkDisplayPlanePropertiesKHR;
  typedef struct VkDisplayModeParametersKHR{
  	VkExtent2D visibleRegion;
  	uint32_t refreshRate;
  } VkDisplayModeParametersKHR;
  typedef struct VkDisplayModePropertiesKHR{
  	VkDisplayModeKHR displayMode;
  	VkDisplayModeParametersKHR parameters;
  } VkDisplayModePropertiesKHR;
  typedef struct VkDisplayModeCreateInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	VkDisplayModeCreateFlagsKHR flags;
  	VkDisplayModeParametersKHR parameters;
  } VkDisplayModeCreateInfoKHR;
  typedef struct VkDisplayPlaneCapabilitiesKHR{
  	VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
  	VkOffset2D minSrcPosition;
  	VkOffset2D maxSrcPosition;
  	VkExtent2D minSrcExtent;
  	VkExtent2D maxSrcExtent;
  	VkOffset2D minDstPosition;
  	VkOffset2D maxDstPosition;
  	VkExtent2D minDstExtent;
  	VkExtent2D maxDstExtent;
  } VkDisplayPlaneCapabilitiesKHR;
  typedef struct VkDisplaySurfaceCreateInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	VkDisplaySurfaceCreateFlagsKHR flags;
  	VkDisplayModeKHR displayMode;
  	uint32_t planeIndex;
  	uint32_t planeStackIndex;
  	VkSurfaceTransformFlagBitsKHR transform;
  	float globalAlpha;
  	VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
  	VkExtent2D imageExtent;
  } VkDisplaySurfaceCreateInfoKHR;
  typedef struct VkDisplayPresentInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	VkRect2D srcRect;
  	VkRect2D dstRect;
  	VkBool32 persistent;
  } VkDisplayPresentInfoKHR;
  typedef struct VkSurfaceCapabilitiesKHR{
  	uint32_t minImageCount;
  	uint32_t maxImageCount;
  	VkExtent2D currentExtent;
  	VkExtent2D minImageExtent;
  	VkExtent2D maxImageExtent;
  	uint32_t maxImageArrayLayers;
  	VkSurfaceTransformFlagsKHR supportedTransforms;
  	VkSurfaceTransformFlagBitsKHR currentTransform;
  	VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
  	VkImageUsageFlags supportedUsageFlags;
  } VkSurfaceCapabilitiesKHR;
  typedef struct VkAndroidSurfaceCreateInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	VkAndroidSurfaceCreateFlagsKHR flags;
  	ANativeWindow* window;
  } VkAndroidSurfaceCreateInfoKHR;
  typedef struct VkSurfaceFormatKHR{
  	VkFormat format;
  	VkColorSpaceKHR colorSpace;
  } VkSurfaceFormatKHR;
  typedef struct VkSwapchainCreateInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	VkSwapchainCreateFlagsKHR flags;
  	VkSurfaceKHR surface;
  	uint32_t minImageCount;
  	VkFormat imageFormat;
  	VkColorSpaceKHR imageColorSpace;
  	VkExtent2D imageExtent;
  	uint32_t imageArrayLayers;
  	VkImageUsageFlags imageUsage;
  	VkSharingMode imageSharingMode;
  	uint32_t queueFamilyIndexCount;
  	uint32_t* pQueueFamilyIndices;
  	VkSurfaceTransformFlagBitsKHR preTransform;
  	VkCompositeAlphaFlagBitsKHR compositeAlpha;
  	VkPresentModeKHR presentMode;
  	VkBool32 clipped;
  	VkSwapchainKHR oldSwapchain;
  } VkSwapchainCreateInfoKHR;
  typedef struct VkPresentInfoKHR{
  	VkStructureType sType;
  	void* pNext;
  	uint32_t waitSemaphoreCount;
  	VkSemaphore* pWaitSemaphores;
  	uint32_t swapchainCount;
  	VkSwapchainKHR* pSwapchains;
  	uint32_t* pImageIndices;
  	VkResult* pResults;
  } VkPresentInfoKHR;
  typedef struct VkDebugReportCallbackCreateInfoEXT{
  	VkStructureType sType;
  	void* pNext;
  	VkDebugReportFlagsEXT flags;
  	PFN_vkDebugReportCallbackEXT pfnCallback;
  	void* pUserData;
  } VkDebugReportCallbackCreateInfoEXT;
  typedef struct VkValidationFlagsEXT{
  	VkStructureType sType;
  	void* pNext;
  	uint32_t disabledValidationCheckCount;
  	VkValidationCheckEXT* pDisabledValidationChecks;
  } VkValidationFlagsEXT;
  typedef struct VkPipelineRasterizationStateRasterizationOrderAMD{
  	VkStructureType sType;
  	void* pNext;
  	VkRasterizationOrderAMD rasterizationOrder;
  } VkPipelineRasterizationStateRasterizationOrderAMD;
  typedef struct VkDebugMarkerObjectNameInfoEXT{
  	VkStructureType sType;
  	void* pNext;
  	VkDebugReportObjectTypeEXT objectType;
  	uint64_t object;
  	char* pObjectName;
  } VkDebugMarkerObjectNameInfoEXT;
  typedef struct VkDebugMarkerObjectTagInfoEXT{
  	VkStructureType sType;
  	void* pNext;
  	VkDebugReportObjectTypeEXT objectType;
  	uint64_t object;
  	uint64_t tagName;
  	size_t tagSize;
  	void* pTag;
  } VkDebugMarkerObjectTagInfoEXT;
  typedef struct VkDebugMarkerMarkerInfoEXT{
  	VkStructureType sType;
  	void* pNext;
  	char* pMarkerName;
  	float color[4];
  } VkDebugMarkerMarkerInfoEXT;
  typedef struct VkDedicatedAllocationImageCreateInfoNV{
  	VkStructureType sType;
  	void* pNext;
  	VkBool32 dedicatedAllocation;
  } VkDedicatedAllocationImageCreateInfoNV;
  typedef struct VkDedicatedAllocationBufferCreateInfoNV{
  	VkStructureType sType;
  	void* pNext;
  	VkBool32 dedicatedAllocation;
  } VkDedicatedAllocationBufferCreateInfoNV;
  typedef struct VkDedicatedAllocationMemoryAllocateInfoNV{
  	VkStructureType sType;
  	void* pNext;
  	VkImage image;
  	VkBuffer buffer;
  } VkDedicatedAllocationMemoryAllocateInfoNV;
  typedef struct VkExternalImageFormatPropertiesNV{
  	VkImageFormatProperties imageFormatProperties;
  	VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;
  	VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
  	VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
  } VkExternalImageFormatPropertiesNV;
  typedef struct VkExternalMemoryImageCreateInfoNV{
  	VkStructureType sType;
  	void* pNext;
  	VkExternalMemoryHandleTypeFlagsNV handleTypes;
  } VkExternalMemoryImageCreateInfoNV;
  typedef struct VkExportMemoryAllocateInfoNV{
  	VkStructureType sType;
  	void* pNext;
  	VkExternalMemoryHandleTypeFlagsNV handleTypes;
  } VkExportMemoryAllocateInfoNV;
  VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
  void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
  VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
  PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName);
  PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName);
  void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
  void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
  void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
  void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
  void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
  VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
  VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
  void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
  VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
  VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
  void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
  VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
  VkResult vkQueueWaitIdle(VkQueue queue);
  VkResult vkDeviceWaitIdle(VkDevice device);
  VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
  void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
  VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
  void vkUnmapMemory(VkDevice device, VkDeviceMemory memory);
  VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
  void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
  void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
  VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
  VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
  void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
  void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
  VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
  VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
  void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
  VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
  VkResult vkGetFenceStatus(VkDevice device, VkFence fence);
  VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
  VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
  void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
  void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
  VkResult vkGetEventStatus(VkDevice device, VkEvent event);
  VkResult vkSetEvent(VkDevice device, VkEvent event);
  VkResult vkResetEvent(VkDevice device, VkEvent event);
  VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
  void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
  VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
  VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
  void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
  void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
  void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
  void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
  VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
  void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
  void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
  void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
  VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
  VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
  VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
  void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
  void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
  void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
  void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
  void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
  VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
  VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
  VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
  void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
  VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
  void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
  VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
  void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
  void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
  VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
  void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
  VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
  VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
  void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
  VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer);
  VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
  void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
  void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
  void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
  void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
  void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
  void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
  void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
  void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
  void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
  void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
  void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
  void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
  void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
  void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
  void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
  void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
  void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
  void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
  void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
  void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
  void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
  void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
  void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
  void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
  void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
  void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
  void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
  void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
  void 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);
  void 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);
  void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
  void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
  void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
  void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
  void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
  void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
  void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
  void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
  void vkCmdEndRenderPass(VkCommandBuffer commandBuffer);
  void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
  typedef VkResult (*PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  typedef VkResult (*PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
  typedef VkResult (*PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
  typedef VkResult (*PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
  typedef VkResult (*PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
  typedef VkResult (*PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
  typedef VkResult (*PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
  typedef VkResult (*PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
  typedef VkResult (*PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
  typedef void (*PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
  typedef VkResult (*PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
  typedef VkResult (*PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
  typedef VkResult (*PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
  typedef VkResult (*PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);
  typedef VkResult (*PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
  typedef void (*PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
  typedef VkResult (*PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
  typedef VkResult (*PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
  typedef VkResult (*PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);
  typedef VkResult (*PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
  typedef void (*PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
  typedef void (*PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);
  typedef VkResult (*PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo);
  typedef VkResult (*PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo);
  typedef void (*PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  typedef void (*PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);
  typedef void (*PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
  typedef VkResult (*PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);
  typedef void (*PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  typedef void (*PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
  