text: /*
      Copyright (C) 2020 George Cave - gcave@stablecoder.ca
  
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
  
         http://www.apache.org/licenses/LICENSE-2.0
  
      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  */
  
  /*
      This file was auto-generated by the Vulkan mini-libs utility can be found at
      https://github.com/stablecoder/vulkan-mini-libs.git
      or
      https://git.stabletec.com/utilities/vulkan-mini-libs.git
  
      Check for an updated version anytime, or state concerns/bugs.
  */
  
  #ifndef VK_VALUE_SERIALIZATION_V184_HPP
  #define VK_VALUE_SERIALIZATION_V184_HPP
  
  /*  USAGE:
      To use, include this header where the declarations for the boolean checks are required.
  
      On *ONE* compilation unit, include the definition of `#define VK_VALUE_SERIALIZATION_CONFIG_MAIN`
      so that the definitions are compiled somewhere following the one definition rule.
  */
  
  #include <vulkan/vulkan.h>
  
  #include <string>
  #include <string_view>
  
  static_assert(VK_HEADER_VERSION == 184, "Incompatible VK_HEADER_VERSION!");
  
  /**
   * @brief Macro that automatically stringifies the given Vulkan type for serialization
   * @param VKTYPE Actual Vulkan type
   * @param VALUE Value to be serialized
   * @param STRPTR Pointer to the string to store the serialization in. Only modified if true is
   * returned.
   * @return True if serialization was successful. False otherwise.
   */
  #define VK_SERIALIZE(VKTYPE, VALUE, STRPTR) vk_serialize<VKTYPE>(#VKTYPE, VALUE, STRPTR)
  
  /**
   * @brief Macro that automatically stringifies the given Vulkan type for parsing
   * @param VKTYPE Actual Vulkan type
   * @param STRING String to be parsed
   * @param VALPTR Pointer to the value to store the parsed value in. Only modified if true is
   * returned.
   * @return True if serialization was successful. False otherwise.
   */
  #define VK_PARSE(VKTYPE, STRING, VALPTR) vk_parse<VKTYPE>(#VKTYPE, STRING, VALPTR)
  
  /**
   * @brief Serializes a Vulkan enumerator/flag type
   * @param vkType Name of the Vulkan enumerator/flag type
   * @param vkValue Value being serialized
   * @param pString Pointer to a string that will be modified with the serialized value. Only modified
   * if true is returned.
   * @return True the value was successfully serialized. False otherwise.
   */
  bool vk_serialize(std::string_view vkType, uint32_t vkValue, std::string *pString);
  
  /**
   * @brief Parses a Vulkan enumerator/flag serialized string
   * @param vkType Name of the Vulkan enumerator/flag type
   * @param vkString String being parsed
   * @param pValue Pointer to a value that will be modified with the parsed value. Only modified if
   * true is returned.
   * @return True the value was successfully serialized. False otherwise.
   */
  bool vk_parse(std::string_view vkType, std::string vkString, uint32_t *pValue);
  
  /**
   * @brief Serializes a Vulkan enumerator/flag type
   * @tparam Vulkan type being serialized
   * @param vkType Name of the Vulkan enumerator/flag type
   * @param vkValue Value being serialized
   * @param pString Pointer to a string that will be modified with the serialized value. Only modified
   * if true is returned.
   * @return True the value was successfully serialized. False otherwise.
   */
  template <typename T>
  bool vk_serialize(std::string_view vkType, T vkValue, std::string *pString) {
      return vk_serialize(vkType, static_cast<uint32_t>(vkValue), pString);
  }
  
  /**
   * @brief Parses a Vulkan enumerator/flag serialized string
   * @tparam Vulkan type being parsed
   * @param vkType Name of the Vulkan enumerator/flag type
   * @param vkString String being parsed
   * @param pValue Pointer to a value that will be modified with the parsed value. Only modified if
   * true is returned.
   * @return True the value was successfully serialized. False otherwise.
   */
  template <typename T>
  bool vk_parse(std::string_view vkType, std::string vkString, T *pValue) {
      uint32_t retVal = 0;
      auto found = vk_parse(vkType, vkString, &retVal);
      if (found) {
          *pValue = static_cast<T>(retVal);
      }
      return found;
  }
  
  #ifdef VK_VALUE_SERIALIZATION_CONFIG_MAIN
  
  #include <algorithm>
  #include <array>
  #include <cstring>
  #include <tuple>
  
  namespace {
  
  constexpr std::array<std::string_view, 35> vendors = {{
    "IMG",
    "AMD",
    "AMDX",
    "ARM",
    "FSL",
    "BRCM",
    "NXP",
    "NV",
    "NVX",
    "VIV",
    "VSI",
    "KDAB",
    "ANDROID",
    "CHROMIUM",
    "FUCHSIA",
    "GGP",
    "GOOGLE",
    "QCOM",
    "LUNARG",
    "SAMSUNG",
    "SEC",
    "TIZEN",
    "RENDERDOC",
    "NN",
    "MVK",
    "KHR",
    "KHX",
    "EXT",
    "MESA",
    "INTEL",
    "HUAWEI",
    "VALVE",
    "QNX",
    "JUICE",
    "FB",
  }};
  
  struct EnumValueSet {
      std::string_view name;
      int32_t value;
  };
  constexpr EnumValueSet VkImageLayoutSets[] = {
      {"UNDEFINED", 0},
      {"GENERAL", 1},
      {"COLOR_ATTACHMENT_OPTIMAL", 2},
      {"DEPTH_STENCIL_ATTACHMENT_OPTIMAL", 3},
      {"DEPTH_STENCIL_READ_ONLY_OPTIMAL", 4},
      {"SHADER_READ_ONLY_OPTIMAL", 5},
      {"TRANSFER_SRC_OPTIMAL", 6},
      {"TRANSFER_DST_OPTIMAL", 7},
      {"PREINITIALIZED", 8},
  };
  constexpr EnumValueSet VkAttachmentLoadOpSets[] = {
      {"LOAD", 0},
      {"CLEAR", 1},
      {"DONT_CARE", 2},
  };
  constexpr EnumValueSet VkAttachmentStoreOpSets[] = {
      {"STORE", 0},
      {"DONT_CARE", 1},
  };
  constexpr EnumValueSet VkImageTypeSets[] = {
      {"1D", 0},
      {"2D", 1},
      {"3D", 2},
  };
  constexpr EnumValueSet VkImageTilingSets[] = {
      {"OPTIMAL", 0},
      {"LINEAR", 1},
  };
  constexpr EnumValueSet VkImageViewTypeSets[] = {
      {"1D", 0},
      {"2D", 1},
      {"3D", 2},
      {"CUBE", 3},
      {"1D_ARRAY", 4},
      {"2D_ARRAY", 5},
      {"CUBE_ARRAY", 6},
  };
  constexpr EnumValueSet VkCommandBufferLevelSets[] = {
      {"PRIMARY", 0},
      {"SECONDARY", 1},
  };
  constexpr EnumValueSet VkComponentSwizzleSets[] = {
      {"IDENTITY", 0},
      {"ZERO", 1},
      {"ONE", 2},
      {"R", 3},
      {"G", 4},
      {"B", 5},
      {"A", 6},
  };
  constexpr EnumValueSet VkDescriptorTypeSets[] = {
      {"SAMPLER", 0},
      {"COMBINED_IMAGE_SAMPLER", 1},
      {"SAMPLED_IMAGE", 2},
      {"STORAGE_IMAGE", 3},
      {"UNIFORM_TEXEL_BUFFER", 4},
      {"STORAGE_TEXEL_BUFFER", 5},
      {"UNIFORM_BUFFER", 6},
      {"STORAGE_BUFFER", 7},
      {"UNIFORM_BUFFER_DYNAMIC", 8},
      {"STORAGE_BUFFER_DYNAMIC", 9},
      {"INPUT_ATTACHMENT", 10},
  };
  constexpr EnumValueSet VkQueryTypeSets[] = {
      {"OCCLUSION", 0},
      {"PIPELINE_STATISTICS", 1},
      {"TIMESTAMP", 2},
  };
  constexpr EnumValueSet VkBorderColorSets[] = {
      {"FLOAT_TRANSPARENT_BLACK", 0},
      {"INT_TRANSPARENT_BLACK", 1},
      {"FLOAT_OPAQUE_BLACK", 2},
      {"INT_OPAQUE_BLACK", 3},
      {"FLOAT_OPAQUE_WHITE", 4},
      {"INT_OPAQUE_WHITE", 5},
  };
  constexpr EnumValueSet VkPipelineBindPointSets[] = {
      {"GRAPHICS", 0},
      {"COMPUTE", 1},
  };
  constexpr EnumValueSet VkPipelineCacheHeaderVersionSets[] = {
      {"ONE", 1},
  };
  constexpr EnumValueSet VkPrimitiveTopologySets[] = {
      {"POINT_LIST", 0},
      {"LINE_LIST", 1},
      {"LINE_STRIP", 2},
      {"TRIANGLE_LIST", 3},
      {"TRIANGLE_STRIP", 4},
      {"TRIANGLE_FAN", 5},
      {"LINE_LIST_WITH_ADJACENCY", 6},
      {"LINE_STRIP_WITH_ADJACENCY", 7},
      {"TRIANGLE_LIST_WITH_ADJACENCY", 8},
      {"TRIANGLE_STRIP_WITH_ADJACENCY", 9},
      {"PATCH_LIST", 10},
  };
  constexpr EnumValueSet VkSharingModeSets[] = {
      {"EXCLUSIVE", 0},
      {"CONCURRENT", 1},
  };
  constexpr EnumValueSet VkIndexTypeSets[] = {
      {"UINT16", 0},
      {"UINT32", 1},
  };
  constexpr EnumValueSet VkFilterSets[] = {
      {"NEAREST", 0},
      {"LINEAR", 1},
  };
  constexpr EnumValueSet VkSamplerMipmapModeSets[] = {
      {"NEAREST", 0},
      {"LINEAR", 1},
  };
  constexpr EnumValueSet VkSamplerAddressModeSets[] = {
      {"REPEAT", 0},
      {"MIRRORED_REPEAT", 1},
      {"CLAMP_TO_EDGE", 2},
      {"CLAMP_TO_BORDER", 3},
  };
  constexpr EnumValueSet VkCompareOpSets[] = {
      {"NEVER", 0},
      {"LESS", 1},
      {"EQUAL", 2},
      {"LESS_OR_EQUAL", 3},
      {"GREATER", 4},
      {"NOT_EQUAL", 5},
      {"GREATER_OR_EQUAL", 6},
      {"ALWAYS", 7},
  };
  constexpr EnumValueSet VkPolygonModeSets[] = {
      {"FILL", 0},
      {"LINE", 1},
      {"POINT", 2},
  };
  constexpr EnumValueSet VkFrontFaceSets[] = {
      {"COUNTER_CLOCKWISE", 0},
      {"CLOCKWISE", 1},
  };
  constexpr EnumValueSet VkBlendFactorSets[] = {
      {"ZERO", 0},
      {"ONE", 1},
      {"SRC_COLOR", 2},
      {"ONE_MINUS_SRC_COLOR", 3},
      {"DST_COLOR", 4},
      {"ONE_MINUS_DST_COLOR", 5},
      {"SRC_ALPHA", 6},
      {"ONE_MINUS_SRC_ALPHA", 7},
      {"DST_ALPHA", 8},
      {"ONE_MINUS_DST_ALPHA", 9},
      {"CONSTANT_COLOR", 10},
      {"ONE_MINUS_CONSTANT_COLOR", 11},
      {"CONSTANT_ALPHA", 12},
      {"ONE_MINUS_CONSTANT_ALPHA", 13},
      {"SRC_ALPHA_SATURATE", 14},
      {"SRC1_COLOR", 15},
      {"ONE_MINUS_SRC1_COLOR", 16},
      {"SRC1_ALPHA", 17},
      {"ONE_MINUS_SRC1_ALPHA", 18},
  };
  constexpr EnumValueSet VkBlendOpSets[] = {
      {"ADD", 0},
      {"SUBTRACT", 1},
      {"REVERSE_SUBTRACT", 2},
      {"MIN", 3},
      {"MAX", 4},
  };
  constexpr EnumValueSet VkStencilOpSets[] = {
      {"KEEP", 0},
      {"ZERO", 1},
      {"REPLACE", 2},
      {"INCREMENT_AND_CLAMP", 3},
      {"DECREMENT_AND_CLAMP", 4},
      {"INVERT", 5},
      {"INCREMENT_AND_WRAP", 6},
      {"DECREMENT_AND_WRAP", 7},
  };
  constexpr EnumValueSet VkLogicOpSets[] = {
      {"CLEAR", 0},
      {"AND", 1},
      {"AND_REVERSE", 2},
      {"COPY", 3},
      {"AND_INVERTED", 4},
      {"NO_OP", 5},
      {"XOR", 6},
      {"OR", 7},
      {"NOR", 8},
      {"EQUIVALENT", 9},
      {"INVERT", 10},
      {"OR_REVERSE", 11},
      {"COPY_INVERTED", 12},
      {"OR_INVERTED", 13},
      {"NAND", 14},
      {"SET", 15},
  };
  constexpr EnumValueSet VkInternalAllocationTypeSets[] = {
      {"EXECUTABLE", 0},
  };
  constexpr EnumValueSet VkSystemAllocationScopeSets[] = {
      {"COMMAND", 0},
      {"OBJECT", 1},
      {"CACHE", 2},
      {"DEVICE", 3},
      {"INSTANCE", 4},
  };
  constexpr EnumValueSet VkPhysicalDeviceTypeSets[] = {
      {"OTHER", 0},
      {"INTEGRATED_GPU", 1},
      {"DISCRETE_GPU", 2},
      {"VIRTUAL_GPU", 3},
      {"CPU", 4},
  };
  constexpr EnumValueSet VkVertexInputRateSets[] = {
      {"VERTEX", 0},
      {"INSTANCE", 1},
  };
  constexpr EnumValueSet VkFormatSets[] = {
      {"UNDEFINED", 0},
      {"R4G4_UNORM_PACK8", 1},
      {"R4G4B4A4_UNORM_PACK16", 2},
      {"B4G4R4A4_UNORM_PACK16", 3},
      {"R5G6B5_UNORM_PACK16", 4},
      {"B5G6R5_UNORM_PACK16", 5},
      {"R5G5B5A1_UNORM_PACK16", 6},
      {"B5G5R5A1_UNORM_PACK16", 7},
      {"A1R5G5B5_UNORM_PACK16", 8},
      {"R8_UNORM", 9},
      {"R8_SNORM", 10},
      {"R8_USCALED", 11},
      {"R8_SSCALED", 12},
      {"R8_UINT", 13},
      {"R8_SINT", 14},
      {"R8_SRGB", 15},
      {"R8G8_UNORM", 16},
      {"R8G8_SNORM", 17},
      {"R8G8_USCALED", 18},
      {"R8G8_SSCALED", 19},
      {"R8G8_UINT", 20},
      {"R8G8_SINT", 21},
      {"R8G8_SRGB", 22},
      {"R8G8B8_UNORM", 23},
      {"R8G8B8_SNORM", 24},
      {"R8G8B8_USCALED", 25},
      {"R8G8B8_SSCALED", 26},
      {"R8G8B8_UINT", 27},
      {"R8G8B8_SINT", 28},
      {"R8G8B8_SRGB", 29},
      {"B8G8R8_UNORM", 30},
      {"B8G8R8_SNORM", 31},
      {"B8G8R8_USCALED", 32},
      {"B8G8R8_SSCALED", 33},
      {"B8G8R8_UINT", 34},
      {"B8G8R8_SINT", 35},
      {"B8G8R8_SRGB", 36},
      {"R8G8B8A8_UNORM", 37},
      {"R8G8B8A8_SNORM", 38},
      {"R8G8B8A8_USCALED", 39},
      {"R8G8B8A8_SSCALED", 40},
      {"R8G8B8A8_UINT", 41},
      {"R8G8B8A8_SINT", 42},
      {"R8G8B8A8_SRGB", 43},
      {"B8G8R8A8_UNORM", 44},
      {"B8G8R8A8_SNORM", 45},
      {"B8G8R8A8_USCALED", 46},
      {"B8G8R8A8_SSCALED", 47},
      {"B8G8R8A8_UINT", 48},
      {"B8G8R8A8_SINT", 49},
      {"B8G8R8A8_SRGB", 50},
      {"A8B8G8R8_UNORM_PACK32", 51},
      {"A8B8G8R8_SNORM_PACK32", 52},
      {"A8B8G8R8_USCALED_PACK32", 53},
      {"A8B8G8R8_SSCALED_PACK32", 54},
      {"A8B8G8R8_UINT_PACK32", 55},
      {"A8B8G8R8_SINT_PACK32", 56},
      {"A8B8G8R8_SRGB_PACK32", 57},
      {"A2R10G10B10_UNORM_PACK32", 58},
      {"A2R10G10B10_SNORM_PACK32", 59},
      {"A2R10G10B10_USCALED_PACK32", 60},
      {"A2R10G10B10_SSCALED_PACK32", 61},
      {"A2R10G10B10_UINT_PACK32", 62},
      {"A2R10G10B10_SINT_PACK32", 63},
      {"A2B10G10R10_UNORM_PACK32", 64},
      {"A2B10G10R10_SNORM_PACK32", 65},
      {"A2B10G10R10_USCALED_PACK32", 66},
      {"A2B10G10R10_SSCALED_PACK32", 67},
      {"A2B10G10R10_UINT_PACK32", 68},
      {"A2B10G10R10_SINT_PACK32", 69},
      {"R16_UNORM", 70},
      {"R16_SNORM", 71},
      {"R16_USCALED", 72},
      {"R16_SSCALED", 73},
      {"R16_UINT", 74},
      {"R16_SINT", 75},
      {"R16_SFLOAT", 76},
      {"R16G16_UNORM", 77},
      {"R16G16_SNORM", 78},
      {"R16G16_USCALED", 79},
      {"R16G16_SSCALED", 80},
      {"R16G16_UINT", 81},
      {"R16G16_SINT", 82},
      {"R16G16_SFLOAT", 83},
      {"R16G16B16_UNORM", 84},
      {"R16G16B16_SNORM", 85},
      {"R16G16B16_USCALED", 86},
      {"R16G16B16_SSCALED", 87},
      {"R16G16B16_UINT", 88},
      {"R16G16B16_SINT", 89},
      {"R16G16B16_SFLOAT", 90},
      {"R16G16B16A16_UNORM", 91},
      {"R16G16B16A16_SNORM", 92},
      {"R16G16B16A16_USCALED", 93},
      {"R16G16B16A16_SSCALED", 94},
      {"R16G16B16A16_UINT", 95},
      {"R16G16B16A16_SINT", 96},
      {"R16G16B16A16_SFLOAT", 97},
      {"R32_UINT", 98},
      {"R32_SINT", 99},
      {"R32_SFLOAT", 100},
      {"R32G32_UINT", 101},
      {"R32G32_SINT", 102},
      {"R32G32_SFLOAT", 103},
      {"R32G32B32_UINT", 104},
      {"R32G32B32_SINT", 105},
      {"R32G32B32_SFLOAT", 106},
      {"R32G32B32A32_UINT", 107},
      {"R32G32B32A32_SINT", 108},
      {"R32G32B32A32_SFLOAT", 109},
      {"R64_UINT", 110},
      {"R64_SINT", 111},
      {"R64_SFLOAT", 112},
      {"R64G64_UINT", 113},
      {"R64G64_SINT", 114},
      {"R64G64_SFLOAT", 115},
      {"R64G64B64_UINT", 116},
      {"R64G64B64_SINT", 117},
      {"R64G64B64_SFLOAT", 118},
      {"R64G64B64A64_UINT", 119},
      {"R64G64B64A64_SINT", 120},
      {"R64G64B64A64_SFLOAT", 121},
      {"B10G11R11_UFLOAT_PACK32", 122},
      {"E5B9G9R9_UFLOAT_PACK32", 123},
      {"D16_UNORM", 124},
      {"X8_D24_UNORM_PACK32", 125},
      {"D32_SFLOAT", 126},
      {"S8_UINT", 127},
      {"D16_UNORM_S8_UINT", 128},
      {"D24_UNORM_S8_UINT", 129},
      {"D32_SFLOAT_S8_UINT", 130},
      {"BC1_RGB_UNORM_BLOCK", 131},
      {"BC1_RGB_SRGB_BLOCK", 132},
      {"BC1_RGBA_UNORM_BLOCK", 133},
      {"BC1_RGBA_SRGB_BLOCK", 134},
      {"BC2_UNORM_BLOCK", 135},
      {"BC2_SRGB_BLOCK", 136},
      {"BC3_UNORM_BLOCK", 137},
      {"BC3_SRGB_BLOCK", 138},
      {"BC4_UNORM_BLOCK", 139},
      {"BC4_SNORM_BLOCK", 140},
      {"BC5_UNORM_BLOCK", 141},
      {"BC5_SNORM_BLOCK", 142},
      {"BC6H_UFLOAT_BLOCK", 143},
      {"BC6H_SFLOAT_BLOCK", 144},
      {"BC7_UNORM_BLOCK", 145},
      {"BC7_SRGB_BLOCK", 146},
      {"ETC2_R8G8B8_UNORM_BLOCK", 147},
      {"ETC2_R8G8B8_SRGB_BLOCK", 148},
      {"ETC2_R8G8B8A1_UNORM_BLOCK", 149},
      {"ETC2_R8G8B8A1_SRGB_BLOCK", 150},
      {"ETC2_R8G8B8A8_UNORM_BLOCK", 151},
      {"ETC2_R8G8B8A8_SRGB_BLOCK", 152},
      {"EAC_R11_UNORM_BLOCK", 153},
      {"EAC_R11_SNORM_BLOCK", 154},
      {"EAC_R11G11_UNORM_BLOCK", 155},
      {"EAC_R11G11_SNORM_BLOCK", 156},
      {"ASTC_4x4_UNORM_BLOCK", 157},
      {"ASTC_4x4_SRGB_BLOCK", 158},
      {"ASTC_5x4_UNORM_BLOCK", 159},
      {"ASTC_5x4_SRGB_BLOCK", 160},
      {"ASTC_5x5_UNORM_BLOCK", 161},
      {"ASTC_5x5_SRGB_BLOCK", 162},
      {"ASTC_6x5_UNORM_BLOCK", 163},
      {"ASTC_6x5_SRGB_BLOCK", 164},
      {"ASTC_6x6_UNORM_BLOCK", 165},
      {"ASTC_6x6_SRGB_BLOCK", 166},
      {"ASTC_8x5_UNORM_BLOCK", 167},
      {"ASTC_8x5_SRGB_BLOCK", 168},
      {"ASTC_8x6_UNORM_BLOCK", 169},
      {"ASTC_8x6_SRGB_BLOCK", 170},
      {"ASTC_8x8_UNORM_BLOCK", 171},
      {"ASTC_8x8_SRGB_BLOCK", 172},
      {"ASTC_10x5_UNORM_BLOCK", 173},
      {"ASTC_10x5_SRGB_BLOCK", 174},
      {"ASTC_10x6_UNORM_BLOCK", 175},
      {"ASTC_10x6_SRGB_BLOCK", 176},
      {"ASTC_10x8_UNORM_BLOCK", 177},
      {"ASTC_10x8_SRGB_BLOCK", 178},
      {"ASTC_10x10_UNORM_BLOCK", 179},
      {"ASTC_10x10_SRGB_BLOCK", 180},
      {"ASTC_12x10_UNORM_BLOCK", 181},
      {"ASTC_12x10_SRGB_BLOCK", 182},
      {"ASTC_12x12_UNORM_BLOCK", 183},
      {"ASTC_12x12_SRGB_BLOCK", 184},
  };
  constexpr EnumValueSet VkStructureTypeSets[] = {
      {"APPLICATION_INFO", 0},
      {"INSTANCE_CREATE_INFO", 1},
      {"DEVICE_QUEUE_CREATE_INFO", 2},
      {"DEVICE_CREATE_INFO", 3},
      {"SUBMIT_INFO", 4},
      {"MEMORY_ALLOCATE_INFO", 5},
      {"MAPPED_MEMORY_RANGE", 6},
      {"BIND_SPARSE_INFO", 7},
      {"FENCE_CREATE_INFO", 8},
      {"SEMAPHORE_CREATE_INFO", 9},
      {"EVENT_CREATE_INFO", 10},
      {"QUERY_POOL_CREATE_INFO", 11},
      {"BUFFER_CREATE_INFO", 12},
      {"BUFFER_VIEW_CREATE_INFO", 13},
      {"IMAGE_CREATE_INFO", 14},
      {"IMAGE_VIEW_CREATE_INFO", 15},
      {"SHADER_MODULE_CREATE_INFO", 16},
      {"PIPELINE_CACHE_CREATE_INFO", 17},
      {"PIPELINE_SHADER_STAGE_CREATE_INFO", 18},
      {"PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", 19},
      {"PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", 20},
      {"PIPELINE_TESSELLATION_STATE_CREATE_INFO", 21},
      {"PIPELINE_VIEWPORT_STATE_CREATE_INFO", 22},
      {"PIPELINE_RASTERIZATION_STATE_CREATE_INFO", 23},
      {"PIPELINE_MULTISAMPLE_STATE_CREATE_INFO", 24},
      {"PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO", 25},
      {"PIPELINE_COLOR_BLEND_STATE_CREATE_INFO", 26},
      {"PIPELINE_DYNAMIC_STATE_CREATE_INFO", 27},
      {"GRAPHICS_PIPELINE_CREATE_INFO", 28},
      {"COMPUTE_PIPELINE_CREATE_INFO", 29},
      {"PIPELINE_LAYOUT_CREATE_INFO", 30},
      {"SAMPLER_CREATE_INFO", 31},
      {"DESCRIPTOR_SET_LAYOUT_CREATE_INFO", 32},
      {"DESCRIPTOR_POOL_CREATE_INFO", 33},
      {"DESCRIPTOR_SET_ALLOCATE_INFO", 34},
      {"WRITE_DESCRIPTOR_SET", 35},
      {"COPY_DESCRIPTOR_SET", 36},
      {"FRAMEBUFFER_CREATE_INFO", 37},
      {"RENDER_PASS_CREATE_INFO", 38},
      {"COMMAND_POOL_CREATE_INFO", 39},
      {"COMMAND_BUFFER_ALLOCATE_INFO", 40},
      {"COMMAND_BUFFER_INHERITANCE_INFO", 41},
      {"COMMAND_BUFFER_BEGIN_INFO", 42},
      {"RENDER_PASS_BEGIN_INFO", 43},
      {"BUFFER_MEMORY_BARRIER", 44},
      {"IMAGE_MEMORY_BARRIER", 45},
      {"MEMORY_BARRIER", 46},
      {"LOADER_INSTANCE_CREATE_INFO", 47},
      {"LOADER_DEVICE_CREATE_INFO", 48},
  };
  constexpr EnumValueSet VkSubpassContentsSets[] = {
      {"INLINE", 0},
      {"SECONDARY_COMMAND_BUFFERS", 1},
  };
  constexpr EnumValueSet VkDynamicStateSets[] = {
      {"VIEWPORT", 0},
      {"SCISSOR", 1},
      {"LINE_WIDTH", 2},
      {"DEPTH_BIAS", 3},
      {"BLEND_CONSTANTS", 4},
      {"DEPTH_BOUNDS", 5},
      {"STENCIL_COMPARE_MASK", 6},
      {"STENCIL_WRITE_MASK", 7},
      {"STENCIL_REFERENCE", 8},
  };
  constexpr EnumValueSet VkDescriptorUpdateTemplateTypeSets[] = {
      {"DESCRIPTOR_SET", 0},
  };
  constexpr EnumValueSet VkObjectTypeSets[] = {
      {"UNKNOWN", 0},
      {"INSTANCE", 1},
      {"PHYSICAL_DEVICE", 2},
      {"DEVICE", 3},
      {"QUEUE", 4},
      {"SEMAPHORE", 5},
      {"COMMAND_BUFFER", 6},
      {"FENCE", 7},
      {"DEVICE_MEMORY", 8},
      {"BUFFER", 9},
      {"IMAGE", 10},
      {"EVENT", 11},
      {"QUERY_POOL", 12},
      {"BUFFER_VIEW", 13},
      {"IMAGE_VIEW", 14},
      {"SHADER_MODULE", 15},
      {"PIPELINE_CACHE", 16},
      {"PIPELINE_LAYOUT", 17},
      {"RENDER_PASS", 18},
      {"PIPELINE", 19},
      {"DESCRIPTOR_SET_LAYOUT", 20},
      {"SAMPLER", 21},
      {"DESCRIPTOR_POOL", 22},
      {"DESCRIPTOR_SET", 23},
      {"FRAMEBUFFER", 24},
      {"COMMAND_POOL", 25},
  };
  constexpr EnumValueSet VkQueueFlagBitsSets[] = {
      {"GRAPHICS", 0x00000001},
      {"COMPUTE", 0x00000002},
      {"TRANSFER", 0x00000004},
      {"SPARSE_BINDING", 0x00000008},
  };
  constexpr EnumValueSet VkCullModeFlagBitsSets[] = {
      {"NONE", 0},
      {"FRONT", 0x00000001},
      {"BACK", 0x00000002},
      {"FRONT_AND_BACK", 0x00000003},
  };
  constexpr EnumValueSet VkMemoryPropertyFlagBitsSets[] = {
      {"DEVICE_LOCAL", 0x00000001},
      {"HOST_VISIBLE", 0x00000002},
      {"HOST_COHERENT", 0x00000004},
      {"HOST_CACHED", 0x00000008},
      {"LAZILY_ALLOCATED", 0x00000010},
  };
  constexpr EnumValueSet VkMemoryHeapFlagBitsSets[] = {
      {"DEVICE_LOCAL", 0x00000001},
  };
  constexpr EnumValueSet VkAccessFlagBitsSets[] = {
      {"INDIRECT_COMMAND_READ", 0x00000001},
      {"INDEX_READ", 0x00000002},
      {"VERTEX_ATTRIBUTE_READ", 0x00000004},
      {"UNIFORM_READ", 0x00000008},
      {"INPUT_ATTACHMENT_READ", 0x00000010},
      {"SHADER_READ", 0x00000020},
      {"SHADER_WRITE", 0x00000040},
      {"COLOR_ATTACHMENT_READ", 0x00000080},
      {"COLOR_ATTACHMENT_WRITE", 0x00000100},
      {"DEPTH_STENCIL_ATTACHMENT_READ", 0x00000200},
      {"DEPTH_STENCIL_ATTACHMENT_WRITE", 0x00000400},
      {"TRANSFER_READ", 0x00000800},
      {"TRANSFER_WRITE", 0x00001000},
      {"HOST_READ", 0x00002000},
      {"HOST_WRITE", 0x00004000},
      {"MEMORY_READ", 0x00008000},
      {"MEMORY_WRITE", 0x00010000},
  };
  constexpr EnumValueSet VkBufferUsageFlagBitsSets[] = {
      {"TRANSFER_SRC", 0x00000001},
      {"TRANSFER_DST", 0x00000002},
      {"UNIFORM_TEXEL_BUFFER", 0x00000004},
      {"STORAGE_TEXEL_BUFFER", 0x00000008},
      {"UNIFORM_BUFFER", 0x00000010},
      {"STORAGE_BUFFER", 0x00000020},
      {"INDEX_BUFFER", 0x00000040},
      {"VERTEX_BUFFER", 0x00000080},
      {"INDIRECT_BUFFER", 0x00000100},
  };
  constexpr EnumValueSet VkBufferCreateFlagBitsSets[] = {
      {"SPARSE_BINDING", 0x00000001},
      {"SPARSE_RESIDENCY", 0x00000002},
      {"SPARSE_ALIASED", 0x00000004},
  };
  constexpr EnumValueSet VkShaderStageFlagBitsSets[] = {
      {"VERTEX", 0x00000001},
      {"TESSELLATION_CONTROL", 0x00000002},
      {"TESSELLATION_EVALUATION", 0x00000004},
      {"GEOMETRY", 0x00000008},
      {"FRAGMENT", 0x00000010},
      {"COMPUTE", 0x00000020},
      {"ALL_GRAPHICS", 0x0000001F},
      {"ALL", 0x7FFFFFFF},
  };
  constexpr EnumValueSet VkImageUsageFlagBitsSets[] = {
      {"TRANSFER_SRC", 0x00000001},
      {"TRANSFER_DST", 0x00000002},
      {"SAMPLED", 0x00000004},
      {"STORAGE", 0x00000008},
      {"COLOR_ATTACHMENT", 0x00000010},
      {"DEPTH_STENCIL_ATTACHMENT", 0x00000020},
      {"TRANSIENT_ATTACHMENT", 0x00000040},
      {"INPUT_ATTACHMENT", 0x00000080},
  };
  constexpr EnumValueSet VkImageCreateFlagBitsSets[] = {
      {"SPARSE_BINDING", 0x00000001},
      {"SPARSE_RESIDENCY", 0x00000002},
      {"SPARSE_ALIASED", 0x00000004},
      {"MUTABLE_FORMAT", 0x00000008},
      {"CUBE_COMPATIBLE", 0x00000010},
  };
  constexpr EnumValueSet VkPipelineCreateFlagBitsSets[] = {
      {"DISABLE_OPTIMIZATION", 0x00000001},
      {"ALLOW_DERIVATIVES", 0x00000002},
      {"DERIVATIVE", 0x00000004},
  };
  constexpr EnumValueSet VkColorComponentFlagBitsSets[] = {
      {"R", 0x00000001},
      {"G", 0x00000002},
      {"B", 0x00000004},
      {"A", 0x00000008},
  };
  constexpr EnumValueSet VkFenceCreateFlagBitsSets[] = {
      {"SIGNALED", 0x00000001},
  };
  constexpr EnumValueSet VkFormatFeatureFlagBitsSets[] = {
      {"SAMPLED_IMAGE", 0x00000001},
      {"STORAGE_IMAGE", 0x00000002},
      {"STORAGE_IMAGE_ATOMIC", 0x00000004},
      {"UNIFORM_TEXEL_BUFFER", 0x00000008},
      {"STORAGE_TEXEL_BUFFER", 0x00000010},
      {"STORAGE_TEXEL_BUFFER_ATOMIC", 0x00000020},
      {"VERTEX_BUFFER", 0x00000040},
      {"COLOR_ATTACHMENT", 0x00000080},
      {"COLOR_ATTACHMENT_BLEND", 0x00000100},
      {"DEPTH_STENCIL_ATTACHMENT", 0x00000200},
      {"BLIT_SRC", 0x00000400},
      {"BLIT_DST", 0x00000800},
      {"SAMPLED_IMAGE_FILTER_LINEAR", 0x00001000},
  };
  constexpr EnumValueSet VkQueryControlFlagBitsSets[] = {
      {"PRECISE", 0x00000001},
  };
  constexpr EnumValueSet VkQueryResultFlagBitsSets[] = {
      {"64", 0x00000001},
      {"WAIT", 0x00000002},
      {"WITH_AVAILABILITY", 0x00000004},
      {"PARTIAL", 0x00000008},
  };
  constexpr EnumValueSet VkCommandBufferUsageFlagBitsSets[] = {
      {"ONE_TIME_SUBMIT", 0x00000001},
      {"RENDER_PASS_CONTINUE", 0x00000002},
      {"SIMULTANEOUS_USE", 0x00000004},
  };
  constexpr EnumValueSet VkQueryPipelineStatisticFlagBitsSets[] = {
      {"INPUT_ASSEMBLY_VERTICES", 0x00000001},
      {"INPUT_ASSEMBLY_PRIMITIVES", 0x00000002},
      {"VERTEX_SHADER_INVOCATIONS", 0x00000004},
      {"GEOMETRY_SHADER_INVOCATIONS", 0x00000008},
      {"GEOMETRY_SHADER_PRIMITIVES", 0x00000010},
      {"CLIPPING_INVOCATIONS", 0x00000020},
      {"CLIPPING_PRIMITIVES", 0x00000040},
      {"FRAGMENT_SHADER_INVOCATIONS", 0x00000080},
      {"TESSELLATION_CONTROL_SHADER_PATCHES", 0x00000100},
      {"TESSELLATION_EVALUATION_SHADER_INVOCATIONS", 0x00000200},
      {"COMPUTE_SHADER_INVOCATIONS", 0x00000400},
  };
  constexpr EnumValueSet VkImageAspectFlagBitsSets[] = {
      {"COLOR", 0x00000001},
      {"DEPTH", 0x00000002},
      {"STENCIL", 0x00000004},
      {"METADATA", 0x00000008},
  };
  constexpr EnumValueSet VkSparseImageFormatFlagBitsSets[] = {
      {"SINGLE_MIPTAIL", 0x00000001},
      {"ALIGNED_MIP_SIZE", 0x00000002},
      {"NONSTANDARD_BLOCK_SIZE", 0x00000004},
  };
  constexpr EnumValueSet VkSparseMemoryBindFlagBitsSets[] = {
      {"METADATA", 0x00000001},
  };
  constexpr EnumValueSet VkPipelineStageFlagBitsSets[] = {
      {"TOP_OF_PIPE", 0x00000001},
      {"DRAW_INDIRECT", 0x00000002},
      {"VERTEX_INPUT", 0x00000004},
      {"VERTEX_SHADER", 0x00000008},
      {"TESSELLATION_CONTROL_SHADER", 0x00000010},
      {"TESSELLATION_EVALUATION_SHADER", 0x00000020},
      {"GEOMETRY_SHADER", 0x00000040},
      {"FRAGMENT_SHADER", 0x00000080},
      {"EARLY_FRAGMENT_TESTS", 0x00000100},
      {"LATE_FRAGMENT_TESTS", 0x00000200},
      {"COLOR_ATTACHMENT_OUTPUT", 0x00000400},
      {"COMPUTE_SHADER", 0x00000800},
      {"TRANSFER", 0x00001000},
      {"BOTTOM_OF_PIPE", 0x00002000},
      {"HOST", 0x00004000},
      {"ALL_GRAPHICS", 0x00008000},
      {"ALL_COMMANDS", 0x00010000},
  };
  constexpr EnumValueSet VkCommandPoolCreateFlagBitsSets[] = {
      {"TRANSIENT", 0x00000001},
      {"RESET_COMMAND_BUFFER", 0x00000002},
  };
  constexpr EnumValueSet VkCommandPoolResetFlagBitsSets[] = {
      {"RELEASE_RESOURCES", 0x00000001},
  };
  constexpr EnumValueSet VkCommandBufferResetFlagBitsSets[] = {
      {"RELEASE_RESOURCES", 0x00000001},
  };
  constexpr EnumValueSet VkSampleCountFlagBitsSets[] = {
      {"1", 0x00000001},
      {"2", 0x00000002},
      {"4", 0x00000004},
      {"8", 0x00000008},
      {"16", 0x00000010},
      {"32", 0x00000020},
      {"64", 0x00000040},
  };
  constexpr EnumValueSet VkAttachmentDescriptionFlagBitsSets[] = {
      {"MAY_ALIAS", 0x00000001},
  };
  constexpr EnumValueSet VkStencilFaceFlagBitsSets[] = {
      {"FRONT", 0x00000001},
      {"BACK", 0x00000002},
      {"FRONT_AND_BACK", 0x00000003},
      {"VK_STENCIL_FRONT_AND_BACK", 0x00000003},
  };
  constexpr EnumValueSet VkDescriptorPoolCreateFlagBitsSets[] = {
      {"FREE_DESCRIPTOR_SET", 0x00000001},
  };
  constexpr EnumValueSet VkDependencyFlagBitsSets[] = {
      {"BY_REGION", 0x00000001},
  };
  constexpr EnumValueSet VkSemaphoreTypeSets[] = {
      {"BINARY", 0},
      {"TIMELINE", 1},
  };
  constexpr EnumValueSet VkSemaphoreWaitFlagBitsSets[] = {
      {"ANY", 0x00000001},
  };
  constexpr EnumValueSet VkPresentModeKHRSets[] = {
      {"IMMEDIATE", 0},
      {"MAILBOX", 1},
      {"FIFO", 2},
      {"FIFO_RELAXED", 3},
  };
  constexpr EnumValueSet VkColorSpaceKHRSets[] = {
      {"SRGB_NONLINEAR", 0},
      {"VK_COLORSPACE_SRGB_NONLINEAR", 0},
  };
  constexpr EnumValueSet VkDisplayPlaneAlphaFlagBitsKHRSets[] = {
      {"OPAQUE", 0x00000001},
      {"GLOBAL", 0x00000002},
      {"PER_PIXEL", 0x00000004},
      {"PER_PIXEL_PREMULTIPLIED", 0x00000008},
  };
  constexpr EnumValueSet VkCompositeAlphaFlagBitsKHRSets[] = {
      {"OPAQUE", 0x00000001},
      {"PRE_MULTIPLIED", 0x00000002},
      {"POST_MULTIPLIED", 0x00000004},
      {"INHERIT", 0x00000008},
  };
  constexpr EnumValueSet VkSurfaceTransformFlagBitsKHRSets[] = {
      {"IDENTITY", 0x00000001},
      {"ROTATE_90", 0x00000002},
      {"ROTATE_180", 0x00000004},
      {"ROTATE_270", 0x00000008},
      {"HORIZONTAL_MIRROR", 0x00000010},
      {"HORIZONTAL_MIRROR_ROTATE_90", 0x00000020},
      {"HORIZONTAL_MIRROR_ROTATE_180", 0x00000040},
      {"HORIZONTAL_MIRROR_ROTATE_270", 0x00000080},
      {"INHERIT", 0x00000100},
  };
  constexpr EnumValueSet VkSwapchainImageUsageFlagBitsANDROIDSets[] = {
      {"SHARED", 0x00000001},
  };
  constexpr EnumValueSet VkTimeDomainEXTSets[] = {
      {"DEVICE", 0},
      {"CLOCK_MONOTONIC", 1},
      {"CLOCK_MONOTONIC_RAW", 2},
      {"QUERY_PERFORMANCE_COUNTER", 3},
  };
  constexpr EnumValueSet VkDebugReportFlagBitsEXTSets[] = {
      {"INFORMATION", 0x00000001},
      {"WARNING", 0x00000002},
      {"PERFORMANCE_WARNING", 0x00000004},
      {"ERROR", 0x00000008},
      {"DEBUG", 0x00000010},
  };
  constexpr EnumValueSet VkDebugReportObjectTypeEXTSets[] = {
      {"UNKNOWN", 0},
      {"INSTANCE", 1},
      {"PHYSICAL_DEVICE", 2},
      {"DEVICE", 3},
      {"QUEUE", 4},
      {"SEMAPHORE", 5},
      {"COMMAND_BUFFER", 6},
      {"FENCE", 7},
      {"DEVICE_MEMORY", 8},
      {"BUFFER", 9},
      {"IMAGE", 10},
      {"EVENT", 11},
      {"QUERY_POOL", 12},
      {"BUFFER_VIEW", 13},
      {"IMAGE_VIEW", 14},
      {"SHADER_MODULE", 15},
      {"PIPELINE_CACHE", 16},
      {"PIPELINE_LAYOUT", 17},
      {"RENDER_PASS", 18},
      {"PIPELINE", 19},
      {"DESCRIPTOR_SET_LAYOUT", 20},
      {"SAMPLER", 21},
      {"DESCRIPTOR_POOL", 22},
      {"DESCRIPTOR_SET", 23},
      {"FRAMEBUFFER", 24},
      {"COMMAND_POOL", 25},
      {"SURFACE_KHR", 26},
      {"SWAPCHAIN_KHR", 27},
      {"DEBUG_REPORT_CALLBACK_EXT", 28},
      {"DEBUG_REPORT", 28},
      {"DISPLAY_KHR", 29},
      {"DISPLAY_MODE_KHR", 30},
      {"VALIDATION_CACHE_EXT", 33},
      {"VALIDATION_CACHE", 33},
  };
  constexpr EnumValueSet VkDeviceMemoryReportEventTypeEXTSets[] = {
      {"ALLOCATE", 0},
      {"FREE", 1},
      {"IMPORT", 2},
      {"UNIMPORT", 3},
      {"ALLOCATION_FAILED", 4},
  };
  constexpr EnumValueSet VkRasterizationOrderAMDSets[] = {
      {"STRICT", 0},
      {"RELAXED", 1},
  };
  constexpr EnumValueSet VkExternalMemoryHandleTypeFlagBitsNVSets[] = {
      {"OPAQUE_WIN32", 0x00000001},
      {"OPAQUE_WIN32_KMT", 0x00000002},
      {"D3D11_IMAGE", 0x00000004},
      {"D3D11_IMAGE_KMT", 0x00000008},
  };
  constexpr EnumValueSet VkExternalMemoryFeatureFlagBitsNVSets[] = {
      {"DEDICATED_ONLY", 0x00000001},
      {"EXPORTABLE", 0x00000002},
      {"IMPORTABLE", 0x00000004},
  };
  constexpr EnumValueSet VkValidationCheckEXTSets[] = {
      {"ALL", 0},
      {"SHADERS", 1},
  };
  constexpr EnumValueSet VkValidationFeatureEnableEXTSets[] = {
      {"GPU_ASSISTED", 0},
      {"GPU_ASSISTED_RESERVE_BINDING_SLOT", 1},
      {"BEST_PRACTICES", 2},
      {"DEBUG_PRINTF", 3},
      {"SYNCHRONIZATION_VALIDATION", 4},
  };
  constexpr EnumValueSet VkValidationFeatureDisableEXTSets[] = {
      {"ALL", 0},
      {"SHADERS", 1},
      {"THREAD_SAFETY", 2},
      {"API_PARAMETERS", 3},
      {"OBJECT_LIFETIMES", 4},
      {"CORE_CHECKS", 5},
      {"UNIQUE_HANDLES", 6},
      {"SHADER_VALIDATION_CACHE", 7},
  };
  constexpr EnumValueSet VkSubgroupFeatureFlagBitsSets[] = {
      {"BASIC", 0x00000001},
      {"VOTE", 0x00000002},
      {"ARITHMETIC", 0x00000004},
      {"BALLOT", 0x00000008},
      {"SHUFFLE", 0x00000010},
      {"SHUFFLE_RELATIVE", 0x00000020},
      {"CLUSTERED", 0x00000040},
      {"QUAD", 0x00000080},
  };
  constexpr EnumValueSet VkIndirectCommandsLayoutUsageFlagBitsNVSets[] = {
      {"EXPLICIT_PREPROCESS", 0x00000001},
      {"INDEXED_SEQUENCES", 0x00000002},
      {"UNORDERED_SEQUENCES", 0x00000004},
  };
  constexpr EnumValueSet VkIndirectStateFlagBitsNVSets[] = {
      {"FLAG_FRONTFACE", 0x00000001},
  };
  constexpr EnumValueSet VkIndirectCommandsTokenTypeNVSets[] = {
      {"SHADER_GROUP", 0},
      {"STATE_FLAGS", 1},
      {"INDEX_BUFFER", 2},
      {"VERTEX_BUFFER", 3},
      {"PUSH_CONSTANT", 4},
      {"DRAW_INDEXED", 5},
      {"DRAW", 6},
      {"DRAW_TASKS", 7},
  };
  constexpr EnumValueSet VkExternalMemoryHandleTypeFlagBitsSets[] = {
      {"OPAQUE_FD", 0x00000001},
      {"OPAQUE_WIN32", 0x00000002},
      {"OPAQUE_WIN32_KMT", 0x00000004},
      {"D3D11_TEXTURE", 0x00000008},
      {"D3D11_TEXTURE_KMT", 0x00000010},
      {"D3D12_HEAP", 0x00000020},
      {"D3D12_RESOURCE", 0x00000040},
  };
  constexpr EnumValueSet VkExternalMemoryFeatureFlagBitsSets[] = {
      {"DEDICATED_ONLY", 0x00000001},
      {"EXPORTABLE", 0x00000002},
      {"IMPORTABLE", 0x00000004},
  };
  constexpr EnumValueSet VkExternalSemaphoreHandleTypeFlagBitsSets[] = {
      {"OPAQUE_FD", 0x00000001},
      {"OPAQUE_WIN32", 0x00000002},
      {"OPAQUE_WIN32_KMT", 0x00000004},
      {"D3D12_FENCE", 0x00000008},
      {"D3D11_FENCE", 0x00000008},
      {"SYNC_FD", 0x00000010},
  };
  constexpr EnumValueSet VkExternalSemaphoreFeatureFlagBitsSets[] = {
      {"EXPORTABLE", 0x00000001},
      {"IMPORTABLE", 0x00000002},
  };
  constexpr EnumValueSet VkSemaphoreImportFlagBitsSets[] = {
      {"TEMPORARY", 0x00000001},
  };
  constexpr EnumValueSet VkExternalFenceHandleTypeFlagBitsSets[] = {
      {"OPAQUE_FD", 0x00000001},
      {"OPAQUE_WIN32", 0x00000002},
      {"OPAQUE_WIN32_KMT", 0x00000004},
      {"SYNC_FD", 0x00000008},
  };
  constexpr EnumValueSet VkExternalFenceFeatureFlagBitsSets[] = {
      {"EXPORTABLE", 0x00000001},
      {"IMPORTABLE", 0x00000002},
  };
  constexpr EnumValueSet VkFenceImportFlagBitsSets[] = {
      {"TEMPORARY", 0x00000001},
  };
  constexpr EnumValueSet VkSurfaceCounterFlagBitsEXTSets[] = {
      {"VBLANK", 0x00000001},
      {"VBLANK", 0x00000001},
  };
  constexpr EnumValueSet VkDisplayPowerStateEXTSets[] = {
      {"OFF", 0},
      {"SUSPEND", 1},
      {"ON", 2},
  };
  constexpr EnumValueSet VkDeviceEventTypeEXTSets[] = {
      {"DISPLAY_HOTPLUG", 0},
  };
  constexpr EnumValueSet VkDisplayEventTypeEXTSets[] = {
      {"FIRST_PIXEL_OUT", 0},
  };
  constexpr EnumValueSet VkPeerMemoryFeatureFlagBitsSets[] = {
      {"COPY_SRC", 0x00000001},
      {"COPY_DST", 0x00000002},
      {"GENERIC_SRC", 0x00000004},
      {"GENERIC_DST", 0x00000008},
  };
  constexpr EnumValueSet VkMemoryAllocateFlagBitsSets[] = {
      {"DEVICE_MASK", 0x00000001},
  };
  constexpr EnumValueSet VkDeviceGroupPresentModeFlagBitsKHRSets[] = {
      {"LOCAL", 0x00000001},
      {"REMOTE", 0x00000002},
      {"SUM", 0x00000004},
      {"LOCAL_MULTI_DEVICE", 0x00000008},
  };
  constexpr EnumValueSet VkViewportCoordinateSwizzleNVSets[] = {
      {"POSITIVE_X", 0},
      {"NEGATIVE_X", 1},
      {"POSITIVE_Y", 2},
      {"NEGATIVE_Y", 3},
      {"POSITIVE_Z", 4},
      {"NEGATIVE_Z", 5},
      {"POSITIVE_W", 6},
      {"NEGATIVE_W", 7},
  };
  constexpr EnumValueSet VkDiscardRectangleModeEXTSets[] = {
      {"INCLUSIVE", 0},
      {"EXCLUSIVE", 1},
  };
  constexpr EnumValueSet VkPointClippingBehaviorSets[] = {
      {"ALL_CLIP_PLANES", 0},
      {"USER_CLIP_PLANES_ONLY", 1},
  };
  constexpr EnumValueSet VkSamplerReductionModeSets[] = {
      {"WEIGHTED_AVERAGE", 0},
      {"MIN", 1},
      {"MAX", 2},
  };
  constexpr EnumValueSet VkTessellationDomainOriginSets[] = {
      {"UPPER_LEFT", 0},
      {"LOWER_LEFT", 1},
  };
  constexpr EnumValueSet VkSamplerYcbcrModelConversionSets[] = {
      {"RGB_IDENTITY", 0},
      {"YCBCR_IDENTITY", 1},
      {"YCBCR_709", 2},
      {"YCBCR_601", 3},
      {"YCBCR_2020", 4},
  };
  constexpr EnumValueSet VkSamplerYcbcrRangeSets[] = {
      {"ITU_FULL", 0},
      {"ITU_NARROW", 1},
  };
  constexpr EnumValueSet VkChromaLocationSets[] = {
      {"COSITED_EVEN", 0},
      {"MIDPOINT", 1},
  };
  constexpr EnumValueSet VkBlendOverlapEXTSets[] = {
      {"UNCORRELATED", 0},
      {"DISJOINT", 1},
      {"CONJOINT", 2},
  };
  constexpr EnumValueSet VkCoverageModulationModeNVSets[] = {
      {"NONE", 0},
      {"RGB", 1},
      {"ALPHA", 2},
      {"RGBA", 3},
  };
  constexpr EnumValueSet VkCoverageReductionModeNVSets[] = {
      {"MERGE", 0},
      {"TRUNCATE", 1},
  };
  constexpr EnumValueSet VkValidationCacheHeaderVersionEXTSets[] = {
      {"ONE", 1},
  };
  constexpr EnumValueSet VkShaderInfoTypeAMDSets[] = {
      {"STATISTICS", 0},
      {"BINARY", 1},
      {"DISASSEMBLY", 2},
  };
  constexpr EnumValueSet VkQueueGlobalPriorityEXTSets[] = {
      {"LOW", 128},
      {"MEDIUM", 256},
      {"HIGH", 512},
      {"REALTIME", 1024},
  };
  constexpr EnumValueSet VkDebugUtilsMessageSeverityFlagBitsEXTSets[] = {
      {"VERBOSE", 0x00000001},
      {"INFO", 0x00000010},
      {"WARNING", 0x00000100},
      {"ERROR", 0x00001000},
  };
  constexpr EnumValueSet VkDebugUtilsMessageTypeFlagBitsEXTSets[] = {
      {"GENERAL", 0x00000001},
      {"VALIDATION", 0x00000002},
      {"PERFORMANCE", 0x00000004},
  };
  constexpr EnumValueSet VkConservativeRasterizationModeEXTSets[] = {
      {"DISABLED", 0},
      {"OVERESTIMATE", 1},
      {"UNDERESTIMATE", 2},
  };
  constexpr EnumValueSet VkDescriptorBindingFlagBitsSets[] = {
      {"UPDATE_AFTER_BIND", 0x00000001},
      {"UPDATE_UNUSED_WHILE_PENDING", 0x00000002},
      {"PARTIALLY_BOUND", 0x00000004},
      {"VARIABLE_DESCRIPTOR_COUNT", 0x00000008},
  };
  constexpr EnumValueSet VkVendorIdSets[] = {
      {"VIV", 0x10001},
      {"VSI", 0x10002},
      {"KAZAN", 0x10003},
      {"CODEPLAY", 0x10004},
      {"MESA", 0x10005},
      {"POCL", 0x10006},
  };
  constexpr EnumValueSet VkDriverIdSets[] = {
      {"AMD_PROPRIETARY", 1},
      {"AMD_OPEN_SOURCE", 2},
      {"MESA_RADV", 3},
      {"NVIDIA_PROPRIETARY", 4},
      {"INTEL_PROPRIETARY_WINDOWS", 5},
      {"INTEL_OPEN_SOURCE", 6},
      {"IMAGINATION_PROPRIETARY", 7},
      {"QUALCOMM_PROPRIETARY", 8},
      {"ARM_PROPRIETARY", 9},
      {"GOOGLE_SWIFTSHADER", 10},
      {"GGP_PROPRIETARY", 11},
      {"BROADCOM_PROPRIETARY", 12},
      {"MESA_LLVMPIPE", 13},
      {"MOLTENVK", 14},
      {"COREAVI_PROPRIETARY", 15},
      {"JUICE_PROPRIETARY", 16},
  };
  constexpr EnumValueSet VkConditionalRenderingFlagBitsEXTSets[] = {
      {"INVERTED", 0x00000001},
  };
  constexpr EnumValueSet VkResolveModeFlagBitsSets[] = {
      {"NONE", 0},
      {"SAMPLE_ZERO", 0x00000001},
      {"AVERAGE", 0x00000002},
      {"MIN", 0x00000004},
      {"MAX", 0x00000008},
  };
  constexpr EnumValueSet VkShadingRatePaletteEntryNVSets[] = {
      {"NO_INVOCATIONS", 0},
      {"16_INVOCATIONS_PER_PIXEL", 1},
      {"8_INVOCATIONS_PER_PIXEL", 2},
      {"4_INVOCATIONS_PER_PIXEL", 3},
      {"2_INVOCATIONS_PER_PIXEL", 4},
      {"1_INVOCATION_PER_PIXEL", 5},
      {"1_INVOCATION_PER_2X1_PIXELS", 6},
      {"1_INVOCATION_PER_1X2_PIXELS", 7},
      {"1_INVOCATION_PER_2X2_PIXELS", 8},
      {"1_INVOCATION_PER_4X2_PIXELS", 9},
      {"1_INVOCATION_PER_2X4_PIXELS", 10},
      {"1_INVOCATION_PER_4X4_PIXELS", 11},
  };
  constexpr EnumValueSet VkCoarseSampleOrderTypeNVSets[] = {
      {"DEFAULT", 0},
      {"CUSTOM", 1},
      {"PIXEL_MAJOR", 2},
      {"SAMPLE_MAJOR", 3},
  };
  constexpr EnumValueSet VkGeometryInstanceFlagBitsKHRSets[] = {
      {"TRIANGLE_FACING_CULL_DISABLE", 0x00000001},
      {"TRIANGLE_FRONT_COUNTERCLOCKWISE", 0x00000002},
      {"FORCE_OPAQUE", 0x00000004},
      {"FORCE_NO_OPAQUE", 0x00000008},
  };
  constexpr EnumValueSet VkGeometryFlagBitsKHRSets[] = {
      {"OPAQUE", 0x00000001},
      {"NO_DUPLICATE_ANY_HIT_INVOCATION", 0x00000002},
  };
  constexpr EnumValueSet VkBuildAccelerationStructureFlagBitsKHRSets[] = {
      {"ALLOW_UPDATE", 0x00000001},
      {"ALLOW_COMPACTION", 0x00000002},
      {"PREFER_FAST_TRACE", 0x00000004},
      {"PREFER_FAST_BUILD", 0x00000008},
      {"LOW_MEMORY", 0x00000010},
  };
  constexpr EnumValueSet VkAccelerationStructureCreateFlagBitsKHRSets[] = {
      {"DEVICE_ADDRESS_CAPTURE_REPLAY", 0x00000001},
  };
  constexpr EnumValueSet VkCopyAccelerationStructureModeKHRSets[] = {
      {"CLONE", 0},
      {"COMPACT", 1},
      {"SERIALIZE", 2},
      {"DESERIALIZE", 3},
  };
  constexpr EnumValueSet VkBuildAccelerationStructureModeKHRSets[] = {
      {"BUILD", 0},
      {"UPDATE", 1},
  };
  constexpr EnumValueSet VkAccelerationStructureTypeKHRSets[] = {
      {"TOP_LEVEL", 0},
      {"BOTTOM_LEVEL", 1},
      {"GENERIC", 2},
  };
  constexpr EnumValueSet VkGeometryTypeKHRSets[] = {
      {"TRIANGLES", 0},
      {"AABBS", 1},
      {"INSTANCES", 2},
  };
  constexpr EnumValueSet VkAccelerationStructureMemoryRequirementsTypeNVSets[] = {
      {"OBJECT", 0},
      {"BUILD_SCRATCH", 1},
      {"UPDATE_SCRATCH", 2},
  };
  constexpr EnumValueSet VkAccelerationStructureBuildTypeKHRSets[] = {
      {"HOST", 0},
      {"DEVICE", 1},
      {"HOST_OR_DEVICE", 2},
  };
  constexpr EnumValueSet VkRayTracingShaderGroupTypeKHRSets[] = {
      {"GENERAL", 0},
      {"TRIANGLES_HIT_GROUP", 1},
      {"PROCEDURAL_HIT_GROUP", 2},
  };
  constexpr EnumValueSet VkAccelerationStructureCompatibilityKHRSets[] = {
      {"COMPATIBLE", 0},
      {"INCOMPATIBLE", 1},
  };
  constexpr EnumValueSet VkShaderGroupShaderKHRSets[] = {
      {"GENERAL", 0},
      {"CLOSEST_HIT", 1},
      {"ANY_HIT", 2},
      {"INTERSECTION", 3},
  };
  constexpr EnumValueSet VkMemoryOverallocationBehaviorAMDSets[] = {
      {"DEFAULT", 0},
      {"ALLOWED", 1},
      {"DISALLOWED", 2},
  };
  constexpr EnumValueSet VkScopeNVSets[] = {
      {"DEVICE", 1},
      {"WORKGROUP", 2},
      {"SUBGROUP", 3},
      {"QUEUE_FAMILY", 5},
  };
  constexpr EnumValueSet VkComponentTypeNVSets[] = {
      {"FLOAT16", 0},
      {"FLOAT32", 1},
      {"FLOAT64", 2},
      {"SINT8", 3},
      {"SINT16", 4},
      {"SINT32", 5},
      {"SINT64", 6},
      {"UINT8", 7},
      {"UINT16", 8},
      {"UINT32", 9},
      {"UINT64", 10},
  };
  constexpr EnumValueSet VkDeviceDiagnosticsConfigFlagBitsNVSets[] = {
      {"ENABLE_SHADER_DEBUG_INFO", 0x00000001},
      {"ENABLE_RESOURCE_TRACKING", 0x00000002},
      {"ENABLE_AUTOMATIC_CHECKPOINTS", 0x00000004},
  };
  constexpr EnumValueSet VkPipelineCreationFeedbackFlagBitsEXTSets[] = {
      {"VALID", 0x00000001},
      {"APPLICATION_PIPELINE_CACHE_HIT", 0x00000002},
      {"BASE_PIPELINE_ACCELERATION", 0x00000004},
  };
  constexpr EnumValueSet VkFullScreenExclusiveEXTSets[] = {
      {"DEFAULT", 0},
      {"ALLOWED", 1},
      {"DISALLOWED", 2},
      {"APPLICATION_CONTROLLED", 3},
  };
  constexpr EnumValueSet VkPerformanceCounterScopeKHRSets[] = {
      {"COMMAND_BUFFER", 0},
      {"RENDER_PASS", 1},
      {"COMMAND", 2},
      {"VK_QUERY_SCOPE_COMMAND_BUFFER", 0},
      {"VK_QUERY_SCOPE_RENDER_PASS", 1},
      {"VK_QUERY_SCOPE_COMMAND", 2},
  };
  constexpr EnumValueSet VkPerformanceCounterUnitKHRSets[] = {
      {"GENERIC", 0},
      {"PERCENTAGE", 1},
      {"NANOSECONDS", 2},
      {"BYTES", 3},
      {"BYTES_PER_SECOND", 4},
      {"KELVIN", 5},
      {"WATTS", 6},
      {"VOLTS", 7},
      {"AMPS", 8},
      {"HERTZ", 9},
      {"CYCLES", 10},
  };
  constexpr EnumValueSet VkPerformanceCounterStorageKHRSets[] = {
      {"INT32", 0},
      {"INT64", 1},
      {"UINT32", 2},
      {"UINT64", 3},
      {"FLOAT32", 4},
      {"FLOAT64", 5},
  };
  constexpr EnumValueSet VkPerformanceCounterDescriptionFlagBitsKHRSets[] = {
      {"PERFORMANCE_IMPACTING", 0x00000001},
      {"PERFORMANCE_IMPACTING", 0x00000001},
      {"CONCURRENTLY_IMPACTED", 0x00000002},
      {"CONCURRENTLY_IMPACTED", 0x00000002},
  };
  constexpr EnumValueSet VkPerformanceConfigurationTypeINTELSets[] = {
      {"COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED", 0},
  };
  constexpr EnumValueSet VkQueryPoolSamplingModeINTELSets[] = {
      {"MANUAL", 0},
  };
  constexpr EnumValueSet VkPerformanceOverrideTypeINTELSets[] = {
      {"NULL_HARDWARE", 0},
      {"FLUSH_GPU_CACHES", 1},
  };
  constexpr EnumValueSet VkPerformanceParameterTypeINTELSets[] = {
      {"HW_COUNTERS_SUPPORTED", 0},
      {"STREAM_MARKER_VALID_BITS", 1},
  };
  constexpr EnumValueSet VkPerformanceValueTypeINTELSets[] = {
      {"UINT32", 0},
      {"UINT64", 1},
      {"FLOAT", 2},
      {"BOOL", 3},
      {"STRING", 4},
  };
  constexpr EnumValueSet VkShaderFloatControlsIndependenceSets[] = {
      {"32_BIT_ONLY", 0},
      {"ALL", 1},
      {"NONE", 2},
  };
  constexpr EnumValueSet VkPipelineExecutableStatisticFormatKHRSets[] = {
      {"BOOL32", 0},
      {"INT64", 1},
      {"UINT64", 2},
      {"FLOAT64", 3},
  };
  constexpr EnumValueSet VkLineRasterizationModeEXTSets[] = {
      {"DEFAULT", 0},
      {"RECTANGULAR", 1},
      {"BRESENHAM", 2},
      {"RECTANGULAR_SMOOTH", 3},
  };
  constexpr EnumValueSet VkToolPurposeFlagBitsEXTSets[] = {
      {"VALIDATION", 0x00000001},
      {"PROFILING", 0x00000002},
      {"TRACING", 0x00000004},
      {"ADDITIONAL_FEATURES", 0x00000008},
      {"MODIFYING_FEATURES", 0x00000010},
  };
  constexpr EnumValueSet VkFragmentShadingRateCombinerOpKHRSets[] = {
      {"KEEP", 0},
      {"REPLACE", 1},
      {"MIN", 2},
      {"MAX", 3},
      {"MUL", 4},
  };
  constexpr EnumValueSet VkFragmentShadingRateNVSets[] = {
      {"1_INVOCATION_PER_PIXEL", 0},
      {"1_INVOCATION_PER_1X2_PIXELS", 1},
      {"1_INVOCATION_PER_2X1_PIXELS", 4},
      {"1_INVOCATION_PER_2X2_PIXELS", 5},
      {"1_INVOCATION_PER_2X4_PIXELS", 6},
      {"1_INVOCATION_PER_4X2_PIXELS", 9},
      {"1_INVOCATION_PER_4X4_PIXELS", 10},
      {"2_INVOCATIONS_PER_PIXEL", 11},
      {"4_INVOCATIONS_PER_PIXEL", 12},
      {"8_INVOCATIONS_PER_PIXEL", 13},
      {"16_INVOCATIONS_PER_PIXEL", 14},
      {"NO_INVOCATIONS", 15},
  };
  constexpr EnumValueSet VkFragmentShadingRateTypeNVSets[] = {
      {"FRAGMENT_SIZE", 0},
      {"ENUMS", 1},
  };
  constexpr EnumValueSet VkAccessFlagBits2KHRSets[] = {
      {"VK_ACCESS_2_NONE", 0},
      {"VK_ACCESS_2_INDIRECT_COMMAND_READ", 0x00000001},
      {"VK_ACCESS_2_INDEX_READ", 0x00000002},
      {"VK_ACCESS_2_VERTEX_ATTRIBUTE_READ", 0x00000004},
      {"VK_ACCESS_2_UNIFORM_READ", 0x00000008},
      {"VK_ACCESS_2_INPUT_ATTACHMENT_READ", 0x00000010},
      {"VK_ACCESS_2_SHADER_READ", 0x00000020},
      {"VK_ACCESS_2_SHADER_WRITE", 0x00000040},
      {"VK_ACCESS_2_COLOR_ATTACHMENT_READ", 0x00000080},
      {"VK_ACCESS_2_COLOR_ATTACHMENT_WRITE", 0x00000100},
      {"VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ", 0x00000200},
      {"VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE", 0x00000400},
      {"VK_ACCESS_2_TRANSFER_READ", 0x00000800},
      {"VK_ACCESS_2_TRANSFER_WRITE", 0x00001000},
      {"VK_ACCESS_2_HOST_READ", 0x00002000},
      {"VK_ACCESS_2_HOST_WRITE", 0x00004000},
      {"VK_ACCESS_2_MEMORY_READ", 0x00008000},
      {"VK_ACCESS_2_MEMORY_WRITE", 0x00010000},
      {"VK_ACCESS_2_SHADER_SAMPLED_READ", 0x00000001},
      {"VK_ACCESS_2_SHADER_STORAGE_READ", 0x00000002},
      {"VK_ACCESS_2_SHADER_STORAGE_WRITE", 0x00000004},
  };
  constexpr EnumValueSet VkPipelineStageFlagBits2KHRSets[] = {
      {"VK_PIPELINE_STAGE_2_NONE", 0},
      {"VK_PIPELINE_STAGE_2_TOP_OF_PIPE", 0x00000001},
      {"VK_PIPELINE_STAGE_2_DRAW_INDIRECT", 0x00000002},
      {"VK_PIPELINE_STAGE_2_VERTEX_INPUT", 0x00000004},
      {"VK_PIPELINE_STAGE_2_VERTEX_SHADER", 0x00000008},
      {"VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER", 0x00000010},
      {"VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER", 0x00000020},
      {"VK_PIPELINE_STAGE_2_GEOMETRY_SHADER", 0x00000040},
      {"VK_PIPELINE_STAGE_2_FRAGMENT_SHADER", 0x00000080},
      {"VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS", 0x00000100},
      {"VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS", 0x00000200},
      {"VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT", 0x00000400},
      {"VK_PIPELINE_STAGE_2_COMPUTE_SHADER", 0x00000800},
      {"VK_PIPELINE_STAGE_2_ALL_TRANSFER", 0x00001000},
      {"VK_PIPELINE_STAGE_2_TRANSFER", 0x00001000},
      {"VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE", 0x00002000},
      {"VK_PIPELINE_STAGE_2_HOST", 0x00004000},
      {"VK_PIPELINE_STAGE_2_ALL_GRAPHICS", 0x00008000},
      {"VK_PIPELINE_STAGE_2_ALL_COMMANDS", 0x00010000},
      {"VK_PIPELINE_STAGE_2_COPY", 0x00000001},
      {"VK_PIPELINE_STAGE_2_RESOLVE", 0x00000002},
      {"VK_PIPELINE_STAGE_2_BLIT", 0x00000004},
      {"VK_PIPELINE_STAGE_2_CLEAR", 0x00000008},
      {"VK_PIPELINE_STAGE_2_INDEX_INPUT", 0x00000010},
      {"VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT", 0x00000020},
      {"VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS", 0x00000040},
  };
  constexpr EnumValueSet VkSubmitFlagBitsKHRSets[] = {
      {"PROTECTED", 0x00000001},
  };
  constexpr EnumValueSet VkProvokingVertexModeEXTSets[] = {
      {"FIRST_VERTEX", 0},
      {"LAST_VERTEX", 1},
  };
  constexpr EnumValueSet VkAccelerationStructureMotionInstanceTypeNVSets[] = {
      {"STATIC", 0},
      {"MATRIX_MOTION", 1},
      {"SRT_MOTION", 2},
  };
  constexpr EnumValueSet VkVideoCodecOperationFlagBitsKHRSets[] = {
      {"INVALID", 0},
  };
  constexpr EnumValueSet VkVideoChromaSubsamplingFlagBitsKHRSets[] = {
      {"INVALID", 0},
      {"MONOCHROME", 0x00000001},
      {"420", 0x00000002},
      {"422", 0x00000004},
      {"444", 0x00000008},
  };
  constexpr EnumValueSet VkVideoComponentBitDepthFlagBitsKHRSets[] = {
      {"INVALID", 0},
      {"8", 0x00000001},
      {"10", 0x00000004},
      {"12", 0x00000010},
  };
  constexpr EnumValueSet VkVideoCapabilitiesFlagBitsKHRSets[] = {
      {"PROTECTED_CONTENT", 0x00000001},
      {"SEPARATE_REFERENCE_IMAGES", 0x00000002},
  };
  constexpr EnumValueSet VkVideoSessionCreateFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"PROTECTED_CONTENT", 0x00000001},
  };
  constexpr EnumValueSet VkVideoCodingQualityPresetFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"NORMAL", 0x00000001},
      {"POWER", 0x00000002},
      {"QUALITY", 0x00000004},
  };
  constexpr EnumValueSet VkVideoDecodeH264FieldLayoutFlagBitsEXTSets[] = {
      {"VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY", 0},
      {"LINE_INTERLACED_PLANE", 0x00000001},
      {"SEPARATE_INTERLACED_PLANE", 0x00000002},
  };
  constexpr EnumValueSet VkVideoCodingControlFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"RESET", 0x00000001},
  };
  constexpr EnumValueSet VkQueryResultStatusKHRSets[] = {
      {"ERROR", -1},
      {"NOT_READY", 0},
      {"COMPLETE", 1},
  };
  constexpr EnumValueSet VkVideoDecodeFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"RESERVED_0", 0x00000001},
  };
  constexpr EnumValueSet VkVideoEncodeFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"RESERVED_0", 0x00000001},
  };
  constexpr EnumValueSet VkVideoEncodeRateControlFlagBitsKHRSets[] = {
      {"DEFAULT", 0},
      {"RESET", 0x00000001},
  };
  constexpr EnumValueSet VkVideoEncodeRateControlModeFlagBitsKHRSets[] = {
      {"NONE", 0},
      {"CBR", 1},
      {"VBR", 2},
  };
  constexpr EnumValueSet VkVideoEncodeH264CapabilitiesFlagBitsEXTSets[] = {
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC", 0x00000001},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC", 0x00000002},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT", 0x00000004},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8", 0x00000008},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET", 0x00000010},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET", 0x00000020},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED", 0x00000040},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED", 0x00000080},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL", 0x00000100},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME", 0x00000200},
      {"VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE", 0x00000400},
  };
  constexpr EnumValueSet VkVideoEncodeH264InputModeFlagBitsEXTSets[] = {
      {"FRAME", 0x00000001},
      {"SLICE", 0x00000002},
      {"NON_VCL", 0x00000004},
  };
  constexpr EnumValueSet VkVideoEncodeH264OutputModeFlagBitsEXTSets[] = {
      {"FRAME", 0x00000001},
      {"SLICE", 0x00000002},
      {"NON_VCL", 0x00000004},
  };
  constexpr EnumValueSet VkVideoEncodeH264CreateFlagBitsEXTSets[] = {
      {"DEFAULT", 0},
      {"RESERVED_0", 0x00000001},
  };
  
  struct EnumType {
      std::string_view name;
      EnumValueSet const* data;
      uint32_t count;
  };
  
  constexpr std::array<EnumType, 201> enumTypes = {{
    {"VkImageLayout", VkImageLayoutSets, 9},
    {"VkAttachmentLoadOp", VkAttachmentLoadOpSets, 3},
    {"VkAttachmentStoreOp", VkAttachmentStoreOpSets, 2},
    {"VkImageType", VkImageTypeSets, 3},
    {"VkImageTiling", VkImageTilingSets, 2},
    {"VkImageViewType", VkImageViewTypeSets, 7},
    {"VkCommandBufferLevel", VkCommandBufferLevelSets, 2},
    {"VkComponentSwizzle", VkComponentSwizzleSets, 7},
    {"VkDescriptorType", VkDescriptorTypeSets, 11},
    {"VkQueryType", VkQueryTypeSets, 3},
    {"VkBorderColor", VkBorderColorSets, 6},
    {"VkPipelineBindPoint", VkPipelineBindPointSets, 2},
    {"VkPipelineCacheHeaderVersion", VkPipelineCacheHeaderVersionSets, 1},
    {"VkPipelineCacheCreateFlagBits", nullptr, 0},
    {"VkPrimitiveTopology", VkPrimitiveTopologySets, 11},
    {"VkSharingMode", VkSharingModeSets, 2},
    {"VkIndexType", VkIndexTypeSets, 2},
    {"VkFilter", VkFilterSets, 2},
    {"VkSamplerMipmapMode", VkSamplerMipmapModeSets, 2},
    {"VkSamplerAddressMode", VkSamplerAddressModeSets, 4},
    {"VkCompareOp", VkCompareOpSets, 8},
    {"VkPolygonMode", VkPolygonModeSets, 3},
    {"VkFrontFace", VkFrontFaceSets, 2},
    {"VkBlendFactor", VkBlendFactorSets, 19},
    {"VkBlendOp", VkBlendOpSets, 5},
    {"VkStencilOp", VkStencilOpSets, 8},
    {"VkLogicOp", VkLogicOpSets, 16},
    {"VkInternalAllocationType", VkInternalAllocationTypeSets, 1},
    {"VkSystemAllocationScope", VkSystemAllocationScopeSets, 5},
    {"VkPhysicalDeviceType", VkPhysicalDeviceTypeSets, 5},
    {"VkVertexInputRate", VkVertexInputRateSets, 2},
    {"VkFormat", VkFormatSets, 185},
    {"VkStructureType", VkStructureTypeSets, 49},
    {"VkSubpassContents", VkSubpassContentsSets, 2},
    {"VkDynamicState", VkDynamicStateSets, 9},
    {"VkDescriptorUpdateTemplateType", VkDescriptorUpdateTemplateTypeSets, 1},
    {"VkObjectType", VkObjectTypeSets, 26},
    {"VkQueueFlagBits", VkQueueFlagBitsSets, 4},
    {"VkCullModeFlagBits", VkCullModeFlagBitsSets, 4},
    {"VkRenderPassCreateFlagBits", nullptr, 0},
    {"VkDeviceQueueCreateFlagBits", nullptr, 0},
    {"VkMemoryPropertyFlagBits", VkMemoryPropertyFlagBitsSets, 5},
    {"VkMemoryHeapFlagBits", VkMemoryHeapFlagBitsSets, 1},
    {"VkAccessFlagBits", VkAccessFlagBitsSets, 17},
    {"VkBufferUsageFlagBits", VkBufferUsageFlagBitsSets, 9},
    {"VkBufferCreateFlagBits", VkBufferCreateFlagBitsSets, 3},
    {"VkShaderStageFlagBits", VkShaderStageFlagBitsSets, 8},
    {"VkImageUsageFlagBits", VkImageUsageFlagBitsSets, 8},
    {"VkImageCreateFlagBits", VkImageCreateFlagBitsSets, 5},
    {"VkImageViewCreateFlagBits", nullptr, 0},
    {"VkSamplerCreateFlagBits", nullptr, 0},
    {"VkPipelineCreateFlagBits", VkPipelineCreateFlagBitsSets, 3},
    {"VkPipelineShaderStageCreateFlagBits", nullptr, 0},
    {"VkColorComponentFlagBits", VkColorComponentFlagBitsSets, 4},
    {"VkFenceCreateFlagBits", VkFenceCreateFlagBitsSets, 1},
    {"VkFormatFeatureFlagBits", VkFormatFeatureFlagBitsSets, 13},
    {"VkQueryControlFlagBits", VkQueryControlFlagBitsSets, 1},
    {"VkQueryResultFlagBits", VkQueryResultFlagBitsSets, 4},
    {"VkCommandBufferUsageFlagBits", VkCommandBufferUsageFlagBitsSets, 3},
    {"VkQueryPipelineStatisticFlagBits", VkQueryPipelineStatisticFlagBitsSets, 11},
    {"VkImageAspectFlagBits", VkImageAspectFlagBitsSets, 4},
    {"VkSparseImageFormatFlagBits", VkSparseImageFormatFlagBitsSets, 3},
    {"VkSparseMemoryBindFlagBits", VkSparseMemoryBindFlagBitsSets, 1},
    {"VkPipelineStageFlagBits", VkPipelineStageFlagBitsSets, 17},
    {"VkCommandPoolCreateFlagBits", VkCommandPoolCreateFlagBitsSets, 2},
    {"VkCommandPoolResetFlagBits", VkCommandPoolResetFlagBitsSets, 1},
    {"VkCommandBufferResetFlagBits", VkCommandBufferResetFlagBitsSets, 1},
    {"VkSampleCountFlagBits", VkSampleCountFlagBitsSets, 7},
    {"VkAttachmentDescriptionFlagBits", VkAttachmentDescriptionFlagBitsSets, 1},
    {"VkStencilFaceFlagBits", VkStencilFaceFlagBitsSets, 4},
    {"VkDescriptorPoolCreateFlagBits", VkDescriptorPoolCreateFlagBitsSets, 1},
    {"VkDependencyFlagBits", VkDependencyFlagBitsSets, 1},
    {"VkSemaphoreType", VkSemaphoreTypeSets, 2},
    {"VkSemaphoreWaitFlagBits", VkSemaphoreWaitFlagBitsSets, 1},
    {"VkPresentModeKHR", VkPresentModeKHRSets, 4},
    {"VkColorSpaceKHR", VkColorSpaceKHRSets, 2},
    {"VkDisplayPlaneAlphaFlagBitsKHR", VkDisplayPlaneAlphaFlagBitsKHRSets, 4},
    {"VkCompositeAlphaFlagBitsKHR", VkCompositeAlphaFlagBitsKHRSets, 4},
    {"VkSurfaceTransformFlagBitsKHR", VkSurfaceTransformFlagBitsKHRSets, 9},
    {"VkSwapchainImageUsageFlagBitsANDROID", VkSwapchainImageUsageFlagBitsANDROIDSets, 1},
    {"VkTimeDomainEXT", VkTimeDomainEXTSets, 4},
    {"VkDebugReportFlagBitsEXT", VkDebugReportFlagBitsEXTSets, 5},
    {"VkDebugReportObjectTypeEXT", VkDebugReportObjectTypeEXTSets, 34},
    {"VkDeviceMemoryReportEventTypeEXT", VkDeviceMemoryReportEventTypeEXTSets, 5},
    {"VkRasterizationOrderAMD", VkRasterizationOrderAMDSets, 2},
    {"VkExternalMemoryHandleTypeFlagBitsNV", VkExternalMemoryHandleTypeFlagBitsNVSets, 4},
    {"VkExternalMemoryFeatureFlagBitsNV", VkExternalMemoryFeatureFlagBitsNVSets, 3},
    {"VkValidationCheckEXT", VkValidationCheckEXTSets, 2},
    {"VkValidationFeatureEnableEXT", VkValidationFeatureEnableEXTSets, 5},
    {"VkValidationFeatureDisableEXT", VkValidationFeatureDisableEXTSets, 8},
    {"VkSubgroupFeatureFlagBits", VkSubgroupFeatureFlagBitsSets, 8},
    {"VkIndirectCommandsLayoutUsageFlagBitsNV", VkIndirectCommandsLayoutUsageFlagBitsNVSets, 3},
    {"VkIndirectStateFlagBitsNV", VkIndirectStateFlagBitsNVSets, 1},
    {"VkIndirectCommandsTokenTypeNV", VkIndirectCommandsTokenTypeNVSets, 8},
    {"VkPrivateDataSlotCreateFlagBitsEXT", nullptr, 0},
    {"VkDescriptorSetLayoutCreateFlagBits", nullptr, 0},
    {"VkExternalMemoryHandleTypeFlagBits", VkExternalMemoryHandleTypeFlagBitsSets, 7},
    {"VkExternalMemoryFeatureFlagBits", VkExternalMemoryFeatureFlagBitsSets, 3},
    {"VkExternalSemaphoreHandleTypeFlagBits", VkExternalSemaphoreHandleTypeFlagBitsSets, 6},
    {"VkExternalSemaphoreFeatureFlagBits", VkExternalSemaphoreFeatureFlagBitsSets, 2},
    {"VkSemaphoreImportFlagBits", VkSemaphoreImportFlagBitsSets, 1},
    {"VkExternalFenceHandleTypeFlagBits", VkExternalFenceHandleTypeFlagBitsSets, 4},
    {"VkExternalFenceFeatureFlagBits", VkExternalFenceFeatureFlagBitsSets, 2},
    {"VkFenceImportFlagBits", VkFenceImportFlagBitsSets, 1},
    {"VkSurfaceCounterFlagBitsEXT", VkSurfaceCounterFlagBitsEXTSets, 2},
    {"VkDisplayPowerStateEXT", VkDisplayPowerStateEXTSets, 3},
    {"VkDeviceEventTypeEXT", VkDeviceEventTypeEXTSets, 1},
    {"VkDisplayEventTypeEXT", VkDisplayEventTypeEXTSets, 1},
    {"VkPeerMemoryFeatureFlagBits", VkPeerMemoryFeatureFlagBitsSets, 4},
    {"VkMemoryAllocateFlagBits", VkMemoryAllocateFlagBitsSets, 1},
    {"VkDeviceGroupPresentModeFlagBitsKHR", VkDeviceGroupPresentModeFlagBitsKHRSets, 4},
    {"VkSwapchainCreateFlagBitsKHR", nullptr, 0},
    {"VkViewportCoordinateSwizzleNV", VkViewportCoordinateSwizzleNVSets, 8},
    {"VkDiscardRectangleModeEXT", VkDiscardRectangleModeEXTSets, 2},
    {"VkSubpassDescriptionFlagBits", nullptr, 0},
    {"VkPointClippingBehavior", VkPointClippingBehaviorSets, 2},
    {"VkSamplerReductionMode", VkSamplerReductionModeSets, 3},
    {"VkTessellationDomainOrigin", VkTessellationDomainOriginSets, 2},
    {"VkSamplerYcbcrModelConversion", VkSamplerYcbcrModelConversionSets, 5},
    {"VkSamplerYcbcrRange", VkSamplerYcbcrRangeSets, 2},
    {"VkChromaLocation", VkChromaLocationSets, 2},
    {"VkBlendOverlapEXT", VkBlendOverlapEXTSets, 3},
    {"VkCoverageModulationModeNV", VkCoverageModulationModeNVSets, 4},
    {"VkCoverageReductionModeNV", VkCoverageReductionModeNVSets, 2},
    {"VkValidationCacheHeaderVersionEXT", VkValidationCacheHeaderVersionEXTSets, 1},
    {"VkShaderInfoTypeAMD", VkShaderInfoTypeAMDSets, 3},
    {"VkQueueGlobalPriorityEXT", VkQueueGlobalPriorityEXTSets, 4},
    {"VkDebugUtilsMessageSeverityFlagBitsEXT", VkDebugUtilsMessageSeverityFlagBitsEXTSets, 4},
    {"VkDebugUtilsMessageTypeFlagBitsEXT", VkDebugUtilsMessageTypeFlagBitsEXTSets, 3},
    {"VkConservativeRasterizationModeEXT", VkConservativeRasterizationModeEXTSets, 3},
    {"VkDescriptorBindingFlagBits", VkDescriptorBindingFlagBitsSets, 4},
    {"VkVendorId", VkVendorIdSets, 6},
    {"VkDriverId", VkDriverIdSets, 16},
    {"VkConditionalRenderingFlagBitsEXT", VkConditionalRenderingFlagBitsEXTSets, 1},
    {"VkResolveModeFlagBits", VkResolveModeFlagBitsSets, 5},
    {"VkShadingRatePaletteEntryNV", VkShadingRatePaletteEntryNVSets, 12},
    {"VkCoarseSampleOrderTypeNV", VkCoarseSampleOrderTypeNVSets, 4},
    {"VkGeometryInstanceFlagBitsKHR", VkGeometryInstanceFlagBitsKHRSets, 4},
    {"VkGeometryFlagBitsKHR", VkGeometryFlagBitsKHRSets, 2},
    {"VkBuildAccelerationStructureFlagBitsKHR", VkBuildAccelerationStructureFlagBitsKHRSets, 5},
    {"VkAccelerationStructureCreateFlagBitsKHR", VkAccelerationStructureCreateFlagBitsKHRSets, 1},
    {"VkCopyAccelerationStructureModeKHR", VkCopyAccelerationStructureModeKHRSets, 4},
    {"VkBuildAccelerationStructureModeKHR", VkBuildAccelerationStructureModeKHRSets, 2},
    {"VkAccelerationStructureTypeKHR", VkAccelerationStructureTypeKHRSets, 3},
    {"VkGeometryTypeKHR", VkGeometryTypeKHRSets, 3},
    {"VkAccelerationStructureMemoryRequirementsTypeNV", VkAccelerationStructureMemoryRequirementsTypeNVSets, 3},
    {"VkAccelerationStructureBuildTypeKHR", VkAccelerationStructureBuildTypeKHRSets, 3},
    {"VkRayTracingShaderGroupTypeKHR", VkRayTracingShaderGroupTypeKHRSets, 3},
    {"VkAccelerationStructureCompatibilityKHR", VkAccelerationStructureCompatibilityKHRSets, 2},
    {"VkShaderGroupShaderKHR", VkShaderGroupShaderKHRSets, 4},
    {"VkMemoryOverallocationBehaviorAMD", VkMemoryOverallocationBehaviorAMDSets, 3},
    {"VkFramebufferCreateFlagBits", nullptr, 0},
    {"VkScopeNV", VkScopeNVSets, 4},
    {"VkComponentTypeNV", VkComponentTypeNVSets, 11},
    {"VkDeviceDiagnosticsConfigFlagBitsNV", VkDeviceDiagnosticsConfigFlagBitsNVSets, 3},
    {"VkPipelineCreationFeedbackFlagBitsEXT", VkPipelineCreationFeedbackFlagBitsEXTSets, 3},
    {"VkFullScreenExclusiveEXT", VkFullScreenExclusiveEXTSets, 4},
    {"VkPerformanceCounterScopeKHR", VkPerformanceCounterScopeKHRSets, 6},
    {"VkPerformanceCounterUnitKHR", VkPerformanceCounterUnitKHRSets, 11},
    {"VkPerformanceCounterStorageKHR", VkPerformanceCounterStorageKHRSets, 6},
    {"VkPerformanceCounterDescriptionFlagBitsKHR", VkPerformanceCounterDescriptionFlagBitsKHRSets, 4},
    {"VkAcquireProfilingLockFlagBitsKHR", nullptr, 0},
    {"VkShaderCorePropertiesFlagBitsAMD", nullptr, 0},
    {"VkPerformanceConfigurationTypeINTEL", VkPerformanceConfigurationTypeINTELSets, 1},
    {"VkQueryPoolSamplingModeINTEL", VkQueryPoolSamplingModeINTELSets, 1},
    {"VkPerformanceOverrideTypeINTEL", VkPerformanceOverrideTypeINTELSets, 2},
    {"VkPerformanceParameterTypeINTEL", VkPerformanceParameterTypeINTELSets, 2},
    {"VkPerformanceValueTypeINTEL", VkPerformanceValueTypeINTELSets, 5},
    {"VkShaderFloatControlsIndependence", VkShaderFloatControlsIndependenceSets, 3},
    {"VkPipelineExecutableStatisticFormatKHR", VkPipelineExecutableStatisticFormatKHRSets, 4},
    {"VkLineRasterizationModeEXT", VkLineRasterizationModeEXTSets, 4},
    {"VkShaderModuleCreateFlagBits", nullptr, 0},
    {"VkPipelineCompilerControlFlagBitsAMD", nullptr, 0},
    {"VkToolPurposeFlagBitsEXT", VkToolPurposeFlagBitsEXTSets, 5},
    {"VkFragmentShadingRateCombinerOpKHR", VkFragmentShadingRateCombinerOpKHRSets, 5},
    {"VkFragmentShadingRateNV", VkFragmentShadingRateNVSets, 12},
    {"VkFragmentShadingRateTypeNV", VkFragmentShadingRateTypeNVSets, 2},
    {"VkAccessFlagBits2KHR", VkAccessFlagBits2KHRSets, 21},
    {"VkPipelineStageFlagBits2KHR", VkPipelineStageFlagBits2KHRSets, 26},
    {"VkSubmitFlagBitsKHR", VkSubmitFlagBitsKHRSets, 1},
    {"VkEventCreateFlagBits", nullptr, 0},
    {"VkPipelineLayoutCreateFlagBits", nullptr, 0},
    {"VkProvokingVertexModeEXT", VkProvokingVertexModeEXTSets, 2},
    {"VkAccelerationStructureMotionInstanceTypeNV", VkAccelerationStructureMotionInstanceTypeNVSets, 3},
    {"VkVideoCodecOperationFlagBitsKHR", VkVideoCodecOperationFlagBitsKHRSets, 1},
    {"VkVideoChromaSubsamplingFlagBitsKHR", VkVideoChromaSubsamplingFlagBitsKHRSets, 5},
    {"VkVideoComponentBitDepthFlagBitsKHR", VkVideoComponentBitDepthFlagBitsKHRSets, 4},
    {"VkVideoCapabilitiesFlagBitsKHR", VkVideoCapabilitiesFlagBitsKHRSets, 2},
    {"VkVideoSessionCreateFlagBitsKHR", VkVideoSessionCreateFlagBitsKHRSets, 2},
    {"VkVideoCodingQualityPresetFlagBitsKHR", VkVideoCodingQualityPresetFlagBitsKHRSets, 4},
    {"VkVideoDecodeH264FieldLayoutFlagBitsEXT", VkVideoDecodeH264FieldLayoutFlagBitsEXTSets, 3},
    {"VkVideoCodingControlFlagBitsKHR", VkVideoCodingControlFlagBitsKHRSets, 2},
    {"VkQueryResultStatusKHR", VkQueryResultStatusKHRSets, 3},
    {"VkVideoDecodeFlagBitsKHR", VkVideoDecodeFlagBitsKHRSets, 2},
    {"VkVideoEncodeFlagBitsKHR", VkVideoEncodeFlagBitsKHRSets, 2},
    {"VkVideoEncodeRateControlFlagBitsKHR", VkVideoEncodeRateControlFlagBitsKHRSets, 2},
    {"VkVideoEncodeRateControlModeFlagBitsKHR", VkVideoEncodeRateControlModeFlagBitsKHRSets, 3},
    {"VkVideoEncodeH264CapabilitiesFlagBitsEXT", VkVideoEncodeH264CapabilitiesFlagBitsEXTSets, 11},
    {"VkVideoEncodeH264InputModeFlagBitsEXT", VkVideoEncodeH264InputModeFlagBitsEXTSets, 3},
    {"VkVideoEncodeH264OutputModeFlagBitsEXT", VkVideoEncodeH264OutputModeFlagBitsEXTSets, 3},
    {"VkVideoEncodeH264CreateFlagBitsEXT", VkVideoEncodeH264CreateFlagBitsEXTSets, 2},
  }};
  
  /**
   * @brief Removes a vendor tag from the end of the given string view
   * @param view String view to remove the vendor tag from
   * @return A string_view without the vendor tag, if it was suffixed
   */
  std::string_view stripVendor(std::string_view view) {
      for (auto const &it : vendors) {
          // Don't strip if it's all that's left
          if (view == it)
              break;
  
          if (strncmp(view.data() + view.size() - it.size(), it.data(), it.size()) == 0) {
              view = view.substr(0, view.size() - it.size());
              break;
          }
      }
  
      return view;
  }
  
  /**
   * @brief Strips '_BIT' from the end of a string, if there
   */
  std::string_view stripBit(std::string_view view) {
      if (view.size() > strlen("_BIT")) {
          if (view.substr(view.size() - strlen("_BIT")) == "_BIT") {
              return view.substr(0, view.size() - strlen("_BIT"));
          }
      }
  
      return view;
  }
  
  std::tuple<EnumValueSet const *, EnumValueSet const *> getEnumType(std::string_view vkType) {
      // Check for a conversion from Flags -> FlagBits
      std::string localString;
      if (vkType.rfind("Flags") != std::string::npos) {
          localString = vkType;
          auto it = localString.rfind("Flags");
          localString = localString.replace(it, strlen("Flags"), "FlagBits");
          vkType = localString;
      }
  
      // Try the original name
      for (auto const &it : enumTypes) {
          if (vkType == std::string_view{it.name}) {
              if (it.data == nullptr)
                  return std::make_tuple(nullptr, nullptr);
              return std::make_tuple(it.data, it.data + it.count);
          }
      }
  
      // Try a vendor-stripped name
      vkType = stripVendor(vkType);
      for (auto const &it : enumTypes) {
          if (vkType == std::string_view{it.name}) {
              if (it.data == nullptr)
                  return std::make_tuple(nullptr, nullptr);
              return std::make_tuple(it.data, it.data + it.count);
          }
      }
  
      return std::make_tuple(nullptr, nullptr);
  }
  
  /**
   * @brief Converts a Vulkan Flag typename into the prefix that is used for it's enums
   * @param typeName Name of the type to generate the Vk enum prefix for
   * @return Generated prefix string
   *
   * Any capitalized letters except for the first has an underscore inserted before it, an underscore
   * is added to the end, and all characters are converted to upper case.
   *
   * It also removed the 'Flags' or 'FlagBits' suffixes.
   */
  std::string processEnumPrefix(std::string_view typeName) {
      // Flag Bits
      std::size_t flagBitsSize = strlen("FlagBits");
      if (typeName.size() > flagBitsSize) {
          if (strncmp(typeName.data() + typeName.size() - flagBitsSize, "FlagBits", flagBitsSize) ==
              0) {
              typeName = typeName.substr(0, typeName.size() - strlen("FlagBits"));
          }
      }
      // Flags
      std::size_t flagsSize = strlen("Flags");
      if (typeName.size() > flagsSize) {
          if (strncmp(typeName.data() + typeName.size() - flagsSize, "Flags", flagsSize) == 0) {
              typeName = typeName.substr(0, typeName.size() - strlen("Flags"));
          }
      }
  
      std::string retStr;
      for (auto it = typeName.begin(); it != typeName.end(); ++it) {
          if (it == typeName.begin()) {
              retStr += ::toupper(*it);
          } else if (::isupper(*it)) {
              retStr += '_';
              retStr += *it;
          } else {
              retStr += toupper(*it);
          }
      }
      retStr += '_';
  
      return retStr;
  }
  
  bool findValue(std::string_view findValue,
                 std::string_view prefix,
                 uint32_t *pValue,
                 EnumValueSet const *start,
                 EnumValueSet const *end) {
      // Remove the vendor tag suffix if it's on the value
      findValue = stripVendor(findValue);
      if (findValue[findValue.size() - 1] == '_')
          findValue = findValue.substr(0, findValue.size() - 1);
  
      // Remove '_BIT' if it's there
      findValue = stripBit(findValue);
  
      // Iterate until we find the value
      while (start != end) {
          if (findValue == start->name) {
              *pValue |= start->value;
              return true;
          }
  
          std::string prefixedName{prefix};
          prefixedName += start->name;
          if (findValue == prefixedName) {
              *pValue |= start->value;
              return true;
          }
  
          ++start;
      }
  
      return false;
  }
  
  /**
   * @brief Takes a given string and formats it for use with parsing
   * @param str The string to format
   * @return Formatted string
   *
   * First, any non alphanumeric characters are trimmed from both ends of the string.
   * After than, any spaces are replaced with underscores, and finally all the characters are
   * capitalized. This will generate the string closest to the original ones found in the XML spec.
   */
  std::string formatString(std::string str) {
      // Trim left
      std::size_t cutOffset = 0;
      for (auto c : str) {
          if (::isalnum(c))
              break;
          else
              ++cutOffset;
      }
      str = str.substr(cutOffset);
  
      // Trim right
      cutOffset = 0;
      for (std::size_t i = 0; i < str.size(); ++i) {
          if (::isalnum(str[i]))
              cutOffset = i + 1;
      }
      str = str.substr(0, cutOffset);
  
      std::replace(str.begin(), str.end(), ' ', '_');
      std::for_each(str.begin(), str.end(), [](char &c) { c = ::toupper(c); });
  
      return str;
  }
  
  bool serializeBitmask(std::string_view vkType, uint32_t vkValue, std::string *pString) {
      auto [end, start] = getEnumType(vkType);
      --end;
      --start;
  
      if(start == end) {
          // If this is a non-existing bitmask, then return an empty string
          *pString = {};
          return true;
      }
  
      std::string retStr;
      while (start != end) {
          if(vkValue == 0 && !retStr.empty()) {
              break;
          }
          if ((start->value & vkValue) == start->value) {
              // Found a compatible bit mask, add it
              if (!retStr.empty()) {
                  retStr += " | ";
              }
              retStr += start->name;
              vkValue = vkValue ^ start->value;
          }
  
          --start;
      }
  
      if (vkValue != 0 || retStr.empty()) {
          // Failed to find a valid bitmask for the value
          return false;
      }
  
      *pString = retStr;
      return true;
  }
  
  bool serializeEnum(std::string_view vkType, uint32_t vkValue, std::string *pString) {
      auto [start, end] = getEnumType(vkType);
  
      while (start != end) {
          if (start->value == vkValue) {
              *pString = start->name;
              return true;
          }
  
          ++start;
      }
  
      return false;
  }
  
  bool parseBitmask(std::string_view vkType, std::string_view vkString, uint32_t *pValue) {
      auto [start, end] = getEnumType(vkType);
      std::string prefix = processEnumPrefix(stripVendor(vkType));
      uint32_t retVal = 0;
  
      auto startCh = vkString.begin();
      auto endCh = startCh;
      for (; endCh != vkString.end(); ++endCh) {
          if (*endCh == '|') {
              std::string token(startCh, endCh);
              token = formatString(token);
  
              bool foundVal = findValue(token, prefix, &retVal, start, end);
              if (!foundVal)
                  return false;
  
              startCh = endCh + 1;
          }
      }
      if (startCh != endCh) {
          std::string token(startCh, endCh);
          token = formatString(token);
  
          bool foundVal = findValue(token, prefix, &retVal, start, end);
          if (!foundVal)
              return false;
      }
  
      *pValue = retVal;
      return true;
  }
  
  bool parseEnum(std::string_view vkType, std::string_view vkString, uint32_t *pValue) {
      auto [start, end] = getEnumType(vkType);
      std::string prefix = processEnumPrefix(stripVendor(vkType));
      uint32_t retVal = 0;
  
      std::string token = formatString(std::string{vkString});
      bool found = findValue(token, prefix, &retVal, start, end);
      if (found) {
          *pValue = retVal;
      }
      return found;
  }
  
  } // namespace
  
  bool vk_serialize(std::string_view vkType, uint32_t vkValue, std::string *pString) {
      if (vkType.empty()) {
          return false;
      }
  
      if (vkType.find("Flags") != std::string::npos || 
          vkType.find("FlagBits") != std::string::npos) {
          return serializeBitmask(vkType, vkValue, pString);
      }
  
      return serializeEnum(vkType, vkValue, pString);
  }
  
  bool vk_parse(std::string_view vkType, std::string vkString, uint32_t *pValue) {
      if (vkType.empty()) {
          return false;
      }
      if(vkString.empty()) {
          *pValue = 0;
          return true;
      }
  
      if (vkType.find("Flags") != std::string::npos || 
          vkType.find("FlagBits") != std::string::npos) {
          return parseBitmask(vkType, vkString, pValue);
      }
  
      return parseEnum(vkType, vkString, pValue);
  }
  
  #endif // VK_VALUE_SERIALIZATION_CONFIG_MAIN
  #endif // VK_VALUE_SERIALIZATION_V184_HPP
  