Replace spirv.hpp with spirv.hpp11

SPIRV/CMakeLists.txt

@@ -49,7 +49,7 @@ set(SPVREMAP_SOURCES
 
 set(SPIRV_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/bitutils.h
-    ${CMAKE_CURRENT_SOURCE_DIR}/spirv.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/spirv.hpp11
     ${CMAKE_CURRENT_SOURCE_DIR}/GLSL.std.450.h
     ${CMAKE_CURRENT_SOURCE_DIR}/GLSL.ext.EXT.h
     ${CMAKE_CURRENT_SOURCE_DIR}/GLSL.ext.KHR.h
@@ -58,6 +58,7 @@ set(SPIRV_HEADERS
     ${CMAKE_CURRENT_SOURCE_DIR}/Logger.h
     ${CMAKE_CURRENT_SOURCE_DIR}/SpvBuilder.h
     ${CMAKE_CURRENT_SOURCE_DIR}/spvIR.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/spvUtil.h
     ${CMAKE_CURRENT_SOURCE_DIR}/doc.h
     ${CMAKE_CURRENT_SOURCE_DIR}/SpvTools.h
     ${CMAKE_CURRENT_SOURCE_DIR}/disassemble.h
@@ -77,7 +78,7 @@ set(PUBLIC_HEADERS
     GlslangToSpv.h
     disassemble.h
     Logger.h
-    spirv.hpp
+    spirv.hpp11
     SPVRemapper.h
     SpvTools.h)
 

SPIRV/GLSL.ext.NV.h

@@ -27,10 +27,10 @@
 #ifndef GLSLextNV_H
 #define GLSLextNV_H
 
-enum BuiltIn;
-enum Decoration;
-enum Op;
-enum Capability;
+enum class BuiltIn : unsigned;
+enum class Decoration : unsigned;
+enum class Op : unsigned;
+enum class Capability : unsigned;
 
 static const int GLSLextNVVersion = 100;
 static const int GLSLextNVRevision = 11;

SPIRV/GLSL.ext.QCOM.h

@@ -27,10 +27,10 @@
 #ifndef GLSLextQCOM_H
 #define GLSLextQCOM_H
 
-enum BuiltIn;
-enum Decoration;
-enum Op;
-enum Capability;
+enum class BuiltIn : unsigned;
+enum class Decoration : unsigned;
+enum class Op : unsigned;
+enum class Capability : unsigned;
 
 static const int GLSLextQCOMVersion = 100;
 static const int GLSLextQCOMRevision = 1;

SPIRV/InReadableOrder.cpp

@@ -85,7 +85,7 @@ public:
             Id mergeId = mergeInst->getIdOperand(0);
             mergeBlock = block->getParent().getParent().getInstruction(mergeId)->getBlock();
             delayed_.insert(mergeBlock);
-            if (mergeInst->getOpCode() == spv::OpLoopMerge) {
+            if (mergeInst->getOpCode() == spv::Op::OpLoopMerge) {
                 Id continueId = mergeInst->getIdOperand(1);
                 continueBlock =
                     block->getParent().getParent().getInstruction(continueId)->getBlock();

SPIRV/SPVRemapper.cpp

@@ -35,6 +35,7 @@
 
 #include "SPVRemapper.h"
 #include "doc.h"
+#include "spvUtil.h"
 
 #include <algorithm>
 #include <cassert>
@@ -61,13 +62,13 @@ namespace spv {
         std::uint32_t offset = 0;
 
         switch (opCode) {
-        case spv::OpExtInst:
+        case spv::Op::OpExtInst:
             offset += asId(word + 4); break;
         default:
             break;
         }
 
-        return opCode * 19 + offset; // 19 = small prime
+        return ((unsigned)opCode) * 19 + offset; // 19 = small prime
     }
 
     spirvbin_t::range_t spirvbin_t::literalRange(spv::Op opCode) const
@@ -75,16 +76,16 @@ namespace spv {
         static const int maxCount = 1<<30;
 
         switch (opCode) {
-        case spv::OpTypeFloat:        // fall through...
-        case spv::OpTypePointer:      return range_t(2, 3);
-        case spv::OpTypeInt:          return range_t(2, 4);
+        case spv::Op::OpTypeFloat:    // fall through...
+        case spv::Op::OpTypePointer:  return range_t(2, 3);
+        case spv::Op::OpTypeInt:      return range_t(2, 4);
         // TODO: case spv::OpTypeImage:
         // TODO: case spv::OpTypeSampledImage:
-        case spv::OpTypeSampler:      return range_t(3, 8);
-        case spv::OpTypeVector:       // fall through
-        case spv::OpTypeMatrix:       // ...
-        case spv::OpTypePipe:         return range_t(3, 4);
-        case spv::OpConstant:         return range_t(3, maxCount);
+        case spv::Op::OpTypeSampler:  return range_t(3, 8);
+        case spv::Op::OpTypeVector:   // fall through
+        case spv::Op::OpTypeMatrix:   // ...
+        case spv::Op::OpTypePipe:     return range_t(3, 4);
+        case spv::Op::OpConstant:     return range_t(3, maxCount);
         default:                      return range_t(0, 0);
         }
     }
@@ -97,15 +98,15 @@ namespace spv {
             return range_t(1, 2);
 
         switch (opCode) {
-        case spv::OpTypeVector:       // fall through
-        case spv::OpTypeMatrix:       // ...
-        case spv::OpTypeSampler:      // ...
-        case spv::OpTypeArray:        // ...
-        case spv::OpTypeRuntimeArray: // ...
-        case spv::OpTypePipe:         return range_t(2, 3);
-        case spv::OpTypeStruct:       // fall through
-        case spv::OpTypeFunction:     return range_t(2, maxCount);
-        case spv::OpTypePointer:      return range_t(3, 4);
+        case spv::Op::OpTypeVector:       // fall through
+        case spv::Op::OpTypeMatrix:       // ...
+        case spv::Op::OpTypeSampler:      // ...
+        case spv::Op::OpTypeArray:        // ...
+        case spv::Op::OpTypeRuntimeArray: // ...
+        case spv::Op::OpTypePipe:         return range_t(2, 3);
+        case spv::Op::OpTypeStruct:       // fall through
+        case spv::Op::OpTypeFunction:     return range_t(2, maxCount);
+        case spv::Op::OpTypePointer:      return range_t(3, 4);
         default:                      return range_t(0, 0);
         }
     }
@@ -115,9 +116,9 @@ namespace spv {
         static const int maxCount = 1<<30;
 
         switch (opCode) {
-        case spv::OpTypeArray:         // fall through...
-        case spv::OpTypeRuntimeArray:  return range_t(3, 4);
-        case spv::OpConstantComposite: return range_t(3, maxCount);
+        case spv::Op::OpTypeArray:         // fall through...
+        case spv::Op::OpTypeRuntimeArray:  return range_t(3, 4);
+        case spv::Op::OpConstantComposite: return range_t(3, maxCount);
         default:                       return range_t(0, 0);
         }
     }
@@ -134,8 +135,8 @@ namespace spv {
             return 0;
 
         switch (opCode) {
-        case spv::OpTypeInt:   // fall through...
-        case spv::OpTypeFloat: return (spv[typeStart+2]+31)/32;
+        case spv::Op::OpTypeInt:   // fall through...
+        case spv::Op::OpTypeFloat: return (spv[typeStart + 2] + 31) / 32;
         default:
             return 0;
         }
@@ -158,11 +159,11 @@ namespace spv {
     bool spirvbin_t::isStripOp(spv::Op opCode, unsigned start) const
     {
         switch (opCode) {
-        case spv::OpSource:
-        case spv::OpSourceExtension:
-        case spv::OpName:
-        case spv::OpMemberName:
-        case spv::OpLine :
+        case spv::Op::OpSource:
+        case spv::Op::OpSourceExtension:
+        case spv::Op::OpName:
+        case spv::Op::OpMemberName:
+        case spv::Op::OpLine:
         {
             const std::string name = literalString(start + 2);
 
@@ -185,15 +186,15 @@ namespace spv {
     bool spirvbin_t::isFlowCtrl(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpBranchConditional:
-        case spv::OpBranch:
-        case spv::OpSwitch:
-        case spv::OpLoopMerge:
-        case spv::OpSelectionMerge:
-        case spv::OpLabel:
-        case spv::OpFunction:
-        case spv::OpFunctionEnd:    return true;
-        default:                    return false;
+        case spv::Op::OpBranchConditional:
+        case spv::Op::OpBranch:
+        case spv::Op::OpSwitch:
+        case spv::Op::OpLoopMerge:
+        case spv::Op::OpSelectionMerge:
+        case spv::Op::OpLabel:
+        case spv::Op::OpFunction:
+        case spv::Op::OpFunctionEnd: return true;
+        default:                     return false;
         }
     }
 
@@ -201,27 +202,27 @@ namespace spv {
     bool spirvbin_t::isTypeOp(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpTypeVoid:
-        case spv::OpTypeBool:
-        case spv::OpTypeInt:
-        case spv::OpTypeFloat:
-        case spv::OpTypeVector:
-        case spv::OpTypeMatrix:
-        case spv::OpTypeImage:
-        case spv::OpTypeSampler:
-        case spv::OpTypeArray:
-        case spv::OpTypeRuntimeArray:
-        case spv::OpTypeStruct:
-        case spv::OpTypeOpaque:
-        case spv::OpTypePointer:
-        case spv::OpTypeFunction:
-        case spv::OpTypeEvent:
-        case spv::OpTypeDeviceEvent:
-        case spv::OpTypeReserveId:
-        case spv::OpTypeQueue:
-        case spv::OpTypeSampledImage:
-        case spv::OpTypePipe:         return true;
-        default:                      return false;
+        case spv::Op::OpTypeVoid:
+        case spv::Op::OpTypeBool:
+        case spv::Op::OpTypeInt:
+        case spv::Op::OpTypeFloat:
+        case spv::Op::OpTypeVector:
+        case spv::Op::OpTypeMatrix:
+        case spv::Op::OpTypeImage:
+        case spv::Op::OpTypeSampler:
+        case spv::Op::OpTypeArray:
+        case spv::Op::OpTypeRuntimeArray:
+        case spv::Op::OpTypeStruct:
+        case spv::Op::OpTypeOpaque:
+        case spv::Op::OpTypePointer:
+        case spv::Op::OpTypeFunction:
+        case spv::Op::OpTypeEvent:
+        case spv::Op::OpTypeDeviceEvent:
+        case spv::Op::OpTypeReserveId:
+        case spv::Op::OpTypeQueue:
+        case spv::Op::OpTypeSampledImage:
+        case spv::Op::OpTypePipe:         return true;
+        default:                          return false;
         }
     }
 
@@ -229,15 +230,15 @@ namespace spv {
     bool spirvbin_t::isConstOp(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpConstantSampler:
+        case spv::Op::OpConstantSampler:
             error("unimplemented constant type");
             return true;
 
-        case spv::OpConstantNull:
-        case spv::OpConstantTrue:
-        case spv::OpConstantFalse:
-        case spv::OpConstantComposite:
-        case spv::OpConstant:
+        case spv::Op::OpConstantNull:
+        case spv::Op::OpConstantTrue:
+        case spv::Op::OpConstantFalse:
+        case spv::Op::OpConstantComposite:
+        case spv::Op::OpConstant:
             return true;
 
         default:
@@ -395,10 +396,10 @@ namespace spv {
             [&](spv::Op opCode, unsigned start) {
                 // strip opcodes pointing to removed data
                 switch (opCode) {
-                case spv::OpName:
-                case spv::OpMemberName:
-                case spv::OpDecorate:
-                case spv::OpMemberDecorate:
+                case spv::Op::OpName:
+                case spv::Op::OpMemberName:
+                case spv::Op::OpDecorate:
+                case spv::Op::OpMemberDecorate:
                     if (idPosR.find(asId(start+1)) == idPosR.end())
                         stripInst(start);
                     break;
@@ -439,11 +440,11 @@ namespace spv {
                 unsigned word = start+1;
                 spv::Id  typeId = spv::NoResult;
 
-                if (spv::InstructionDesc[opCode].hasType())
+                if (spv::InstructionDesc[enumCast(opCode)].hasType())
                     typeId = asId(word++);
 
                 // If there's a result ID, remember the size of its type
-                if (spv::InstructionDesc[opCode].hasResult()) {
+                if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
                     const spv::Id resultId = asId(word++);
                     idPosR[resultId] = start;
 
@@ -546,19 +547,19 @@ namespace spv {
             return nextInst;
 
         // Read type and result ID from instruction desc table
-        if (spv::InstructionDesc[opCode].hasType()) {
+        if (spv::InstructionDesc[enumCast(opCode)].hasType()) {
             idFn(asId(word++));
             --numOperands;
         }
 
-        if (spv::InstructionDesc[opCode].hasResult()) {
+        if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
             idFn(asId(word++));
             --numOperands;
         }
 
         // Extended instructions: currently, assume everything is an ID.
         // TODO: add whatever data we need for exceptions to that
-        if (opCode == spv::OpExtInst) {
+        if (opCode == spv::Op::OpExtInst) {
 
             idFn(asId(word)); // Instruction set is an ID that also needs to be mapped
 
@@ -583,14 +584,14 @@ namespace spv {
             // opcode being processed is the literal opcode value of the SpecConstantOp.  See the
             // SPIRV spec for details.  This way we will handle IDs and literals as appropriate for
             // the embedded op.
-            if (opCode == spv::OpSpecConstantOp) {
+            if (opCode == spv::Op::OpSpecConstantOp) {
                 if (op == 0) {
                     opCode = asOpCode(word++);  // this is the opcode embedded in the SpecConstantOp.
                     --numOperands;
                 }
             }
 
-            switch (spv::InstructionDesc[opCode].operands.getClass(op)) {
+            switch (spv::InstructionDesc[enumCast(opCode)].operands.getClass(op)) {
             case spv::OperandId:
             case spv::OperandScope:
             case spv::OperandMemorySemantics:
@@ -614,7 +615,7 @@ namespace spv {
                 return nextInst;
 
             case spv::OperandVariableLiteralId: {
-                if (opCode == OpSwitch) {
+                if (opCode == Op::OpSwitch) {
                     // word-2 is the position of the selector ID.  OpSwitch Literals match its type.
                     // In case the IDs are currently being remapped, we get the word[-2] ID from
                     // the circular idBuffer.
@@ -653,12 +654,12 @@ namespace spv {
             case spv::OperandMemoryAccess:
                 {
                     uint32_t mask = spv[word];
-                    if (mask & uint32_t(spv::MemoryAccessMask::MemoryAccessAlignedMask)) {
+                    if (mask & uint32_t(spv::MemoryAccessMask::Aligned)) {
                         ++word;
                         --numOperands;
                     }
-                    if (mask & uint32_t(spv::MemoryAccessMask::MemoryAccessMakePointerAvailableMask |
-                                        spv::MemoryAccessMask::MemoryAccessMakePointerVisibleMask)) {
+                    if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailable |
+                                        spv::MemoryAccessMask::MakePointerVisible)) {
                         idFn(asId(word+1));
                         ++word;
                         --numOperands;
@@ -670,12 +671,12 @@ namespace spv {
             case spv::OperandTensorAddressingOperands:
                 {
                     uint32_t mask = spv[word];
-                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorAddressingOperandsTensorViewMask)) {
+                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorView)) {
                         idFn(asId(word+1));
                         ++word;
                         --numOperands;
                     }
-                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorAddressingOperandsDecodeFuncMask)) {
+                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::DecodeFunc)) {
                         idFn(asId(word+1));
                         ++word;
                         --numOperands;
@@ -800,26 +801,26 @@ namespace spv {
             const unsigned start  = instPos[entry];
             const spv::Op  opCode = asOpCode(start);
 
-            if (opCode == spv::OpFunction)
+            if (opCode == spv::Op::OpFunction)
                 fnId   = asId(start + 2);
 
-            if (opCode == spv::OpFunctionEnd)
+            if (opCode == spv::Op::OpFunctionEnd)
                 fnId = spv::NoResult;
 
             if (fnId != spv::NoResult) { // if inside a function
-                if (spv::InstructionDesc[opCode].hasResult()) {
-                    const unsigned word    = start + (spv::InstructionDesc[opCode].hasType() ? 2 : 1);
+                if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
+                    const unsigned word    = start + (spv::InstructionDesc[enumCast(opCode)].hasType() ? 2 : 1);
                     const spv::Id  resId   = asId(word);
                     std::uint32_t  hashval = fnId * 17; // small prime
 
                     for (unsigned i = entry-1; i >= entry-windowSize; --i) {
-                        if (asOpCode(instPos[i]) == spv::OpFunction)
+                        if (asOpCode(instPos[i]) == spv::Op::OpFunction)
                             break;
                         hashval = hashval * 30103 + asOpCodeHash(instPos[i]); // 30103 = semiarbitrary prime
                     }
 
                     for (unsigned i = entry; i <= entry + windowSize; ++i) {
-                        if (asOpCode(instPos[i]) == spv::OpFunctionEnd)
+                        if (asOpCode(instPos[i]) == spv::Op::OpFunctionEnd)
                             break;
                         hashval = hashval * 30103 + asOpCodeHash(instPos[i]); // 30103 = semiarbitrary prime
                     }
@@ -834,7 +835,7 @@ namespace spv {
             }
         }
 
-        spv::Op          thisOpCode(spv::OpNop);
+        spv::Op thisOpCode(spv::Op::OpNop);
         std::unordered_map<int, int> opCounter;
         int              idCounter(0);
         fnId = spv::NoResult;
@@ -842,53 +843,53 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 switch (opCode) {
-                case spv::OpFunction:
+                case spv::Op::OpFunction:
                     // Reset counters at each function
                     idCounter = 0;
                     opCounter.clear();
                     fnId = asId(start + 2);
                     break;
 
-                case spv::OpImageSampleImplicitLod:
-                case spv::OpImageSampleExplicitLod:
-                case spv::OpImageSampleDrefImplicitLod:
-                case spv::OpImageSampleDrefExplicitLod:
-                case spv::OpImageSampleProjImplicitLod:
-                case spv::OpImageSampleProjExplicitLod:
-                case spv::OpImageSampleProjDrefImplicitLod:
-                case spv::OpImageSampleProjDrefExplicitLod:
-                case spv::OpDot:
-                case spv::OpCompositeExtract:
-                case spv::OpCompositeInsert:
-                case spv::OpVectorShuffle:
-                case spv::OpLabel:
-                case spv::OpVariable:
-
-                case spv::OpAccessChain:
-                case spv::OpLoad:
-                case spv::OpStore:
-                case spv::OpCompositeConstruct:
-                case spv::OpFunctionCall:
-                    ++opCounter[opCode];
+                case spv::Op::OpImageSampleImplicitLod:
+                case spv::Op::OpImageSampleExplicitLod:
+                case spv::Op::OpImageSampleDrefImplicitLod:
+                case spv::Op::OpImageSampleDrefExplicitLod:
+                case spv::Op::OpImageSampleProjImplicitLod:
+                case spv::Op::OpImageSampleProjExplicitLod:
+                case spv::Op::OpImageSampleProjDrefImplicitLod:
+                case spv::Op::OpImageSampleProjDrefExplicitLod:
+                case spv::Op::OpDot:
+                case spv::Op::OpCompositeExtract:
+                case spv::Op::OpCompositeInsert:
+                case spv::Op::OpVectorShuffle:
+                case spv::Op::OpLabel:
+                case spv::Op::OpVariable:
+
+                case spv::Op::OpAccessChain:
+                case spv::Op::OpLoad:
+                case spv::Op::OpStore:
+                case spv::Op::OpCompositeConstruct:
+                case spv::Op::OpFunctionCall:
+                    ++opCounter[enumCast(opCode)];
                     idCounter = 0;
                     thisOpCode = opCode;
                     break;
                 default:
-                    thisOpCode = spv::OpNop;
+                    thisOpCode = spv::Op::OpNop;
                 }
 
                 return false;
             },
 
             [&](spv::Id& id) {
-                if (thisOpCode != spv::OpNop) {
+                if (thisOpCode != spv::Op::OpNop) {
                     ++idCounter;
                     const std::uint32_t hashval =
                         // Explicitly cast operands to unsigned int to avoid integer
                         // promotion to signed int followed by integer overflow,
                         // which would result in undefined behavior.
-                        static_cast<unsigned int>(opCounter[thisOpCode])
-                        * thisOpCode
+                        static_cast<unsigned int>(opCounter[enumCast(thisOpCode)])
+                        * enumCast(thisOpCode)
                         * 50047
                         + idCounter
                         + static_cast<unsigned int>(fnId) * 117;
@@ -910,16 +911,16 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 // Add inputs and uniforms to the map
-                if ((opCode == spv::OpVariable && asWordCount(start) == 4) &&
-                    (spv[start+3] == spv::StorageClassUniform ||
-                    spv[start+3] == spv::StorageClassUniformConstant ||
-                    spv[start+3] == spv::StorageClassInput))
+                if ((opCode == spv::Op::OpVariable && asWordCount(start) == 4) &&
+                    (spv[start+3] == (unsigned)spv::StorageClass::Uniform ||
+                    spv[start+3] == (unsigned)spv::StorageClass::UniformConstant ||
+                    spv[start+3] == (unsigned)spv::StorageClass::Input))
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpAccessChain && fnLocalVars.count(asId(start+3)) > 0)
+                if (opCode == spv::Op::OpAccessChain && fnLocalVars.count(asId(start+3)) > 0)
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
                     idMap[asId(start+2)] = asId(start+3);
                     stripInst(start);
                 }
@@ -940,11 +941,11 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 // Add inputs and uniforms to the map
-                if ((opCode == spv::OpVariable && asWordCount(start) == 4) &&
-                    (spv[start+3] == spv::StorageClassOutput))
+                if ((opCode == spv::Op::OpVariable && asWordCount(start) == 4) &&
+                    (spv[start+3] == (int)spv::StorageClass::Output))
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
+                if (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
                     idMap[asId(start+2)] = asId(start+1);
                     stripInst(start);
                 }
@@ -985,19 +986,19 @@ namespace spv {
                     ++blockNum;
 
                 // Add local variables to the map
-                if ((opCode == spv::OpVariable && spv[start+3] == spv::StorageClassFunction && asWordCount(start) == 4)) {
+                if ((opCode == spv::Op::OpVariable && spv[start+3] == (unsigned)spv::StorageClass::Function && asWordCount(start) == 4)) {
                     fnLocalVars.insert(asId(start+2));
                     return true;
                 }
 
                 // Ignore process vars referenced via access chain
-                if ((opCode == spv::OpAccessChain || opCode == spv::OpInBoundsAccessChain) && fnLocalVars.count(asId(start+3)) > 0) {
+                if ((opCode == spv::Op::OpAccessChain || opCode == spv::Op::OpInBoundsAccessChain) && fnLocalVars.count(asId(start+3)) > 0) {
                     fnLocalVars.erase(asId(start+3));
                     idMap.erase(asId(start+3));
                     return true;
                 }
 
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start + 3)) > 0) {
                     const spv::Id varId = asId(start+3);
 
                     // Avoid loads before stores
@@ -1007,7 +1008,7 @@ namespace spv {
                     }
 
                     // don't do for volatile references
-                    if (wordCount > 4 && (spv[start+4] & spv::MemoryAccessVolatileMask)) {
+                    if (wordCount > 4 && (spv[start+4] & spv::MemoryAccessMask::Volatile)) {
                         fnLocalVars.erase(varId);
                         idMap.erase(varId);
                     }
@@ -1023,7 +1024,7 @@ namespace spv {
                     return true;
                 }
 
-                if (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
+                if (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
                     const spv::Id varId = asId(start+1);
 
                     if (idMap.find(varId) == idMap.end()) {
@@ -1035,7 +1036,7 @@ namespace spv {
                     }
 
                     // don't do for volatile references
-                    if (wordCount > 3 && (spv[start+3] & spv::MemoryAccessVolatileMask)) {
+                    if (wordCount > 3 && (spv[start+3] & spv::MemoryAccessMask::Volatile)) {
                         fnLocalVars.erase(asId(start+3));
                         idMap.erase(asId(start+3));
                     }
@@ -1068,7 +1069,7 @@ namespace spv {
 
         process(
             [&](spv::Op opCode, unsigned start) {
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0)
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0)
                     idMap[asId(start+2)] = idMap[asId(start+3)];
                 return false;
             },
@@ -1094,9 +1095,9 @@ namespace spv {
         // Remove the load/store/variables for the ones we've discovered
         process(
             [&](spv::Op opCode, unsigned start) {
-                if ((opCode == spv::OpLoad  && fnLocalVars.count(asId(start+3)) > 0) ||
-                    (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) ||
-                    (opCode == spv::OpVariable && fnLocalVars.count(asId(start+2)) > 0)) {
+                if ((opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0) ||
+                    (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) ||
+                    (opCode == spv::Op::OpVariable && fnLocalVars.count(asId(start+2)) > 0)) {
 
                     stripInst(start);
                     return true;
@@ -1175,10 +1176,10 @@ namespace spv {
         // Count function variable use
         process(
             [&](spv::Op opCode, unsigned start) {
-                if (opCode == spv::OpVariable) {
+                if (opCode == spv::Op::OpVariable) {
                     ++varUseCount[asId(start+2)];
                     return true;
-                } else if (opCode == spv::OpEntryPoint) {
+                } else if (opCode == spv::Op::OpEntryPoint) {
                     const int wordCount = asWordCount(start);
                     for (int i = 4; i < wordCount; i++) {
                         ++varUseCount[asId(start+i)];
@@ -1198,9 +1199,9 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 spv::Id id = spv::NoResult;
-                if (opCode == spv::OpVariable)
+                if (opCode == spv::Op::OpVariable)
                     id = asId(start+2);
-                if (opCode == spv::OpDecorate || opCode == spv::OpName)
+                if (opCode == spv::Op::OpDecorate || opCode == spv::Op::OpName)
                     id = asId(start+1);
 
                 if (id != spv::NoResult && varUseCount[id] == 1)
@@ -1344,30 +1345,30 @@ namespace spv {
         const spv::Op  opCode      = asOpCode(typeStart);
 
         switch (opCode) {
-        case spv::OpTypeVoid:         return 0;
-        case spv::OpTypeBool:         return 1;
-        case spv::OpTypeInt:          return 3 + (spv[typeStart+3]);
-        case spv::OpTypeFloat:        return 5;
-        case spv::OpTypeVector:
+        case spv::Op::OpTypeVoid:         return 0;
+        case spv::Op::OpTypeBool:         return 1;
+        case spv::Op::OpTypeInt:          return 3 + (spv[typeStart+3]);
+        case spv::Op::OpTypeFloat:        return 5;
+        case spv::Op::OpTypeVector:
             return 6 + hashType(idPos(spv[typeStart+2])) * (spv[typeStart+3] - 1);
-        case spv::OpTypeMatrix:
+        case spv::Op::OpTypeMatrix:
             return 30 + hashType(idPos(spv[typeStart+2])) * (spv[typeStart+3] - 1);
-        case spv::OpTypeImage:
+        case spv::Op::OpTypeImage:
             return 120 + hashType(idPos(spv[typeStart+2])) +
                 spv[typeStart+3] +            // dimensionality
                 spv[typeStart+4] * 8 * 16 +   // depth
                 spv[typeStart+5] * 4 * 16 +   // arrayed
                 spv[typeStart+6] * 2 * 16 +   // multisampled
                 spv[typeStart+7] * 1 * 16;    // format
-        case spv::OpTypeSampler:
+        case spv::Op::OpTypeSampler:
             return 500;
-        case spv::OpTypeSampledImage:
+        case spv::Op::OpTypeSampledImage:
             return 502;
-        case spv::OpTypeArray:
+        case spv::Op::OpTypeArray:
             return 501 + hashType(idPos(spv[typeStart+2])) * spv[typeStart+3];
-        case spv::OpTypeRuntimeArray:
+        case spv::Op::OpTypeRuntimeArray:
             return 5000  + hashType(idPos(spv[typeStart+2]));
-        case spv::OpTypeStruct:
+        case spv::Op::OpTypeStruct:
             {
                 std::uint32_t hash = 10000;
                 for (unsigned w=2; w < wordCount; ++w)
@@ -1375,9 +1376,9 @@ namespace spv {
                 return hash;
             }
 
-        case spv::OpTypeOpaque:         return 6000 + spv[typeStart+2];
-        case spv::OpTypePointer:        return 100000  + hashType(idPos(spv[typeStart+3]));
-        case spv::OpTypeFunction:
+        case spv::Op::OpTypeOpaque:         return 6000 + spv[typeStart+2];
+        case spv::Op::OpTypePointer:        return 100000  + hashType(idPos(spv[typeStart+3]));
+        case spv::Op::OpTypeFunction:
             {
                 std::uint32_t hash = 200000;
                 for (unsigned w=2; w < wordCount; ++w)
@@ -1385,35 +1386,35 @@ namespace spv {
                 return hash;
             }
 
-        case spv::OpTypeEvent:                      return 300000;
-        case spv::OpTypeDeviceEvent:                return 300001;
-        case spv::OpTypeReserveId:                  return 300002;
-        case spv::OpTypeQueue:                      return 300003;
-        case spv::OpTypePipe:                       return 300004;
-        case spv::OpConstantTrue:                   return 300007;
-        case spv::OpConstantFalse:                  return 300008;
-        case spv::OpTypeRayQueryKHR:                return 300009;
-        case spv::OpTypeAccelerationStructureKHR:   return 300010;
-        case spv::OpConstantComposite:
+        case spv::Op::OpTypeEvent:                      return 300000;
+        case spv::Op::OpTypeDeviceEvent:                return 300001;
+        case spv::Op::OpTypeReserveId:                  return 300002;
+        case spv::Op::OpTypeQueue:                      return 300003;
+        case spv::Op::OpTypePipe:                       return 300004;
+        case spv::Op::OpConstantTrue:                   return 300007;
+        case spv::Op::OpConstantFalse:                  return 300008;
+        case spv::Op::OpTypeRayQueryKHR:                return 300009;
+        case spv::Op::OpTypeAccelerationStructureKHR:   return 300010;
+        case spv::Op::OpConstantComposite:
             {
                 std::uint32_t hash = 300011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)
                     hash += w * hashType(idPos(spv[typeStart+w]));
                 return hash;
             }
-        case spv::OpConstant:
+        case spv::Op::OpConstant:
             {
                 std::uint32_t hash = 400011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)
                     hash += w * spv[typeStart+w];
                 return hash;
             }
-        case spv::OpConstantNull:
+        case spv::Op::OpConstantNull:
             {
                 std::uint32_t hash = 500009 + hashType(idPos(spv[typeStart+1]));
                 return hash;
             }
-        case spv::OpConstantSampler:
+        case spv::Op::OpConstantSampler:
             {
                 std::uint32_t hash = 600011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)

SPIRV/SPVRemapper.h

@@ -91,7 +91,7 @@ public:
 #include <set>
 #include <cassert>
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 namespace spv {
 

SPIRV/SpvBuilder.h

@@ -49,8 +49,10 @@
 
 #include "Logger.h"
 #define SPV_ENABLE_UTILITY_CODE
-#include "spirv.hpp"
+#include "spirv.hpp11"
 #include "spvIR.h"
+#include "spvUtil.h"
+
 namespace spv {
     #include "GLSL.ext.KHR.h"
     #include "GLSL.ext.EXT.h"
@@ -100,7 +102,7 @@ public:
         if (sItr != stringIds.end())
             return sItr->second;
         spv::Id strId = getUniqueId();
-        Instruction* fileString = new Instruction(strId, NoType, OpString);
+        Instruction* fileString = new Instruction(strId, NoType, Op::OpString);
         const char* file_c_str = str.c_str();
         fileString->addStringOperand(file_c_str);
         strings.push_back(std::unique_ptr<Instruction>(fileString));
@@ -298,46 +300,46 @@ public:
     bool isTensorView(Id resultId)const { return isTensorViewType(getTypeId(resultId)); }
 
     bool isBoolType(Id typeId)
-        { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); }
+        { return groupedTypes[enumCast(Op::OpTypeBool)].size() > 0 && typeId == groupedTypes[enumCast(Op::OpTypeBool)].back()->getResultId(); }
     bool isIntType(Id typeId)          const
-        { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; }
+        { return getTypeClass(typeId) == Op::OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; }
     bool isUintType(Id typeId)         const
-        { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
-    bool isFloatType(Id typeId)        const { return getTypeClass(typeId) == OpTypeFloat; }
-    bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == OpTypePointer; }
+        { return getTypeClass(typeId) == Op::OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
+    bool isFloatType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeFloat; }
+    bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == Op::OpTypePointer; }
     bool isScalarType(Id typeId)       const
-        { return getTypeClass(typeId) == OpTypeFloat || getTypeClass(typeId) == OpTypeInt ||
-          getTypeClass(typeId) == OpTypeBool; }
-    bool isVectorType(Id typeId)       const { return getTypeClass(typeId) == OpTypeVector; }
-    bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == OpTypeMatrix; }
-    bool isStructType(Id typeId)       const { return getTypeClass(typeId) == OpTypeStruct; }
-    bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == OpTypeArray; }
+        { return getTypeClass(typeId) == Op::OpTypeFloat || getTypeClass(typeId) == Op::OpTypeInt ||
+          getTypeClass(typeId) == Op::OpTypeBool; }
+    bool isVectorType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeVector; }
+    bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeMatrix; }
+    bool isStructType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeStruct; }
+    bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeArray; }
     bool isCooperativeMatrixType(Id typeId)const
     {
-        return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV;
+        return getTypeClass(typeId) == Op::OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == Op::OpTypeCooperativeMatrixNV;
     }
-    bool isTensorViewType(Id typeId)   const { return getTypeClass(typeId) == OpTypeTensorViewNV; }
-    bool isCooperativeVectorType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeVectorNV; }
+    bool isTensorViewType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeTensorViewNV; }
+    bool isCooperativeVectorType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeCooperativeVectorNV; }
     bool isAggregateType(Id typeId)    const
         { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
-    bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
-    bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == OpTypeSampler; }
-    bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; }
+    bool isImageType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeImage; }
+    bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == Op::OpTypeSampler; }
+    bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeSampledImage; }
     bool containsType(Id typeId, Op typeOp, unsigned int width) const;
     bool containsPhysicalStorageBufferOrArray(Id typeId) const;
 
     bool isConstantOpCode(Op opcode) const;
     bool isSpecConstantOpCode(Op opcode) const;
     bool isConstant(Id resultId) const { return isConstantOpCode(getOpCode(resultId)); }
-    bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == OpConstant; }
+    bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == Op::OpConstant; }
     bool isSpecConstant(Id resultId) const { return isSpecConstantOpCode(getOpCode(resultId)); }
     unsigned int getConstantScalar(Id resultId) const
         { return module.getInstruction(resultId)->getImmediateOperand(0); }
     StorageClass getStorageClass(Id resultId) const { return getTypeStorageClass(getTypeId(resultId)); }
 
-    bool isVariableOpCode(Op opcode) const { return opcode == OpVariable; }
+    bool isVariableOpCode(Op opcode) const { return opcode == Op::OpVariable; }
     bool isVariable(Id resultId) const { return isVariableOpCode(getOpCode(resultId)); }
-    bool isGlobalStorage(Id resultId) const { return getStorageClass(resultId) != StorageClassFunction; }
+    bool isGlobalStorage(Id resultId) const { return getStorageClass(resultId) != StorageClass::Function; }
     bool isGlobalVariable(Id resultId) const { return isVariable(resultId) && isGlobalStorage(resultId); }
     // See if a resultId is valid for use as an initializer.
     bool isValidInitializer(Id resultId) const { return isConstant(resultId) || isGlobalVariable(resultId); }
@@ -345,7 +347,7 @@ public:
     int getScalarTypeWidth(Id typeId) const
     {
         Id scalarTypeId = getScalarTypeId(typeId);
-        assert(getTypeClass(scalarTypeId) == OpTypeInt || getTypeClass(scalarTypeId) == OpTypeFloat);
+        assert(getTypeClass(scalarTypeId) == Op::OpTypeInt || getTypeClass(scalarTypeId) == Op::OpTypeFloat);
         return module.getInstruction(scalarTypeId)->getImmediateOperand(0);
     }
 
@@ -396,6 +398,14 @@ public:
         { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
     Id makeUintConstant(unsigned u, bool specConstant = false)
         { return makeIntConstant(makeUintType(32),           u, specConstant); }
+    Id makeUintConstant(Scope u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(StorageClass u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(MemorySemanticsMask u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(SourceLanguage u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
     Id makeInt64Constant(long long i, bool specConstant = false)
         { return makeInt64Constant(makeIntType(64),  (unsigned long long)i, specConstant); }
     Id makeUint64Constant(unsigned long long u, bool specConstant = false)
@@ -491,13 +501,13 @@ public:
     Id createUndefined(Id type);
 
     // Store into an Id and return the l-value
-    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
-        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // Load from an Id and return it
     Id createLoad(Id lValue, spv::Decoration precision,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
-        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // Create an OpAccessChain instruction
     Id createAccessChain(StorageClass, Id base, const std::vector<Id>& offsets);
@@ -524,7 +534,7 @@ public:
     void createNoResultOp(Op, const std::vector<Id>& operands);
     void createNoResultOp(Op, const std::vector<IdImmediate>& operands);
     void createControlBarrier(Scope execution, Scope memory, MemorySemanticsMask);
-    void createMemoryBarrier(unsigned executionScope, unsigned memorySemantics);
+    void createMemoryBarrier(Scope executionScope, MemorySemanticsMask memorySemantics);
     Id createUnaryOp(Op, Id typeId, Id operand);
     Id createBinOp(Op, Id typeId, Id operand1, Id operand2);
     Id createTriOp(Op, Id typeId, Id operand1, Id operand2, Id operand3);
@@ -631,7 +641,7 @@ public:
     // Helper to use for building nested control flow with if-then-else.
     class If {
     public:
-        If(Id condition, unsigned int ctrl, Builder& builder);
+        If(Id condition, SelectionControlMask ctrl, Builder& builder);
         ~If() {}
 
         void makeBeginElse();
@@ -643,7 +653,7 @@ public:
 
         Builder& builder;
         Id condition;
-        unsigned int control;
+        SelectionControlMask control;
         Function* function;
         Block* headerBlock;
         Block* thenBlock;
@@ -663,7 +673,7 @@ public:
     // Returns the right set of basic blocks to start each code segment with, so that the caller's
     // recursion stack can hold the memory for it.
     //
-    void makeSwitch(Id condition, unsigned int control, int numSegments, const std::vector<int>& caseValues,
+    void makeSwitch(Id condition, SelectionControlMask control, int numSegments, const std::vector<int>& caseValues,
                     const std::vector<int>& valueToSegment, int defaultSegment, std::vector<Block*>& segmentBB);
 
     // Add a branch to the innermost switch's merge block.
@@ -854,12 +864,12 @@ public:
 
     // use accessChain and swizzle to store value
     void accessChainStore(Id rvalue, Decoration nonUniform,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
-        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // use accessChain and swizzle to load an r-value
     Id accessChainLoad(Decoration precision, Decoration l_nonUniform, Decoration r_nonUniform, Id ResultType,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax,
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone, spv::Scope scope = spv::Scope::Max,
             unsigned int alignment = 0);
 
     // Return whether or not the access chain can be represented in SPIR-V
@@ -896,7 +906,7 @@ public:
     // If set implicit, the branch instruction shouldn't have debug source location.
     void createBranch(bool implicit, Block* block);
     void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock);
-    void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control,
+    void createLoopMerge(Block* mergeBlock, Block* continueBlock, LoopControlMask control,
         const std::vector<unsigned int>& operands);
 
     // Sets to generate opcode for specialization constants.
@@ -918,7 +928,7 @@ public:
     void transferAccessChainSwizzle(bool dynamic);
     void simplifyAccessChainSwizzle();
     void createAndSetNoPredecessorBlock(const char*);
-    void createSelectionMerge(Block* mergeBlock, unsigned int control);
+    void createSelectionMerge(Block* mergeBlock, SelectionControlMask control);
     void dumpSourceInstructions(std::vector<unsigned int>&) const;
     void dumpSourceInstructions(const spv::Id fileId, const std::string& text, std::vector<unsigned int>&) const;
     template <class Range> void dumpInstructions(std::vector<unsigned int>& out, const Range& instructions) const;

SPIRV/SpvPostProcess.cpp

@@ -44,7 +44,8 @@
 #include <algorithm>
 
 #include "SpvBuilder.h"
-#include "spirv.hpp"
+#include "spirv.hpp11"
+#include "spvUtil.h"
 
 namespace spv {
     #include "GLSL.std.450.h"
@@ -64,137 +65,137 @@ namespace spv {
 void Builder::postProcessType(const Instruction& inst, Id typeId)
 {
     // Characterize the type being questioned
-    Id basicTypeOp = getMostBasicTypeClass(typeId);
+    Op basicTypeOp = getMostBasicTypeClass(typeId);
     int width = 0;
-    if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt)
+    if (basicTypeOp == Op::OpTypeFloat || basicTypeOp == Op::OpTypeInt)
         width = getScalarTypeWidth(typeId);
 
     // Do opcode-specific checks
     switch (inst.getOpCode()) {
-    case OpLoad:
-    case OpStore:
-        if (basicTypeOp == OpTypeStruct) {
-            if (containsType(typeId, OpTypeInt, 8))
-                addCapability(CapabilityInt8);
-            if (containsType(typeId, OpTypeInt, 16))
-                addCapability(CapabilityInt16);
-            if (containsType(typeId, OpTypeFloat, 16))
-                addCapability(CapabilityFloat16);
+    case Op::OpLoad:
+    case Op::OpStore:
+        if (basicTypeOp == Op::OpTypeStruct) {
+            if (containsType(typeId, Op::OpTypeInt, 8))
+                addCapability(Capability::Int8);
+            if (containsType(typeId, Op::OpTypeInt, 16))
+                addCapability(Capability::Int16);
+            if (containsType(typeId, Op::OpTypeFloat, 16))
+                addCapability(Capability::Float16);
         } else {
             StorageClass storageClass = getStorageClass(inst.getIdOperand(0));
             if (width == 8) {
                 switch (storageClass) {
-                case StorageClassPhysicalStorageBufferEXT:
-                case StorageClassUniform:
-                case StorageClassStorageBuffer:
-                case StorageClassPushConstant:
+                case StorageClass::PhysicalStorageBufferEXT:
+                case StorageClass::Uniform:
+                case StorageClass::StorageBuffer:
+                case StorageClass::PushConstant:
                     break;
                 default:
-                    addCapability(CapabilityInt8);
+                    addCapability(Capability::Int8);
                     break;
                 }
             } else if (width == 16) {
                 switch (storageClass) {
-                case StorageClassPhysicalStorageBufferEXT:
-                case StorageClassUniform:
-                case StorageClassStorageBuffer:
-                case StorageClassPushConstant:
-                case StorageClassInput:
-                case StorageClassOutput:
+                case StorageClass::PhysicalStorageBufferEXT:
+                case StorageClass::Uniform:
+                case StorageClass::StorageBuffer:
+                case StorageClass::PushConstant:
+                case StorageClass::Input:
+                case StorageClass::Output:
                     break;
                 default:
-                    if (basicTypeOp == OpTypeInt)
-                        addCapability(CapabilityInt16);
-                    if (basicTypeOp == OpTypeFloat)
-                        addCapability(CapabilityFloat16);
+                    if (basicTypeOp == Op::OpTypeInt)
+                        addCapability(Capability::Int16);
+                    if (basicTypeOp == Op::OpTypeFloat)
+                        addCapability(Capability::Float16);
                     break;
                 }
             }
         }
         break;
-    case OpCopyObject:
+    case Op::OpCopyObject:
         break;
-    case OpFConvert:
-    case OpSConvert:
-    case OpUConvert:
+    case Op::OpFConvert:
+    case Op::OpSConvert:
+    case Op::OpUConvert:
         // Look for any 8/16-bit storage capabilities. If there are none, assume that
         // the convert instruction requires the Float16/Int8/16 capability.
-        if (containsType(typeId, OpTypeFloat, 16) || containsType(typeId, OpTypeInt, 16)) {
+        if (containsType(typeId, Op::OpTypeFloat, 16) || containsType(typeId, Op::OpTypeInt, 16)) {
             bool foundStorage = false;
             for (auto it = capabilities.begin(); it != capabilities.end(); ++it) {
                 spv::Capability cap = *it;
-                if (cap == spv::CapabilityStorageInputOutput16 ||
-                    cap == spv::CapabilityStoragePushConstant16 ||
-                    cap == spv::CapabilityStorageUniformBufferBlock16 ||
-                    cap == spv::CapabilityStorageUniform16) {
+                if (cap == spv::Capability::StorageInputOutput16 ||
+                    cap == spv::Capability::StoragePushConstant16 ||
+                    cap == spv::Capability::StorageUniformBufferBlock16 ||
+                    cap == spv::Capability::StorageUniform16) {
                     foundStorage = true;
                     break;
                 }
             }
             if (!foundStorage) {
-                if (containsType(typeId, OpTypeFloat, 16))
-                    addCapability(CapabilityFloat16);
-                if (containsType(typeId, OpTypeInt, 16))
-                    addCapability(CapabilityInt16);
+                if (containsType(typeId, Op::OpTypeFloat, 16))
+                    addCapability(Capability::Float16);
+                if (containsType(typeId, Op::OpTypeInt, 16))
+                    addCapability(Capability::Int16);
             }
         }
-        if (containsType(typeId, OpTypeInt, 8)) {
+        if (containsType(typeId, Op::OpTypeInt, 8)) {
             bool foundStorage = false;
             for (auto it = capabilities.begin(); it != capabilities.end(); ++it) {
                 spv::Capability cap = *it;
-                if (cap == spv::CapabilityStoragePushConstant8 ||
-                    cap == spv::CapabilityUniformAndStorageBuffer8BitAccess ||
-                    cap == spv::CapabilityStorageBuffer8BitAccess) {
+                if (cap == spv::Capability::StoragePushConstant8 ||
+                    cap == spv::Capability::UniformAndStorageBuffer8BitAccess ||
+                    cap == spv::Capability::StorageBuffer8BitAccess) {
                     foundStorage = true;
                     break;
                 }
             }
             if (!foundStorage) {
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
             }
         }
         break;
-    case OpExtInst:
+    case Op::OpExtInst:
         switch (inst.getImmediateOperand(1)) {
         case GLSLstd450Frexp:
         case GLSLstd450FrexpStruct:
-            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, OpTypeInt, 16))
+            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, Op::OpTypeInt, 16))
                 addExtension(spv::E_SPV_AMD_gpu_shader_int16);
             break;
         case GLSLstd450InterpolateAtCentroid:
         case GLSLstd450InterpolateAtSample:
         case GLSLstd450InterpolateAtOffset:
-            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, OpTypeFloat, 16))
+            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, Op::OpTypeFloat, 16))
                 addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
             break;
         default:
             break;
         }
         break;
-    case OpAccessChain:
-    case OpPtrAccessChain:
+    case Op::OpAccessChain:
+    case Op::OpPtrAccessChain:
         if (isPointerType(typeId))
             break;
-        if (basicTypeOp == OpTypeInt) {
+        if (basicTypeOp == Op::OpTypeInt) {
             if (width == 16)
-                addCapability(CapabilityInt16);
+                addCapability(Capability::Int16);
             else if (width == 8)
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
         }
         break;
     default:
-        if (basicTypeOp == OpTypeInt) {
+        if (basicTypeOp == Op::OpTypeInt) {
             if (width == 16)
-                addCapability(CapabilityInt16);
+                addCapability(Capability::Int16);
             else if (width == 8)
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
             else if (width == 64)
-                addCapability(CapabilityInt64);
-        } else if (basicTypeOp == OpTypeFloat) {
+                addCapability(Capability::Int64);
+        } else if (basicTypeOp == Op::OpTypeFloat) {
             if (width == 16)
-                addCapability(CapabilityFloat16);
+                addCapability(Capability::Float16);
             else if (width == 64)
-                addCapability(CapabilityFloat64);
+                addCapability(Capability::Float64);
         }
         break;
     }
@@ -205,41 +206,41 @@ void Builder::postProcess(Instruction& inst)
 {
     // Add capabilities based simply on the opcode.
     switch (inst.getOpCode()) {
-    case OpExtInst:
+    case Op::OpExtInst:
         switch (inst.getImmediateOperand(1)) {
         case GLSLstd450InterpolateAtCentroid:
         case GLSLstd450InterpolateAtSample:
         case GLSLstd450InterpolateAtOffset:
-            addCapability(CapabilityInterpolationFunction);
+            addCapability(Capability::InterpolationFunction);
             break;
         default:
             break;
         }
         break;
-    case OpDPdxFine:
-    case OpDPdyFine:
-    case OpFwidthFine:
-    case OpDPdxCoarse:
-    case OpDPdyCoarse:
-    case OpFwidthCoarse:
-        addCapability(CapabilityDerivativeControl);
+    case Op::OpDPdxFine:
+    case Op::OpDPdyFine:
+    case Op::OpFwidthFine:
+    case Op::OpDPdxCoarse:
+    case Op::OpDPdyCoarse:
+    case Op::OpFwidthCoarse:
+        addCapability(Capability::DerivativeControl);
         break;
 
-    case OpImageQueryLod:
-    case OpImageQuerySize:
-    case OpImageQuerySizeLod:
-    case OpImageQuerySamples:
-    case OpImageQueryLevels:
-        addCapability(CapabilityImageQuery);
+    case Op::OpImageQueryLod:
+    case Op::OpImageQuerySize:
+    case Op::OpImageQuerySizeLod:
+    case Op::OpImageQuerySamples:
+    case Op::OpImageQueryLevels:
+        addCapability(Capability::ImageQuery);
         break;
 
-    case OpGroupNonUniformPartitionNV:
+    case Op::OpGroupNonUniformPartitionNV:
         addExtension(E_SPV_NV_shader_subgroup_partitioned);
-        addCapability(CapabilityGroupNonUniformPartitionedNV);
+        addCapability(Capability::GroupNonUniformPartitionedNV);
         break;
 
-    case OpLoad:
-    case OpStore:
+    case Op::OpLoad:
+    case Op::OpStore:
         {
             // For any load/store to a PhysicalStorageBufferEXT, walk the accesschain
             // index list to compute the misalignment. The pre-existing alignment value
@@ -247,13 +248,13 @@ void Builder::postProcess(Instruction& inst)
             // the reference type and any scalar component selection in the accesschain,
             // and this function computes the rest from the SPIR-V Offset decorations.
             Instruction *accessChain = module.getInstruction(inst.getIdOperand(0));
-            if (accessChain->getOpCode() == OpAccessChain) {
+            if (accessChain->getOpCode() == Op::OpAccessChain) {
                 Instruction *base = module.getInstruction(accessChain->getIdOperand(0));
                 // Get the type of the base of the access chain. It must be a pointer type.
                 Id typeId = base->getTypeId();
                 Instruction *type = module.getInstruction(typeId);
-                assert(type->getOpCode() == OpTypePointer);
-                if (type->getImmediateOperand(0) != StorageClassPhysicalStorageBufferEXT) {
+                assert(type->getOpCode() == Op::OpTypePointer);
+                if (type->getImmediateOperand(0) != StorageClass::PhysicalStorageBufferEXT) {
                     break;
                 }
                 // Get the pointee type.
@@ -266,16 +267,16 @@ void Builder::postProcess(Instruction& inst)
                 int alignment = 0;
                 for (int i = 1; i < accessChain->getNumOperands(); ++i) {
                     Instruction *idx = module.getInstruction(accessChain->getIdOperand(i));
-                    if (type->getOpCode() == OpTypeStruct) {
-                        assert(idx->getOpCode() == OpConstant);
+                    if (type->getOpCode() == Op::OpTypeStruct) {
+                        assert(idx->getOpCode() == Op::OpConstant);
                         unsigned int c = idx->getImmediateOperand(0);
 
                         const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
-                            if (decoration.get()->getOpCode() == OpMemberDecorate &&
+                            if (decoration.get()->getOpCode() == Op::OpMemberDecorate &&
                                 decoration.get()->getIdOperand(0) == typeId &&
                                 decoration.get()->getImmediateOperand(1) == c &&
-                                (decoration.get()->getImmediateOperand(2) == DecorationOffset ||
-                                 decoration.get()->getImmediateOperand(2) == DecorationMatrixStride)) {
+                                (decoration.get()->getImmediateOperand(2) == Decoration::Offset ||
+                                 decoration.get()->getImmediateOperand(2) == Decoration::MatrixStride)) {
                                 alignment |= decoration.get()->getImmediateOperand(3);
                             }
                         };
@@ -283,12 +284,12 @@ void Builder::postProcess(Instruction& inst)
                         // get the next member type
                         typeId = type->getIdOperand(c);
                         type = module.getInstruction(typeId);
-                    } else if (type->getOpCode() == OpTypeArray ||
-                               type->getOpCode() == OpTypeRuntimeArray) {
+                    } else if (type->getOpCode() == Op::OpTypeArray ||
+                               type->getOpCode() == Op::OpTypeRuntimeArray) {
                         const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
-                            if (decoration.get()->getOpCode() == OpDecorate &&
+                            if (decoration.get()->getOpCode() == Op::OpDecorate &&
                                 decoration.get()->getIdOperand(0) == typeId &&
-                                decoration.get()->getImmediateOperand(1) == DecorationArrayStride) {
+                                decoration.get()->getImmediateOperand(1) == Decoration::ArrayStride) {
                                 alignment |= decoration.get()->getImmediateOperand(2);
                             }
                         };
@@ -302,12 +303,12 @@ void Builder::postProcess(Instruction& inst)
                     }
                 }
                 assert(inst.getNumOperands() >= 3);
-                unsigned int memoryAccess = inst.getImmediateOperand((inst.getOpCode() == OpStore) ? 2 : 1);
-                assert(memoryAccess & MemoryAccessAlignedMask);
+                auto const memoryAccess = (MemoryAccessMask)inst.getImmediateOperand((inst.getOpCode() == Op::OpStore) ? 2 : 1);
+                assert(anySet(memoryAccess, MemoryAccessMask::Aligned));
                 static_cast<void>(memoryAccess);
                 // Compute the index of the alignment operand.
                 int alignmentIdx = 2;
-                if (inst.getOpCode() == OpStore)
+                if (inst.getOpCode() == Op::OpStore)
                     alignmentIdx++;
                 // Merge new and old (mis)alignment
                 alignment |= inst.getImmediateOperand(alignmentIdx);
@@ -404,17 +405,17 @@ void Builder::postProcessFeatures() {
     // Look for any 8/16 bit type in physical storage buffer class, and set the
     // appropriate capability. This happens in createSpvVariable for other storage
     // classes, but there isn't always a variable for physical storage buffer.
-    for (int t = 0; t < (int)groupedTypes[OpTypePointer].size(); ++t) {
-        Instruction* type = groupedTypes[OpTypePointer][t];
-        if (type->getImmediateOperand(0) == (unsigned)StorageClassPhysicalStorageBufferEXT) {
-            if (containsType(type->getIdOperand(1), OpTypeInt, 8)) {
+    for (int t = 0; t < (int)groupedTypes[enumCast(Op::OpTypePointer)].size(); ++t) {
+        Instruction* type = groupedTypes[enumCast(Op::OpTypePointer)][t];
+        if (type->getImmediateOperand(0) == (unsigned)StorageClass::PhysicalStorageBufferEXT) {
+            if (containsType(type->getIdOperand(1), Op::OpTypeInt, 8)) {
                 addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
-                addCapability(spv::CapabilityStorageBuffer8BitAccess);
+                addCapability(spv::Capability::StorageBuffer8BitAccess);
             }
-            if (containsType(type->getIdOperand(1), OpTypeInt, 16) ||
-                containsType(type->getIdOperand(1), OpTypeFloat, 16)) {
+            if (containsType(type->getIdOperand(1), Op::OpTypeInt, 16) ||
+                containsType(type->getIdOperand(1), Op::OpTypeFloat, 16)) {
                 addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
-                addCapability(spv::CapabilityStorageBuffer16BitAccess);
+                addCapability(spv::Capability::StorageBuffer16BitAccess);
             }
         }
     }
@@ -437,15 +438,15 @@ void Builder::postProcessFeatures() {
                     bool foundDecoration = false;
                     const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
                         if (decoration.get()->getIdOperand(0) == resultId &&
-                            decoration.get()->getOpCode() == OpDecorate &&
-                            (decoration.get()->getImmediateOperand(1) == spv::DecorationAliasedPointerEXT ||
-                             decoration.get()->getImmediateOperand(1) == spv::DecorationRestrictPointerEXT)) {
+                            decoration.get()->getOpCode() == Op::OpDecorate &&
+                            (decoration.get()->getImmediateOperand(1) == spv::Decoration::AliasedPointerEXT ||
+                             decoration.get()->getImmediateOperand(1) == spv::Decoration::RestrictPointerEXT)) {
                             foundDecoration = true;
                         }
                     };
                     std::for_each(decorations.begin(), decorations.end(), function);
                     if (!foundDecoration) {
-                        addDecoration(resultId, spv::DecorationAliasedPointerEXT);
+                        addDecoration(resultId, spv::Decoration::AliasedPointerEXT);
                     }
                 }
             }
@@ -454,13 +455,13 @@ void Builder::postProcessFeatures() {
 
     // If any Vulkan memory model-specific functionality is used, update the
     // OpMemoryModel to match.
-    if (capabilities.find(spv::CapabilityVulkanMemoryModelKHR) != capabilities.end()) {
-        memoryModel = spv::MemoryModelVulkanKHR;
+    if (capabilities.find(spv::Capability::VulkanMemoryModelKHR) != capabilities.end()) {
+        memoryModel = spv::MemoryModel::VulkanKHR;
         addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5);
     }
 
     // Add Aliased decoration if there's more than one Workgroup Block variable.
-    if (capabilities.find(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR) != capabilities.end()) {
+    if (capabilities.find(spv::Capability::WorkgroupMemoryExplicitLayoutKHR) != capabilities.end()) {
         assert(entryPoints.size() == 1);
         auto &ep = entryPoints[0];
 
@@ -471,16 +472,16 @@ void Builder::postProcessFeatures() {
 
             const Id id = ep->getIdOperand(i);
             const Instruction *instr = module.getInstruction(id);
-            if (instr->getOpCode() != spv::OpVariable)
+            if (instr->getOpCode() != spv::Op::OpVariable)
                 continue;
 
-            if (instr->getImmediateOperand(0) == spv::StorageClassWorkgroup)
+            if (instr->getImmediateOperand(0) == spv::StorageClass::Workgroup)
                 workgroup_variables.push_back(id);
         }
 
         if (workgroup_variables.size() > 1) {
             for (size_t i = 0; i < workgroup_variables.size(); i++)
-                addDecoration(workgroup_variables[i], spv::DecorationAliased);
+                addDecoration(workgroup_variables[i], spv::Decoration::Aliased);
         }
     }
 }
@@ -497,7 +498,7 @@ void Builder::postProcessSamplers()
     for (auto f: module.getFunctions()) {
 	for (auto b: f->getBlocks()) {
 	    for (auto &i: b->getInstructions()) {
-		if (i->getOpCode() == spv::OpSampledImage) {
+        if (i->getOpCode() == spv::Op::OpSampledImage) {
 		    sampledImageInstrs[i->getResultId()] = i.get();
 		}
 	    }
@@ -518,7 +519,7 @@ void Builder::postProcessSamplers()
                         if (i->getBlock() != opSampImg->getBlock()) {
                             Instruction *newInstr = new Instruction(getUniqueId(),
                                                                     opSampImg->getTypeId(),
-                                                                    spv::OpSampledImage);
+                                                                    spv::Op::OpSampledImage);
                             newInstr->addIdOperand(opSampImg->getIdOperand(0));
                             newInstr->addIdOperand(opSampImg->getIdOperand(1));
                             newInstr->setBlock(b);

SPIRV/disassemble.cpp

@@ -48,6 +48,7 @@
 
 #include "disassemble.h"
 #include "doc.h"
+#include "spvUtil.h"
 
 namespace spv {
     extern "C" {
@@ -97,7 +98,7 @@ public:
 protected:
     SpirvStream(const SpirvStream&);
     SpirvStream& operator=(const SpirvStream&);
-    Op getOpCode(int id) const { return idInstruction[id] ? (Op)(stream[idInstruction[id]] & OpCodeMask) : OpNop; }
+    Op getOpCode(int id) const { return idInstruction[id] ? (Op)(stream[idInstruction[id]] & OpCodeMask) : Op::OpNop; }
 
     // Output methods
     void outputIndent();
@@ -187,14 +188,14 @@ void SpirvStream::processInstructions()
 
         // Type <id>
         Id typeId = 0;
-        if (InstructionDesc[opCode].hasType()) {
+        if (InstructionDesc[enumCast(opCode)].hasType()) {
             typeId = stream[word++];
             --numOperands;
         }
 
         // Result <id>
         Id resultId = 0;
-        if (InstructionDesc[opCode].hasResult()) {
+        if (InstructionDesc[enumCast(opCode)].hasResult()) {
             resultId = stream[word++];
             --numOperands;
 
@@ -355,22 +356,22 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
 {
     // Process the opcode
 
-    out << (OpcodeString(opCode) + 2);  // leave out the "Op"
+    out << (OpcodeString((int)opCode) + 2);  // leave out the "Op"
 
-    if (opCode == OpLoopMerge || opCode == OpSelectionMerge)
+    if (opCode == Op::OpLoopMerge || opCode == Op::OpSelectionMerge)
         nextNestedControl = stream[word];
-    else if (opCode == OpBranchConditional || opCode == OpSwitch) {
+    else if (opCode == Op::OpBranchConditional || opCode == Op::OpSwitch) {
         if (nextNestedControl) {
             nestedControl.push(nextNestedControl);
             nextNestedControl = 0;
         }
-    } else if (opCode == OpExtInstImport) {
+    } else if (opCode == Op::OpExtInstImport) {
         idDescriptor[resultId] = decodeString().second;
     }
     else {
         if (resultId != 0 && idDescriptor[resultId].size() == 0) {
             switch (opCode) {
-            case OpTypeInt:
+            case Op::OpTypeInt:
                 switch (stream[word]) {
                 case 8:  idDescriptor[resultId] = "int8_t"; break;
                 case 16: idDescriptor[resultId] = "int16_t"; break;
@@ -379,10 +380,10 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 case 64: idDescriptor[resultId] = "int64_t"; break;
                 }
                 break;
-            case OpTypeFloat:
+            case Op::OpTypeFloat:
                 switch (stream[word]) {
                 case 16:
-                    if (numOperands > 1 && stream[word+1] == spv::FPEncodingBFloat16KHR) {
+                    if (numOperands > 1 && stream[word+1] == spv::FPEncoding::BFloat16KHR) {
                         idDescriptor[resultId] = "bfloat16_t";
                     } else {
                         idDescriptor[resultId] = "float16_t";
@@ -393,16 +394,16 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 case 64: idDescriptor[resultId] = "float64_t"; break;
                 }
                 break;
-            case OpTypeBool:
+            case Op::OpTypeBool:
                 idDescriptor[resultId] = "bool";
                 break;
-            case OpTypeStruct:
+            case Op::OpTypeStruct:
                 idDescriptor[resultId] = "struct";
                 break;
-            case OpTypePointer:
+            case Op::OpTypePointer:
                 idDescriptor[resultId] = "ptr";
                 break;
-            case OpTypeVector:
+            case Op::OpTypeVector:
                 if (idDescriptor[stream[word]].size() > 0) {
                     if (idDescriptor[stream[word]].substr(0,2) == "bf") {
                         idDescriptor[resultId].append(idDescriptor[stream[word]].begin(), idDescriptor[stream[word]].begin() + 2);
@@ -440,10 +441,10 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
     // swapped in mid-traversal.
 
     // Handle images specially, so can put out helpful strings.
-    if (opCode == OpTypeImage) {
+    if (opCode == Op::OpTypeImage) {
         out << " ";
         disassembleIds(1);
-        out << " " << DimensionString((Dim)stream[word++]);
+        out << " " << DimensionString((int)(Dim)stream[word++]);
         out << (stream[word++] != 0 ? " depth" : "");
         out << (stream[word++] != 0 ? " array" : "");
         out << (stream[word++] != 0 ? " multi-sampled" : "");
@@ -452,7 +453,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
         case 1: out << " sampled";    break;
         case 2: out << " nonsampled"; break;
         }
-        out << " format:" << ImageFormatString((ImageFormat)stream[word++]);
+        out << " format:" << ImageFormatString((int)(ImageFormat)stream[word++]);
 
         if (numOperands == 8) {
             out << " " << AccessQualifierString(stream[word++]);
@@ -461,9 +462,9 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
     }
 
     // Handle all the parameterized operands
-    for (int op = 0; op < InstructionDesc[opCode].operands.getNum() && numOperands > 0; ++op) {
+    for (int op = 0; op < InstructionDesc[enumCast(opCode)].operands.getNum() && numOperands > 0; ++op) {
         out << " ";
-        OperandClass operandClass = InstructionDesc[opCode].operands.getClass(op);
+        OperandClass operandClass = InstructionDesc[enumCast(opCode)].operands.getClass(op);
         switch (operandClass) {
         case OperandId:
         case OperandScope:
@@ -471,7 +472,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
             disassembleIds(1);
             --numOperands;
             // Get names for printing "(XXX)" for readability, *after* this id
-            if (opCode == OpName)
+            if (opCode == Op::OpName)
                 idDescriptor[stream[word - 1]] = decodeString().second;
             break;
         case OperandVariableIds:
@@ -484,8 +485,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
             return;
         case OperandOptionalLiteral:
         case OperandVariableLiterals:
-            if ((opCode == OpDecorate && stream[word - 1] == DecorationBuiltIn) ||
-                (opCode == OpMemberDecorate && stream[word - 1] == DecorationBuiltIn)) {
+            if ((opCode == Op::OpDecorate && stream[word - 1] == Decoration::BuiltIn) ||
+                (opCode == Op::OpMemberDecorate && stream[word - 1] == Decoration::BuiltIn)) {
                 out << BuiltInString(stream[word++]);
                 --numOperands;
                 ++op;
@@ -521,7 +522,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
         case OperandLiteralNumber:
             disassembleImmediates(1);
             --numOperands;
-            if (opCode == OpExtInst) {
+            if (opCode == Op::OpExtInst) {
                 ExtInstSet extInstSet = GLSL450Inst;
                 const char* name = idDescriptor[stream[word - 2]].c_str();
                 if (strcmp("OpenCL.std", name) == 0) {
@@ -585,14 +586,14 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 uint32_t mask = stream[word-1];
                 // Aligned is the only memory access operand that uses an immediate
                 // value, and it is also the first operand that uses a value at all.
-                if (mask & MemoryAccessAlignedMask) {
+                if (mask & (uint32_t)MemoryAccessMask::Aligned) {
                     disassembleImmediates(1);
                     numOperands--;
                     if (numOperands)
                         out << " ";
                 }
 
-                uint32_t bitCount = popcount(mask & (MemoryAccessMakePointerAvailableMask | MemoryAccessMakePointerVisibleMask));
+                uint32_t bitCount = popcount(mask & (uint32_t)(MemoryAccessMask::MakePointerAvailable | MemoryAccessMask::MakePointerVisible));
                 disassembleIds(bitCount);
                 numOperands -= bitCount;
             }
@@ -767,41 +768,41 @@ static const char* GLSLextNVGetDebugNames(const char* name, unsigned entrypoint)
         strcmp(name, spv::E_SPV_NV_shader_image_footprint) == 0) {
         switch (entrypoint) {
         // NV builtins
-        case BuiltInViewportMaskNV:                 return "ViewportMaskNV";
-        case BuiltInSecondaryPositionNV:            return "SecondaryPositionNV";
-        case BuiltInSecondaryViewportMaskNV:        return "SecondaryViewportMaskNV";
-        case BuiltInPositionPerViewNV:              return "PositionPerViewNV";
-        case BuiltInViewportMaskPerViewNV:          return "ViewportMaskPerViewNV";
-        case BuiltInBaryCoordNV:                    return "BaryCoordNV";
-        case BuiltInBaryCoordNoPerspNV:             return "BaryCoordNoPerspNV";
-        case BuiltInTaskCountNV:                    return "TaskCountNV";
-        case BuiltInPrimitiveCountNV:               return "PrimitiveCountNV";
-        case BuiltInPrimitiveIndicesNV:             return "PrimitiveIndicesNV";
-        case BuiltInClipDistancePerViewNV:          return "ClipDistancePerViewNV";
-        case BuiltInCullDistancePerViewNV:          return "CullDistancePerViewNV";
-        case BuiltInLayerPerViewNV:                 return "LayerPerViewNV";
-        case BuiltInMeshViewCountNV:                return "MeshViewCountNV";
-        case BuiltInMeshViewIndicesNV:              return "MeshViewIndicesNV";
+        case (unsigned)BuiltIn::ViewportMaskNV:                 return "ViewportMaskNV";
+        case (unsigned)BuiltIn::SecondaryPositionNV:            return "SecondaryPositionNV";
+        case (unsigned)BuiltIn::SecondaryViewportMaskNV:        return "SecondaryViewportMaskNV";
+        case (unsigned)BuiltIn::PositionPerViewNV:              return "PositionPerViewNV";
+        case (unsigned)BuiltIn::ViewportMaskPerViewNV:          return "ViewportMaskPerViewNV";
+        case (unsigned)BuiltIn::BaryCoordNV:                    return "BaryCoordNV";
+        case (unsigned)BuiltIn::BaryCoordNoPerspNV:             return "BaryCoordNoPerspNV";
+        case (unsigned)BuiltIn::TaskCountNV:                    return "TaskCountNV";
+        case (unsigned)BuiltIn::PrimitiveCountNV:               return "PrimitiveCountNV";
+        case (unsigned)BuiltIn::PrimitiveIndicesNV:             return "PrimitiveIndicesNV";
+        case (unsigned)BuiltIn::ClipDistancePerViewNV:          return "ClipDistancePerViewNV";
+        case (unsigned)BuiltIn::CullDistancePerViewNV:          return "CullDistancePerViewNV";
+        case (unsigned)BuiltIn::LayerPerViewNV:                 return "LayerPerViewNV";
+        case (unsigned)BuiltIn::MeshViewCountNV:                return "MeshViewCountNV";
+        case (unsigned)BuiltIn::MeshViewIndicesNV:              return "MeshViewIndicesNV";
 
         // NV Capabilities
-        case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
-        case CapabilityShaderViewportMaskNV:        return "ShaderViewportMaskNV";
-        case CapabilityShaderStereoViewNV:          return "ShaderStereoViewNV";
-        case CapabilityPerViewAttributesNV:         return "PerViewAttributesNV";
-        case CapabilityFragmentBarycentricNV:       return "FragmentBarycentricNV";
-        case CapabilityMeshShadingNV:               return "MeshShadingNV";
-        case CapabilityImageFootprintNV:            return "ImageFootprintNV";
-        case CapabilitySampleMaskOverrideCoverageNV:return "SampleMaskOverrideCoverageNV";
+        case (unsigned)Capability::GeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
+        case (unsigned)Capability::ShaderViewportMaskNV:        return "ShaderViewportMaskNV";
+        case (unsigned)Capability::ShaderStereoViewNV:          return "ShaderStereoViewNV";
+        case (unsigned)Capability::PerViewAttributesNV:         return "PerViewAttributesNV";
+        case (unsigned)Capability::FragmentBarycentricNV:       return "FragmentBarycentricNV";
+        case (unsigned)Capability::MeshShadingNV:               return "MeshShadingNV";
+        case (unsigned)Capability::ImageFootprintNV:            return "ImageFootprintNV";
+        case (unsigned)Capability::SampleMaskOverrideCoverageNV:return "SampleMaskOverrideCoverageNV";
 
         // NV Decorations
-        case DecorationOverrideCoverageNV:          return "OverrideCoverageNV";
-        case DecorationPassthroughNV:               return "PassthroughNV";
-        case DecorationViewportRelativeNV:          return "ViewportRelativeNV";
-        case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
-        case DecorationPerVertexNV:                 return "PerVertexNV";
-        case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
-        case DecorationPerViewNV:                   return "PerViewNV";
-        case DecorationPerTaskNV:                   return "PerTaskNV";
+        case (unsigned)Decoration::OverrideCoverageNV:          return "OverrideCoverageNV";
+        case (unsigned)Decoration::PassthroughNV:               return "PassthroughNV";
+        case (unsigned)Decoration::ViewportRelativeNV:          return "ViewportRelativeNV";
+        case (unsigned)Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
+        case (unsigned)Decoration::PerVertexNV:                 return "PerVertexNV";
+        case (unsigned)Decoration::PerPrimitiveNV:              return "PerPrimitiveNV";
+        case (unsigned)Decoration::PerViewNV:                   return "PerViewNV";
+        case (unsigned)Decoration::PerTaskNV:                   return "PerTaskNV";
 
         default:                                    return "Bad";
         }

SPIRV/doc.h

@@ -38,7 +38,7 @@
 
 #pragma once
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 #include <vector>
 

SPIRV/spirv.hpp

@@ -1,5054 +0,0 @@
-// Copyright (c) 2014-2024 The Khronos Group Inc.
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and/or associated documentation files (the "Materials"),
-// to deal in the Materials without restriction, including without limitation
-// the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Materials, and to permit persons to whom the
-// Materials are furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Materials.
-// 
-// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-// 
-// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
-// IN THE MATERIALS.
-
-// This header is automatically generated by the same tool that creates
-// the Binary Section of the SPIR-V specification.
-
-// Enumeration tokens for SPIR-V, in various styles:
-//   C, C++, C++11, JSON, Lua, Python, C#, D, Beef
-// 
-// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
-// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
-// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
-// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
-// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
-// - C# will use enum classes in the Specification class located in the "Spv" namespace,
-//     e.g.: Spv.Specification.SourceLanguage.GLSL
-// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
-// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
-//     e.g.: Spv.Specification.SourceLanguage.GLSL
-// 
-// Some tokens act like mask values, which can be OR'd together,
-// while others are mutually exclusive.  The mask-like ones have
-// "Mask" in their name, and a parallel enum that has the shift
-// amount (1 << x) for each corresponding enumerant.
-
-#ifndef spirv_HPP
-#define spirv_HPP
-
-namespace spv {
-
-typedef unsigned int Id;
-
-#define SPV_VERSION 0x10600
-#define SPV_REVISION 1
-
-static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010600;
-static const unsigned int Revision = 1;
-static const unsigned int OpCodeMask = 0xffff;
-static const unsigned int WordCountShift = 16;
-
-enum SourceLanguage {
-    SourceLanguageUnknown = 0,
-    SourceLanguageESSL = 1,
-    SourceLanguageGLSL = 2,
-    SourceLanguageOpenCL_C = 3,
-    SourceLanguageOpenCL_CPP = 4,
-    SourceLanguageHLSL = 5,
-    SourceLanguageCPP_for_OpenCL = 6,
-    SourceLanguageSYCL = 7,
-    SourceLanguageHERO_C = 8,
-    SourceLanguageNZSL = 9,
-    SourceLanguageWGSL = 10,
-    SourceLanguageSlang = 11,
-    SourceLanguageZig = 12,
-    SourceLanguageMax = 0x7fffffff,
-};
-
-enum ExecutionModel {
-    ExecutionModelVertex = 0,
-    ExecutionModelTessellationControl = 1,
-    ExecutionModelTessellationEvaluation = 2,
-    ExecutionModelGeometry = 3,
-    ExecutionModelFragment = 4,
-    ExecutionModelGLCompute = 5,
-    ExecutionModelKernel = 6,
-    ExecutionModelTaskNV = 5267,
-    ExecutionModelMeshNV = 5268,
-    ExecutionModelRayGenerationKHR = 5313,
-    ExecutionModelRayGenerationNV = 5313,
-    ExecutionModelIntersectionKHR = 5314,
-    ExecutionModelIntersectionNV = 5314,
-    ExecutionModelAnyHitKHR = 5315,
-    ExecutionModelAnyHitNV = 5315,
-    ExecutionModelClosestHitKHR = 5316,
-    ExecutionModelClosestHitNV = 5316,
-    ExecutionModelMissKHR = 5317,
-    ExecutionModelMissNV = 5317,
-    ExecutionModelCallableKHR = 5318,
-    ExecutionModelCallableNV = 5318,
-    ExecutionModelTaskEXT = 5364,
-    ExecutionModelMeshEXT = 5365,
-    ExecutionModelMax = 0x7fffffff,
-};
-
-enum AddressingModel {
-    AddressingModelLogical = 0,
-    AddressingModelPhysical32 = 1,
-    AddressingModelPhysical64 = 2,
-    AddressingModelPhysicalStorageBuffer64 = 5348,
-    AddressingModelPhysicalStorageBuffer64EXT = 5348,
-    AddressingModelMax = 0x7fffffff,
-};
-
-enum MemoryModel {
-    MemoryModelSimple = 0,
-    MemoryModelGLSL450 = 1,
-    MemoryModelOpenCL = 2,
-    MemoryModelVulkan = 3,
-    MemoryModelVulkanKHR = 3,
-    MemoryModelMax = 0x7fffffff,
-};
-
-enum ExecutionMode {
-    ExecutionModeInvocations = 0,
-    ExecutionModeSpacingEqual = 1,
-    ExecutionModeSpacingFractionalEven = 2,
-    ExecutionModeSpacingFractionalOdd = 3,
-    ExecutionModeVertexOrderCw = 4,
-    ExecutionModeVertexOrderCcw = 5,
-    ExecutionModePixelCenterInteger = 6,
-    ExecutionModeOriginUpperLeft = 7,
-    ExecutionModeOriginLowerLeft = 8,
-    ExecutionModeEarlyFragmentTests = 9,
-    ExecutionModePointMode = 10,
-    ExecutionModeXfb = 11,
-    ExecutionModeDepthReplacing = 12,
-    ExecutionModeDepthGreater = 14,
-    ExecutionModeDepthLess = 15,
-    ExecutionModeDepthUnchanged = 16,
-    ExecutionModeLocalSize = 17,
-    ExecutionModeLocalSizeHint = 18,
-    ExecutionModeInputPoints = 19,
-    ExecutionModeInputLines = 20,
-    ExecutionModeInputLinesAdjacency = 21,
-    ExecutionModeTriangles = 22,
-    ExecutionModeInputTrianglesAdjacency = 23,
-    ExecutionModeQuads = 24,
-    ExecutionModeIsolines = 25,
-    ExecutionModeOutputVertices = 26,
-    ExecutionModeOutputPoints = 27,
-    ExecutionModeOutputLineStrip = 28,
-    ExecutionModeOutputTriangleStrip = 29,
-    ExecutionModeVecTypeHint = 30,
-    ExecutionModeContractionOff = 31,
-    ExecutionModeInitializer = 33,
-    ExecutionModeFinalizer = 34,
-    ExecutionModeSubgroupSize = 35,
-    ExecutionModeSubgroupsPerWorkgroup = 36,
-    ExecutionModeSubgroupsPerWorkgroupId = 37,
-    ExecutionModeLocalSizeId = 38,
-    ExecutionModeLocalSizeHintId = 39,
-    ExecutionModeNonCoherentColorAttachmentReadEXT = 4169,
-    ExecutionModeNonCoherentDepthAttachmentReadEXT = 4170,
-    ExecutionModeNonCoherentStencilAttachmentReadEXT = 4171,
-    ExecutionModeSubgroupUniformControlFlowKHR = 4421,
-    ExecutionModePostDepthCoverage = 4446,
-    ExecutionModeDenormPreserve = 4459,
-    ExecutionModeDenormFlushToZero = 4460,
-    ExecutionModeSignedZeroInfNanPreserve = 4461,
-    ExecutionModeRoundingModeRTE = 4462,
-    ExecutionModeRoundingModeRTZ = 4463,
-    ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
-    ExecutionModeStencilRefReplacingEXT = 5027,
-    ExecutionModeCoalescingAMDX = 5069,
-    ExecutionModeIsApiEntryAMDX = 5070,
-    ExecutionModeMaxNodeRecursionAMDX = 5071,
-    ExecutionModeStaticNumWorkgroupsAMDX = 5072,
-    ExecutionModeShaderIndexAMDX = 5073,
-    ExecutionModeMaxNumWorkgroupsAMDX = 5077,
-    ExecutionModeStencilRefUnchangedFrontAMD = 5079,
-    ExecutionModeStencilRefGreaterFrontAMD = 5080,
-    ExecutionModeStencilRefLessFrontAMD = 5081,
-    ExecutionModeStencilRefUnchangedBackAMD = 5082,
-    ExecutionModeStencilRefGreaterBackAMD = 5083,
-    ExecutionModeStencilRefLessBackAMD = 5084,
-    ExecutionModeQuadDerivativesKHR = 5088,
-    ExecutionModeRequireFullQuadsKHR = 5089,
-    ExecutionModeSharesInputWithAMDX = 5102,
-    ExecutionModeOutputLinesEXT = 5269,
-    ExecutionModeOutputLinesNV = 5269,
-    ExecutionModeOutputPrimitivesEXT = 5270,
-    ExecutionModeOutputPrimitivesNV = 5270,
-    ExecutionModeDerivativeGroupQuadsKHR = 5289,
-    ExecutionModeDerivativeGroupQuadsNV = 5289,
-    ExecutionModeDerivativeGroupLinearKHR = 5290,
-    ExecutionModeDerivativeGroupLinearNV = 5290,
-    ExecutionModeOutputTrianglesEXT = 5298,
-    ExecutionModeOutputTrianglesNV = 5298,
-    ExecutionModePixelInterlockOrderedEXT = 5366,
-    ExecutionModePixelInterlockUnorderedEXT = 5367,
-    ExecutionModeSampleInterlockOrderedEXT = 5368,
-    ExecutionModeSampleInterlockUnorderedEXT = 5369,
-    ExecutionModeShadingRateInterlockOrderedEXT = 5370,
-    ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
-    ExecutionModeSharedLocalMemorySizeINTEL = 5618,
-    ExecutionModeRoundingModeRTPINTEL = 5620,
-    ExecutionModeRoundingModeRTNINTEL = 5621,
-    ExecutionModeFloatingPointModeALTINTEL = 5622,
-    ExecutionModeFloatingPointModeIEEEINTEL = 5623,
-    ExecutionModeMaxWorkgroupSizeINTEL = 5893,
-    ExecutionModeMaxWorkDimINTEL = 5894,
-    ExecutionModeNoGlobalOffsetINTEL = 5895,
-    ExecutionModeNumSIMDWorkitemsINTEL = 5896,
-    ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
-    ExecutionModeMaximallyReconvergesKHR = 6023,
-    ExecutionModeFPFastMathDefault = 6028,
-    ExecutionModeStreamingInterfaceINTEL = 6154,
-    ExecutionModeRegisterMapInterfaceINTEL = 6160,
-    ExecutionModeNamedBarrierCountINTEL = 6417,
-    ExecutionModeMaximumRegistersINTEL = 6461,
-    ExecutionModeMaximumRegistersIdINTEL = 6462,
-    ExecutionModeNamedMaximumRegistersINTEL = 6463,
-    ExecutionModeMax = 0x7fffffff,
-};
-
-enum StorageClass {
-    StorageClassUniformConstant = 0,
-    StorageClassInput = 1,
-    StorageClassUniform = 2,
-    StorageClassOutput = 3,
-    StorageClassWorkgroup = 4,
-    StorageClassCrossWorkgroup = 5,
-    StorageClassPrivate = 6,
-    StorageClassFunction = 7,
-    StorageClassGeneric = 8,
-    StorageClassPushConstant = 9,
-    StorageClassAtomicCounter = 10,
-    StorageClassImage = 11,
-    StorageClassStorageBuffer = 12,
-    StorageClassTileImageEXT = 4172,
-    StorageClassNodePayloadAMDX = 5068,
-    StorageClassCallableDataKHR = 5328,
-    StorageClassCallableDataNV = 5328,
-    StorageClassIncomingCallableDataKHR = 5329,
-    StorageClassIncomingCallableDataNV = 5329,
-    StorageClassRayPayloadKHR = 5338,
-    StorageClassRayPayloadNV = 5338,
-    StorageClassHitAttributeKHR = 5339,
-    StorageClassHitAttributeNV = 5339,
-    StorageClassIncomingRayPayloadKHR = 5342,
-    StorageClassIncomingRayPayloadNV = 5342,
-    StorageClassShaderRecordBufferKHR = 5343,
-    StorageClassShaderRecordBufferNV = 5343,
-    StorageClassPhysicalStorageBuffer = 5349,
-    StorageClassPhysicalStorageBufferEXT = 5349,
-    StorageClassHitObjectAttributeNV = 5385,
-    StorageClassTaskPayloadWorkgroupEXT = 5402,
-    StorageClassCodeSectionINTEL = 5605,
-    StorageClassDeviceOnlyINTEL = 5936,
-    StorageClassHostOnlyINTEL = 5937,
-    StorageClassMax = 0x7fffffff,
-};
-
-enum Dim {
-    Dim1D = 0,
-    Dim2D = 1,
-    Dim3D = 2,
-    DimCube = 3,
-    DimRect = 4,
-    DimBuffer = 5,
-    DimSubpassData = 6,
-    DimTileImageDataEXT = 4173,
-    DimMax = 0x7fffffff,
-};
-
-enum SamplerAddressingMode {
-    SamplerAddressingModeNone = 0,
-    SamplerAddressingModeClampToEdge = 1,
-    SamplerAddressingModeClamp = 2,
-    SamplerAddressingModeRepeat = 3,
-    SamplerAddressingModeRepeatMirrored = 4,
-    SamplerAddressingModeMax = 0x7fffffff,
-};
-
-enum SamplerFilterMode {
-    SamplerFilterModeNearest = 0,
-    SamplerFilterModeLinear = 1,
-    SamplerFilterModeMax = 0x7fffffff,
-};
-
-enum ImageFormat {
-    ImageFormatUnknown = 0,
-    ImageFormatRgba32f = 1,
-    ImageFormatRgba16f = 2,
-    ImageFormatR32f = 3,
-    ImageFormatRgba8 = 4,
-    ImageFormatRgba8Snorm = 5,
-    ImageFormatRg32f = 6,
-    ImageFormatRg16f = 7,
-    ImageFormatR11fG11fB10f = 8,
-    ImageFormatR16f = 9,
-    ImageFormatRgba16 = 10,
-    ImageFormatRgb10A2 = 11,
-    ImageFormatRg16 = 12,
-    ImageFormatRg8 = 13,
-    ImageFormatR16 = 14,
-    ImageFormatR8 = 15,
-    ImageFormatRgba16Snorm = 16,
-    ImageFormatRg16Snorm = 17,
-    ImageFormatRg8Snorm = 18,
-    ImageFormatR16Snorm = 19,
-    ImageFormatR8Snorm = 20,
-    ImageFormatRgba32i = 21,
-    ImageFormatRgba16i = 22,
-    ImageFormatRgba8i = 23,
-    ImageFormatR32i = 24,
-    ImageFormatRg32i = 25,
-    ImageFormatRg16i = 26,
-    ImageFormatRg8i = 27,
-    ImageFormatR16i = 28,
-    ImageFormatR8i = 29,
-    ImageFormatRgba32ui = 30,
-    ImageFormatRgba16ui = 31,
-    ImageFormatRgba8ui = 32,
-    ImageFormatR32ui = 33,
-    ImageFormatRgb10a2ui = 34,
-    ImageFormatRg32ui = 35,
-    ImageFormatRg16ui = 36,
-    ImageFormatRg8ui = 37,
-    ImageFormatR16ui = 38,
-    ImageFormatR8ui = 39,
-    ImageFormatR64ui = 40,
-    ImageFormatR64i = 41,
-    ImageFormatMax = 0x7fffffff,
-};
-
-enum ImageChannelOrder {
-    ImageChannelOrderR = 0,
-    ImageChannelOrderA = 1,
-    ImageChannelOrderRG = 2,
-    ImageChannelOrderRA = 3,
-    ImageChannelOrderRGB = 4,
-    ImageChannelOrderRGBA = 5,
-    ImageChannelOrderBGRA = 6,
-    ImageChannelOrderARGB = 7,
-    ImageChannelOrderIntensity = 8,
-    ImageChannelOrderLuminance = 9,
-    ImageChannelOrderRx = 10,
-    ImageChannelOrderRGx = 11,
-    ImageChannelOrderRGBx = 12,
-    ImageChannelOrderDepth = 13,
-    ImageChannelOrderDepthStencil = 14,
-    ImageChannelOrdersRGB = 15,
-    ImageChannelOrdersRGBx = 16,
-    ImageChannelOrdersRGBA = 17,
-    ImageChannelOrdersBGRA = 18,
-    ImageChannelOrderABGR = 19,
-    ImageChannelOrderMax = 0x7fffffff,
-};
-
-enum ImageChannelDataType {
-    ImageChannelDataTypeSnormInt8 = 0,
-    ImageChannelDataTypeSnormInt16 = 1,
-    ImageChannelDataTypeUnormInt8 = 2,
-    ImageChannelDataTypeUnormInt16 = 3,
-    ImageChannelDataTypeUnormShort565 = 4,
-    ImageChannelDataTypeUnormShort555 = 5,
-    ImageChannelDataTypeUnormInt101010 = 6,
-    ImageChannelDataTypeSignedInt8 = 7,
-    ImageChannelDataTypeSignedInt16 = 8,
-    ImageChannelDataTypeSignedInt32 = 9,
-    ImageChannelDataTypeUnsignedInt8 = 10,
-    ImageChannelDataTypeUnsignedInt16 = 11,
-    ImageChannelDataTypeUnsignedInt32 = 12,
-    ImageChannelDataTypeHalfFloat = 13,
-    ImageChannelDataTypeFloat = 14,
-    ImageChannelDataTypeUnormInt24 = 15,
-    ImageChannelDataTypeUnormInt101010_2 = 16,
-    ImageChannelDataTypeUnsignedIntRaw10EXT = 19,
-    ImageChannelDataTypeUnsignedIntRaw12EXT = 20,
-    ImageChannelDataTypeUnormInt2_101010EXT = 21,
-    ImageChannelDataTypeMax = 0x7fffffff,
-};
-
-enum ImageOperandsShift {
-    ImageOperandsBiasShift = 0,
-    ImageOperandsLodShift = 1,
-    ImageOperandsGradShift = 2,
-    ImageOperandsConstOffsetShift = 3,
-    ImageOperandsOffsetShift = 4,
-    ImageOperandsConstOffsetsShift = 5,
-    ImageOperandsSampleShift = 6,
-    ImageOperandsMinLodShift = 7,
-    ImageOperandsMakeTexelAvailableShift = 8,
-    ImageOperandsMakeTexelAvailableKHRShift = 8,
-    ImageOperandsMakeTexelVisibleShift = 9,
-    ImageOperandsMakeTexelVisibleKHRShift = 9,
-    ImageOperandsNonPrivateTexelShift = 10,
-    ImageOperandsNonPrivateTexelKHRShift = 10,
-    ImageOperandsVolatileTexelShift = 11,
-    ImageOperandsVolatileTexelKHRShift = 11,
-    ImageOperandsSignExtendShift = 12,
-    ImageOperandsZeroExtendShift = 13,
-    ImageOperandsNontemporalShift = 14,
-    ImageOperandsOffsetsShift = 16,
-    ImageOperandsMax = 0x7fffffff,
-};
-
-enum ImageOperandsMask : unsigned {
-    ImageOperandsMaskNone = 0,
-    ImageOperandsBiasMask = 0x00000001,
-    ImageOperandsLodMask = 0x00000002,
-    ImageOperandsGradMask = 0x00000004,
-    ImageOperandsConstOffsetMask = 0x00000008,
-    ImageOperandsOffsetMask = 0x00000010,
-    ImageOperandsConstOffsetsMask = 0x00000020,
-    ImageOperandsSampleMask = 0x00000040,
-    ImageOperandsMinLodMask = 0x00000080,
-    ImageOperandsMakeTexelAvailableMask = 0x00000100,
-    ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
-    ImageOperandsMakeTexelVisibleMask = 0x00000200,
-    ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
-    ImageOperandsNonPrivateTexelMask = 0x00000400,
-    ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
-    ImageOperandsVolatileTexelMask = 0x00000800,
-    ImageOperandsVolatileTexelKHRMask = 0x00000800,
-    ImageOperandsSignExtendMask = 0x00001000,
-    ImageOperandsZeroExtendMask = 0x00002000,
-    ImageOperandsNontemporalMask = 0x00004000,
-    ImageOperandsOffsetsMask = 0x00010000,
-};
-
-enum FPFastMathModeShift {
-    FPFastMathModeNotNaNShift = 0,
-    FPFastMathModeNotInfShift = 1,
-    FPFastMathModeNSZShift = 2,
-    FPFastMathModeAllowRecipShift = 3,
-    FPFastMathModeFastShift = 4,
-    FPFastMathModeAllowContractShift = 16,
-    FPFastMathModeAllowContractFastINTELShift = 16,
-    FPFastMathModeAllowReassocShift = 17,
-    FPFastMathModeAllowReassocINTELShift = 17,
-    FPFastMathModeAllowTransformShift = 18,
-    FPFastMathModeMax = 0x7fffffff,
-};
-
-enum FPFastMathModeMask : unsigned {
-    FPFastMathModeMaskNone = 0,
-    FPFastMathModeNotNaNMask = 0x00000001,
-    FPFastMathModeNotInfMask = 0x00000002,
-    FPFastMathModeNSZMask = 0x00000004,
-    FPFastMathModeAllowRecipMask = 0x00000008,
-    FPFastMathModeFastMask = 0x00000010,
-    FPFastMathModeAllowContractMask = 0x00010000,
-    FPFastMathModeAllowContractFastINTELMask = 0x00010000,
-    FPFastMathModeAllowReassocMask = 0x00020000,
-    FPFastMathModeAllowReassocINTELMask = 0x00020000,
-    FPFastMathModeAllowTransformMask = 0x00040000,
-};
-
-enum FPRoundingMode {
-    FPRoundingModeRTE = 0,
-    FPRoundingModeRTZ = 1,
-    FPRoundingModeRTP = 2,
-    FPRoundingModeRTN = 3,
-    FPRoundingModeMax = 0x7fffffff,
-};
-
-enum LinkageType {
-    LinkageTypeExport = 0,
-    LinkageTypeImport = 1,
-    LinkageTypeLinkOnceODR = 2,
-    LinkageTypeMax = 0x7fffffff,
-};
-
-enum AccessQualifier {
-    AccessQualifierReadOnly = 0,
-    AccessQualifierWriteOnly = 1,
-    AccessQualifierReadWrite = 2,
-    AccessQualifierMax = 0x7fffffff,
-};
-
-enum FunctionParameterAttribute {
-    FunctionParameterAttributeZext = 0,
-    FunctionParameterAttributeSext = 1,
-    FunctionParameterAttributeByVal = 2,
-    FunctionParameterAttributeSret = 3,
-    FunctionParameterAttributeNoAlias = 4,
-    FunctionParameterAttributeNoCapture = 5,
-    FunctionParameterAttributeNoWrite = 6,
-    FunctionParameterAttributeNoReadWrite = 7,
-    FunctionParameterAttributeRuntimeAlignedINTEL = 5940,
-    FunctionParameterAttributeMax = 0x7fffffff,
-};
-
-enum Decoration {
-    DecorationRelaxedPrecision = 0,
-    DecorationSpecId = 1,
-    DecorationBlock = 2,
-    DecorationBufferBlock = 3,
-    DecorationRowMajor = 4,
-    DecorationColMajor = 5,
-    DecorationArrayStride = 6,
-    DecorationMatrixStride = 7,
-    DecorationGLSLShared = 8,
-    DecorationGLSLPacked = 9,
-    DecorationCPacked = 10,
-    DecorationBuiltIn = 11,
-    DecorationNoPerspective = 13,
-    DecorationFlat = 14,
-    DecorationPatch = 15,
-    DecorationCentroid = 16,
-    DecorationSample = 17,
-    DecorationInvariant = 18,
-    DecorationRestrict = 19,
-    DecorationAliased = 20,
-    DecorationVolatile = 21,
-    DecorationConstant = 22,
-    DecorationCoherent = 23,
-    DecorationNonWritable = 24,
-    DecorationNonReadable = 25,
-    DecorationUniform = 26,
-    DecorationUniformId = 27,
-    DecorationSaturatedConversion = 28,
-    DecorationStream = 29,
-    DecorationLocation = 30,
-    DecorationComponent = 31,
-    DecorationIndex = 32,
-    DecorationBinding = 33,
-    DecorationDescriptorSet = 34,
-    DecorationOffset = 35,
-    DecorationXfbBuffer = 36,
-    DecorationXfbStride = 37,
-    DecorationFuncParamAttr = 38,
-    DecorationFPRoundingMode = 39,
-    DecorationFPFastMathMode = 40,
-    DecorationLinkageAttributes = 41,
-    DecorationNoContraction = 42,
-    DecorationInputAttachmentIndex = 43,
-    DecorationAlignment = 44,
-    DecorationMaxByteOffset = 45,
-    DecorationAlignmentId = 46,
-    DecorationMaxByteOffsetId = 47,
-    DecorationNoSignedWrap = 4469,
-    DecorationNoUnsignedWrap = 4470,
-    DecorationWeightTextureQCOM = 4487,
-    DecorationBlockMatchTextureQCOM = 4488,
-    DecorationBlockMatchSamplerQCOM = 4499,
-    DecorationExplicitInterpAMD = 4999,
-    DecorationNodeSharesPayloadLimitsWithAMDX = 5019,
-    DecorationNodeMaxPayloadsAMDX = 5020,
-    DecorationTrackFinishWritingAMDX = 5078,
-    DecorationPayloadNodeNameAMDX = 5091,
-    DecorationPayloadNodeBaseIndexAMDX = 5098,
-    DecorationPayloadNodeSparseArrayAMDX = 5099,
-    DecorationPayloadNodeArraySizeAMDX = 5100,
-    DecorationPayloadDispatchIndirectAMDX = 5105,
-    DecorationOverrideCoverageNV = 5248,
-    DecorationPassthroughNV = 5250,
-    DecorationViewportRelativeNV = 5252,
-    DecorationSecondaryViewportRelativeNV = 5256,
-    DecorationPerPrimitiveEXT = 5271,
-    DecorationPerPrimitiveNV = 5271,
-    DecorationPerViewNV = 5272,
-    DecorationPerTaskNV = 5273,
-    DecorationPerVertexKHR = 5285,
-    DecorationPerVertexNV = 5285,
-    DecorationNonUniform = 5300,
-    DecorationNonUniformEXT = 5300,
-    DecorationRestrictPointer = 5355,
-    DecorationRestrictPointerEXT = 5355,
-    DecorationAliasedPointer = 5356,
-    DecorationAliasedPointerEXT = 5356,
-    DecorationHitObjectShaderRecordBufferNV = 5386,
-    DecorationBindlessSamplerNV = 5398,
-    DecorationBindlessImageNV = 5399,
-    DecorationBoundSamplerNV = 5400,
-    DecorationBoundImageNV = 5401,
-    DecorationSIMTCallINTEL = 5599,
-    DecorationReferencedIndirectlyINTEL = 5602,
-    DecorationClobberINTEL = 5607,
-    DecorationSideEffectsINTEL = 5608,
-    DecorationVectorComputeVariableINTEL = 5624,
-    DecorationFuncParamIOKindINTEL = 5625,
-    DecorationVectorComputeFunctionINTEL = 5626,
-    DecorationStackCallINTEL = 5627,
-    DecorationGlobalVariableOffsetINTEL = 5628,
-    DecorationCounterBuffer = 5634,
-    DecorationHlslCounterBufferGOOGLE = 5634,
-    DecorationHlslSemanticGOOGLE = 5635,
-    DecorationUserSemantic = 5635,
-    DecorationUserTypeGOOGLE = 5636,
-    DecorationFunctionRoundingModeINTEL = 5822,
-    DecorationFunctionDenormModeINTEL = 5823,
-    DecorationRegisterINTEL = 5825,
-    DecorationMemoryINTEL = 5826,
-    DecorationNumbanksINTEL = 5827,
-    DecorationBankwidthINTEL = 5828,
-    DecorationMaxPrivateCopiesINTEL = 5829,
-    DecorationSinglepumpINTEL = 5830,
-    DecorationDoublepumpINTEL = 5831,
-    DecorationMaxReplicatesINTEL = 5832,
-    DecorationSimpleDualPortINTEL = 5833,
-    DecorationMergeINTEL = 5834,
-    DecorationBankBitsINTEL = 5835,
-    DecorationForcePow2DepthINTEL = 5836,
-    DecorationStridesizeINTEL = 5883,
-    DecorationWordsizeINTEL = 5884,
-    DecorationTrueDualPortINTEL = 5885,
-    DecorationBurstCoalesceINTEL = 5899,
-    DecorationCacheSizeINTEL = 5900,
-    DecorationDontStaticallyCoalesceINTEL = 5901,
-    DecorationPrefetchINTEL = 5902,
-    DecorationStallEnableINTEL = 5905,
-    DecorationFuseLoopsInFunctionINTEL = 5907,
-    DecorationMathOpDSPModeINTEL = 5909,
-    DecorationAliasScopeINTEL = 5914,
-    DecorationNoAliasINTEL = 5915,
-    DecorationInitiationIntervalINTEL = 5917,
-    DecorationMaxConcurrencyINTEL = 5918,
-    DecorationPipelineEnableINTEL = 5919,
-    DecorationBufferLocationINTEL = 5921,
-    DecorationIOPipeStorageINTEL = 5944,
-    DecorationFunctionFloatingPointModeINTEL = 6080,
-    DecorationSingleElementVectorINTEL = 6085,
-    DecorationVectorComputeCallableFunctionINTEL = 6087,
-    DecorationMediaBlockIOINTEL = 6140,
-    DecorationStallFreeINTEL = 6151,
-    DecorationFPMaxErrorDecorationINTEL = 6170,
-    DecorationLatencyControlLabelINTEL = 6172,
-    DecorationLatencyControlConstraintINTEL = 6173,
-    DecorationConduitKernelArgumentINTEL = 6175,
-    DecorationRegisterMapKernelArgumentINTEL = 6176,
-    DecorationMMHostInterfaceAddressWidthINTEL = 6177,
-    DecorationMMHostInterfaceDataWidthINTEL = 6178,
-    DecorationMMHostInterfaceLatencyINTEL = 6179,
-    DecorationMMHostInterfaceReadWriteModeINTEL = 6180,
-    DecorationMMHostInterfaceMaxBurstINTEL = 6181,
-    DecorationMMHostInterfaceWaitRequestINTEL = 6182,
-    DecorationStableKernelArgumentINTEL = 6183,
-    DecorationHostAccessINTEL = 6188,
-    DecorationInitModeINTEL = 6190,
-    DecorationImplementInRegisterMapINTEL = 6191,
-    DecorationCacheControlLoadINTEL = 6442,
-    DecorationCacheControlStoreINTEL = 6443,
-    DecorationMax = 0x7fffffff,
-};
-
-enum BuiltIn {
-    BuiltInPosition = 0,
-    BuiltInPointSize = 1,
-    BuiltInClipDistance = 3,
-    BuiltInCullDistance = 4,
-    BuiltInVertexId = 5,
-    BuiltInInstanceId = 6,
-    BuiltInPrimitiveId = 7,
-    BuiltInInvocationId = 8,
-    BuiltInLayer = 9,
-    BuiltInViewportIndex = 10,
-    BuiltInTessLevelOuter = 11,
-    BuiltInTessLevelInner = 12,
-    BuiltInTessCoord = 13,
-    BuiltInPatchVertices = 14,
-    BuiltInFragCoord = 15,
-    BuiltInPointCoord = 16,
-    BuiltInFrontFacing = 17,
-    BuiltInSampleId = 18,
-    BuiltInSamplePosition = 19,
-    BuiltInSampleMask = 20,
-    BuiltInFragDepth = 22,
-    BuiltInHelperInvocation = 23,
-    BuiltInNumWorkgroups = 24,
-    BuiltInWorkgroupSize = 25,
-    BuiltInWorkgroupId = 26,
-    BuiltInLocalInvocationId = 27,
-    BuiltInGlobalInvocationId = 28,
-    BuiltInLocalInvocationIndex = 29,
-    BuiltInWorkDim = 30,
-    BuiltInGlobalSize = 31,
-    BuiltInEnqueuedWorkgroupSize = 32,
-    BuiltInGlobalOffset = 33,
-    BuiltInGlobalLinearId = 34,
-    BuiltInSubgroupSize = 36,
-    BuiltInSubgroupMaxSize = 37,
-    BuiltInNumSubgroups = 38,
-    BuiltInNumEnqueuedSubgroups = 39,
-    BuiltInSubgroupId = 40,
-    BuiltInSubgroupLocalInvocationId = 41,
-    BuiltInVertexIndex = 42,
-    BuiltInInstanceIndex = 43,
-    BuiltInCoreIDARM = 4160,
-    BuiltInCoreCountARM = 4161,
-    BuiltInCoreMaxIDARM = 4162,
-    BuiltInWarpIDARM = 4163,
-    BuiltInWarpMaxIDARM = 4164,
-    BuiltInSubgroupEqMask = 4416,
-    BuiltInSubgroupEqMaskKHR = 4416,
-    BuiltInSubgroupGeMask = 4417,
-    BuiltInSubgroupGeMaskKHR = 4417,
-    BuiltInSubgroupGtMask = 4418,
-    BuiltInSubgroupGtMaskKHR = 4418,
-    BuiltInSubgroupLeMask = 4419,
-    BuiltInSubgroupLeMaskKHR = 4419,
-    BuiltInSubgroupLtMask = 4420,
-    BuiltInSubgroupLtMaskKHR = 4420,
-    BuiltInBaseVertex = 4424,
-    BuiltInBaseInstance = 4425,
-    BuiltInDrawIndex = 4426,
-    BuiltInPrimitiveShadingRateKHR = 4432,
-    BuiltInDeviceIndex = 4438,
-    BuiltInViewIndex = 4440,
-    BuiltInShadingRateKHR = 4444,
-    BuiltInBaryCoordNoPerspAMD = 4992,
-    BuiltInBaryCoordNoPerspCentroidAMD = 4993,
-    BuiltInBaryCoordNoPerspSampleAMD = 4994,
-    BuiltInBaryCoordSmoothAMD = 4995,
-    BuiltInBaryCoordSmoothCentroidAMD = 4996,
-    BuiltInBaryCoordSmoothSampleAMD = 4997,
-    BuiltInBaryCoordPullModelAMD = 4998,
-    BuiltInFragStencilRefEXT = 5014,
-    BuiltInRemainingRecursionLevelsAMDX = 5021,
-    BuiltInShaderIndexAMDX = 5073,
-    BuiltInViewportMaskNV = 5253,
-    BuiltInSecondaryPositionNV = 5257,
-    BuiltInSecondaryViewportMaskNV = 5258,
-    BuiltInPositionPerViewNV = 5261,
-    BuiltInViewportMaskPerViewNV = 5262,
-    BuiltInFullyCoveredEXT = 5264,
-    BuiltInTaskCountNV = 5274,
-    BuiltInPrimitiveCountNV = 5275,
-    BuiltInPrimitiveIndicesNV = 5276,
-    BuiltInClipDistancePerViewNV = 5277,
-    BuiltInCullDistancePerViewNV = 5278,
-    BuiltInLayerPerViewNV = 5279,
-    BuiltInMeshViewCountNV = 5280,
-    BuiltInMeshViewIndicesNV = 5281,
-    BuiltInBaryCoordKHR = 5286,
-    BuiltInBaryCoordNV = 5286,
-    BuiltInBaryCoordNoPerspKHR = 5287,
-    BuiltInBaryCoordNoPerspNV = 5287,
-    BuiltInFragSizeEXT = 5292,
-    BuiltInFragmentSizeNV = 5292,
-    BuiltInFragInvocationCountEXT = 5293,
-    BuiltInInvocationsPerPixelNV = 5293,
-    BuiltInPrimitivePointIndicesEXT = 5294,
-    BuiltInPrimitiveLineIndicesEXT = 5295,
-    BuiltInPrimitiveTriangleIndicesEXT = 5296,
-    BuiltInCullPrimitiveEXT = 5299,
-    BuiltInLaunchIdKHR = 5319,
-    BuiltInLaunchIdNV = 5319,
-    BuiltInLaunchSizeKHR = 5320,
-    BuiltInLaunchSizeNV = 5320,
-    BuiltInWorldRayOriginKHR = 5321,
-    BuiltInWorldRayOriginNV = 5321,
-    BuiltInWorldRayDirectionKHR = 5322,
-    BuiltInWorldRayDirectionNV = 5322,
-    BuiltInObjectRayOriginKHR = 5323,
-    BuiltInObjectRayOriginNV = 5323,
-    BuiltInObjectRayDirectionKHR = 5324,
-    BuiltInObjectRayDirectionNV = 5324,
-    BuiltInRayTminKHR = 5325,
-    BuiltInRayTminNV = 5325,
-    BuiltInRayTmaxKHR = 5326,
-    BuiltInRayTmaxNV = 5326,
-    BuiltInInstanceCustomIndexKHR = 5327,
-    BuiltInInstanceCustomIndexNV = 5327,
-    BuiltInObjectToWorldKHR = 5330,
-    BuiltInObjectToWorldNV = 5330,
-    BuiltInWorldToObjectKHR = 5331,
-    BuiltInWorldToObjectNV = 5331,
-    BuiltInHitTNV = 5332,
-    BuiltInHitKindKHR = 5333,
-    BuiltInHitKindNV = 5333,
-    BuiltInCurrentRayTimeNV = 5334,
-    BuiltInHitTriangleVertexPositionsKHR = 5335,
-    BuiltInHitMicroTriangleVertexPositionsNV = 5337,
-    BuiltInHitMicroTriangleVertexBarycentricsNV = 5344,
-    BuiltInIncomingRayFlagsKHR = 5351,
-    BuiltInIncomingRayFlagsNV = 5351,
-    BuiltInRayGeometryIndexKHR = 5352,
-    BuiltInHitIsSphereNV = 5359,
-    BuiltInHitIsLSSNV = 5360,
-    BuiltInHitSpherePositionNV = 5361,
-    BuiltInWarpsPerSMNV = 5374,
-    BuiltInSMCountNV = 5375,
-    BuiltInWarpIDNV = 5376,
-    BuiltInSMIDNV = 5377,
-    BuiltInHitLSSPositionsNV = 5396,
-    BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
-    BuiltInHitKindBackFacingMicroTriangleNV = 5406,
-    BuiltInHitSphereRadiusNV = 5420,
-    BuiltInHitLSSRadiiNV = 5421,
-    BuiltInClusterIDNV = 5436,
-    BuiltInCullMaskKHR = 6021,
-    BuiltInMax = 0x7fffffff,
-};
-
-enum SelectionControlShift {
-    SelectionControlFlattenShift = 0,
-    SelectionControlDontFlattenShift = 1,
-    SelectionControlMax = 0x7fffffff,
-};
-
-enum SelectionControlMask : unsigned {
-    SelectionControlMaskNone = 0,
-    SelectionControlFlattenMask = 0x00000001,
-    SelectionControlDontFlattenMask = 0x00000002,
-};
-
-enum LoopControlShift {
-    LoopControlUnrollShift = 0,
-    LoopControlDontUnrollShift = 1,
-    LoopControlDependencyInfiniteShift = 2,
-    LoopControlDependencyLengthShift = 3,
-    LoopControlMinIterationsShift = 4,
-    LoopControlMaxIterationsShift = 5,
-    LoopControlIterationMultipleShift = 6,
-    LoopControlPeelCountShift = 7,
-    LoopControlPartialCountShift = 8,
-    LoopControlInitiationIntervalINTELShift = 16,
-    LoopControlMaxConcurrencyINTELShift = 17,
-    LoopControlDependencyArrayINTELShift = 18,
-    LoopControlPipelineEnableINTELShift = 19,
-    LoopControlLoopCoalesceINTELShift = 20,
-    LoopControlMaxInterleavingINTELShift = 21,
-    LoopControlSpeculatedIterationsINTELShift = 22,
-    LoopControlNoFusionINTELShift = 23,
-    LoopControlLoopCountINTELShift = 24,
-    LoopControlMaxReinvocationDelayINTELShift = 25,
-    LoopControlMax = 0x7fffffff,
-};
-
-enum LoopControlMask : unsigned {
-    LoopControlMaskNone = 0,
-    LoopControlUnrollMask = 0x00000001,
-    LoopControlDontUnrollMask = 0x00000002,
-    LoopControlDependencyInfiniteMask = 0x00000004,
-    LoopControlDependencyLengthMask = 0x00000008,
-    LoopControlMinIterationsMask = 0x00000010,
-    LoopControlMaxIterationsMask = 0x00000020,
-    LoopControlIterationMultipleMask = 0x00000040,
-    LoopControlPeelCountMask = 0x00000080,
-    LoopControlPartialCountMask = 0x00000100,
-    LoopControlInitiationIntervalINTELMask = 0x00010000,
-    LoopControlMaxConcurrencyINTELMask = 0x00020000,
-    LoopControlDependencyArrayINTELMask = 0x00040000,
-    LoopControlPipelineEnableINTELMask = 0x00080000,
-    LoopControlLoopCoalesceINTELMask = 0x00100000,
-    LoopControlMaxInterleavingINTELMask = 0x00200000,
-    LoopControlSpeculatedIterationsINTELMask = 0x00400000,
-    LoopControlNoFusionINTELMask = 0x00800000,
-    LoopControlLoopCountINTELMask = 0x01000000,
-    LoopControlMaxReinvocationDelayINTELMask = 0x02000000,
-};
-
-enum FunctionControlShift {
-    FunctionControlInlineShift = 0,
-    FunctionControlDontInlineShift = 1,
-    FunctionControlPureShift = 2,
-    FunctionControlConstShift = 3,
-    FunctionControlOptNoneEXTShift = 16,
-    FunctionControlOptNoneINTELShift = 16,
-    FunctionControlMax = 0x7fffffff,
-};
-
-enum FunctionControlMask : unsigned {
-    FunctionControlMaskNone = 0,
-    FunctionControlInlineMask = 0x00000001,
-    FunctionControlDontInlineMask = 0x00000002,
-    FunctionControlPureMask = 0x00000004,
-    FunctionControlConstMask = 0x00000008,
-    FunctionControlOptNoneEXTMask = 0x00010000,
-    FunctionControlOptNoneINTELMask = 0x00010000,
-};
-
-enum MemorySemanticsShift {
-    MemorySemanticsAcquireShift = 1,
-    MemorySemanticsReleaseShift = 2,
-    MemorySemanticsAcquireReleaseShift = 3,
-    MemorySemanticsSequentiallyConsistentShift = 4,
-    MemorySemanticsUniformMemoryShift = 6,
-    MemorySemanticsSubgroupMemoryShift = 7,
-    MemorySemanticsWorkgroupMemoryShift = 8,
-    MemorySemanticsCrossWorkgroupMemoryShift = 9,
-    MemorySemanticsAtomicCounterMemoryShift = 10,
-    MemorySemanticsImageMemoryShift = 11,
-    MemorySemanticsOutputMemoryShift = 12,
-    MemorySemanticsOutputMemoryKHRShift = 12,
-    MemorySemanticsMakeAvailableShift = 13,
-    MemorySemanticsMakeAvailableKHRShift = 13,
-    MemorySemanticsMakeVisibleShift = 14,
-    MemorySemanticsMakeVisibleKHRShift = 14,
-    MemorySemanticsVolatileShift = 15,
-    MemorySemanticsMax = 0x7fffffff,
-};
-
-enum MemorySemanticsMask : unsigned {
-    MemorySemanticsMaskNone = 0,
-    MemorySemanticsAcquireMask = 0x00000002,
-    MemorySemanticsReleaseMask = 0x00000004,
-    MemorySemanticsAcquireReleaseMask = 0x00000008,
-    MemorySemanticsSequentiallyConsistentMask = 0x00000010,
-    MemorySemanticsUniformMemoryMask = 0x00000040,
-    MemorySemanticsSubgroupMemoryMask = 0x00000080,
-    MemorySemanticsWorkgroupMemoryMask = 0x00000100,
-    MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
-    MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
-    MemorySemanticsImageMemoryMask = 0x00000800,
-    MemorySemanticsOutputMemoryMask = 0x00001000,
-    MemorySemanticsOutputMemoryKHRMask = 0x00001000,
-    MemorySemanticsMakeAvailableMask = 0x00002000,
-    MemorySemanticsMakeAvailableKHRMask = 0x00002000,
-    MemorySemanticsMakeVisibleMask = 0x00004000,
-    MemorySemanticsMakeVisibleKHRMask = 0x00004000,
-    MemorySemanticsVolatileMask = 0x00008000,
-};
-
-enum MemoryAccessShift {
-    MemoryAccessVolatileShift = 0,
-    MemoryAccessAlignedShift = 1,
-    MemoryAccessNontemporalShift = 2,
-    MemoryAccessMakePointerAvailableShift = 3,
-    MemoryAccessMakePointerAvailableKHRShift = 3,
-    MemoryAccessMakePointerVisibleShift = 4,
-    MemoryAccessMakePointerVisibleKHRShift = 4,
-    MemoryAccessNonPrivatePointerShift = 5,
-    MemoryAccessNonPrivatePointerKHRShift = 5,
-    MemoryAccessAliasScopeINTELMaskShift = 16,
-    MemoryAccessNoAliasINTELMaskShift = 17,
-    MemoryAccessMax = 0x7fffffff,
-};
-
-enum MemoryAccessMask : unsigned {
-    MemoryAccessMaskNone = 0,
-    MemoryAccessVolatileMask = 0x00000001,
-    MemoryAccessAlignedMask = 0x00000002,
-    MemoryAccessNontemporalMask = 0x00000004,
-    MemoryAccessMakePointerAvailableMask = 0x00000008,
-    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
-    MemoryAccessMakePointerVisibleMask = 0x00000010,
-    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
-    MemoryAccessNonPrivatePointerMask = 0x00000020,
-    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
-    MemoryAccessAliasScopeINTELMaskMask = 0x00010000,
-    MemoryAccessNoAliasINTELMaskMask = 0x00020000,
-};
-
-enum Scope {
-    ScopeCrossDevice = 0,
-    ScopeDevice = 1,
-    ScopeWorkgroup = 2,
-    ScopeSubgroup = 3,
-    ScopeInvocation = 4,
-    ScopeQueueFamily = 5,
-    ScopeQueueFamilyKHR = 5,
-    ScopeShaderCallKHR = 6,
-    ScopeMax = 0x7fffffff,
-};
-
-enum GroupOperation {
-    GroupOperationReduce = 0,
-    GroupOperationInclusiveScan = 1,
-    GroupOperationExclusiveScan = 2,
-    GroupOperationClusteredReduce = 3,
-    GroupOperationPartitionedReduceNV = 6,
-    GroupOperationPartitionedInclusiveScanNV = 7,
-    GroupOperationPartitionedExclusiveScanNV = 8,
-    GroupOperationMax = 0x7fffffff,
-};
-
-enum KernelEnqueueFlags {
-    KernelEnqueueFlagsNoWait = 0,
-    KernelEnqueueFlagsWaitKernel = 1,
-    KernelEnqueueFlagsWaitWorkGroup = 2,
-    KernelEnqueueFlagsMax = 0x7fffffff,
-};
-
-enum KernelProfilingInfoShift {
-    KernelProfilingInfoCmdExecTimeShift = 0,
-    KernelProfilingInfoMax = 0x7fffffff,
-};
-
-enum KernelProfilingInfoMask : unsigned {
-    KernelProfilingInfoMaskNone = 0,
-    KernelProfilingInfoCmdExecTimeMask = 0x00000001,
-};
-
-enum Capability {
-    CapabilityMatrix = 0,
-    CapabilityShader = 1,
-    CapabilityGeometry = 2,
-    CapabilityTessellation = 3,
-    CapabilityAddresses = 4,
-    CapabilityLinkage = 5,
-    CapabilityKernel = 6,
-    CapabilityVector16 = 7,
-    CapabilityFloat16Buffer = 8,
-    CapabilityFloat16 = 9,
-    CapabilityFloat64 = 10,
-    CapabilityInt64 = 11,
-    CapabilityInt64Atomics = 12,
-    CapabilityImageBasic = 13,
-    CapabilityImageReadWrite = 14,
-    CapabilityImageMipmap = 15,
-    CapabilityPipes = 17,
-    CapabilityGroups = 18,
-    CapabilityDeviceEnqueue = 19,
-    CapabilityLiteralSampler = 20,
-    CapabilityAtomicStorage = 21,
-    CapabilityInt16 = 22,
-    CapabilityTessellationPointSize = 23,
-    CapabilityGeometryPointSize = 24,
-    CapabilityImageGatherExtended = 25,
-    CapabilityStorageImageMultisample = 27,
-    CapabilityUniformBufferArrayDynamicIndexing = 28,
-    CapabilitySampledImageArrayDynamicIndexing = 29,
-    CapabilityStorageBufferArrayDynamicIndexing = 30,
-    CapabilityStorageImageArrayDynamicIndexing = 31,
-    CapabilityClipDistance = 32,
-    CapabilityCullDistance = 33,
-    CapabilityImageCubeArray = 34,
-    CapabilitySampleRateShading = 35,
-    CapabilityImageRect = 36,
-    CapabilitySampledRect = 37,
-    CapabilityGenericPointer = 38,
-    CapabilityInt8 = 39,
-    CapabilityInputAttachment = 40,
-    CapabilitySparseResidency = 41,
-    CapabilityMinLod = 42,
-    CapabilitySampled1D = 43,
-    CapabilityImage1D = 44,
-    CapabilitySampledCubeArray = 45,
-    CapabilitySampledBuffer = 46,
-    CapabilityImageBuffer = 47,
-    CapabilityImageMSArray = 48,
-    CapabilityStorageImageExtendedFormats = 49,
-    CapabilityImageQuery = 50,
-    CapabilityDerivativeControl = 51,
-    CapabilityInterpolationFunction = 52,
-    CapabilityTransformFeedback = 53,
-    CapabilityGeometryStreams = 54,
-    CapabilityStorageImageReadWithoutFormat = 55,
-    CapabilityStorageImageWriteWithoutFormat = 56,
-    CapabilityMultiViewport = 57,
-    CapabilitySubgroupDispatch = 58,
-    CapabilityNamedBarrier = 59,
-    CapabilityPipeStorage = 60,
-    CapabilityGroupNonUniform = 61,
-    CapabilityGroupNonUniformVote = 62,
-    CapabilityGroupNonUniformArithmetic = 63,
-    CapabilityGroupNonUniformBallot = 64,
-    CapabilityGroupNonUniformShuffle = 65,
-    CapabilityGroupNonUniformShuffleRelative = 66,
-    CapabilityGroupNonUniformClustered = 67,
-    CapabilityGroupNonUniformQuad = 68,
-    CapabilityShaderLayer = 69,
-    CapabilityShaderViewportIndex = 70,
-    CapabilityUniformDecoration = 71,
-    CapabilityCoreBuiltinsARM = 4165,
-    CapabilityTileImageColorReadAccessEXT = 4166,
-    CapabilityTileImageDepthReadAccessEXT = 4167,
-    CapabilityTileImageStencilReadAccessEXT = 4168,
-    CapabilityCooperativeMatrixLayoutsARM = 4201,
-    CapabilityFragmentShadingRateKHR = 4422,
-    CapabilitySubgroupBallotKHR = 4423,
-    CapabilityDrawParameters = 4427,
-    CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
-    CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
-    CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
-    CapabilitySubgroupVoteKHR = 4431,
-    CapabilityStorageBuffer16BitAccess = 4433,
-    CapabilityStorageUniformBufferBlock16 = 4433,
-    CapabilityStorageUniform16 = 4434,
-    CapabilityUniformAndStorageBuffer16BitAccess = 4434,
-    CapabilityStoragePushConstant16 = 4435,
-    CapabilityStorageInputOutput16 = 4436,
-    CapabilityDeviceGroup = 4437,
-    CapabilityMultiView = 4439,
-    CapabilityVariablePointersStorageBuffer = 4441,
-    CapabilityVariablePointers = 4442,
-    CapabilityAtomicStorageOps = 4445,
-    CapabilitySampleMaskPostDepthCoverage = 4447,
-    CapabilityStorageBuffer8BitAccess = 4448,
-    CapabilityUniformAndStorageBuffer8BitAccess = 4449,
-    CapabilityStoragePushConstant8 = 4450,
-    CapabilityDenormPreserve = 4464,
-    CapabilityDenormFlushToZero = 4465,
-    CapabilitySignedZeroInfNanPreserve = 4466,
-    CapabilityRoundingModeRTE = 4467,
-    CapabilityRoundingModeRTZ = 4468,
-    CapabilityRayQueryProvisionalKHR = 4471,
-    CapabilityRayQueryKHR = 4472,
-    CapabilityUntypedPointersKHR = 4473,
-    CapabilityRayTraversalPrimitiveCullingKHR = 4478,
-    CapabilityRayTracingKHR = 4479,
-    CapabilityTextureSampleWeightedQCOM = 4484,
-    CapabilityTextureBoxFilterQCOM = 4485,
-    CapabilityTextureBlockMatchQCOM = 4486,
-    CapabilityTextureBlockMatch2QCOM = 4498,
-    CapabilityFloat16ImageAMD = 5008,
-    CapabilityImageGatherBiasLodAMD = 5009,
-    CapabilityFragmentMaskAMD = 5010,
-    CapabilityStencilExportEXT = 5013,
-    CapabilityImageReadWriteLodAMD = 5015,
-    CapabilityInt64ImageEXT = 5016,
-    CapabilityShaderClockKHR = 5055,
-    CapabilityShaderEnqueueAMDX = 5067,
-    CapabilityQuadControlKHR = 5087,
-    CapabilityBFloat16TypeKHR = 5116,
-    CapabilityBFloat16DotProductKHR = 5117,
-    CapabilityBFloat16CooperativeMatrixKHR = 5118,
-    CapabilitySampleMaskOverrideCoverageNV = 5249,
-    CapabilityGeometryShaderPassthroughNV = 5251,
-    CapabilityShaderViewportIndexLayerEXT = 5254,
-    CapabilityShaderViewportIndexLayerNV = 5254,
-    CapabilityShaderViewportMaskNV = 5255,
-    CapabilityShaderStereoViewNV = 5259,
-    CapabilityPerViewAttributesNV = 5260,
-    CapabilityFragmentFullyCoveredEXT = 5265,
-    CapabilityMeshShadingNV = 5266,
-    CapabilityImageFootprintNV = 5282,
-    CapabilityMeshShadingEXT = 5283,
-    CapabilityFragmentBarycentricKHR = 5284,
-    CapabilityFragmentBarycentricNV = 5284,
-    CapabilityComputeDerivativeGroupQuadsKHR = 5288,
-    CapabilityComputeDerivativeGroupQuadsNV = 5288,
-    CapabilityFragmentDensityEXT = 5291,
-    CapabilityShadingRateNV = 5291,
-    CapabilityGroupNonUniformPartitionedNV = 5297,
-    CapabilityShaderNonUniform = 5301,
-    CapabilityShaderNonUniformEXT = 5301,
-    CapabilityRuntimeDescriptorArray = 5302,
-    CapabilityRuntimeDescriptorArrayEXT = 5302,
-    CapabilityInputAttachmentArrayDynamicIndexing = 5303,
-    CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
-    CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
-    CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
-    CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
-    CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
-    CapabilityUniformBufferArrayNonUniformIndexing = 5306,
-    CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
-    CapabilitySampledImageArrayNonUniformIndexing = 5307,
-    CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
-    CapabilityStorageBufferArrayNonUniformIndexing = 5308,
-    CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
-    CapabilityStorageImageArrayNonUniformIndexing = 5309,
-    CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
-    CapabilityInputAttachmentArrayNonUniformIndexing = 5310,
-    CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
-    CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
-    CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
-    CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
-    CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
-    CapabilityRayTracingPositionFetchKHR = 5336,
-    CapabilityRayTracingNV = 5340,
-    CapabilityRayTracingMotionBlurNV = 5341,
-    CapabilityVulkanMemoryModel = 5345,
-    CapabilityVulkanMemoryModelKHR = 5345,
-    CapabilityVulkanMemoryModelDeviceScope = 5346,
-    CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
-    CapabilityPhysicalStorageBufferAddresses = 5347,
-    CapabilityPhysicalStorageBufferAddressesEXT = 5347,
-    CapabilityComputeDerivativeGroupLinearKHR = 5350,
-    CapabilityComputeDerivativeGroupLinearNV = 5350,
-    CapabilityRayTracingProvisionalKHR = 5353,
-    CapabilityCooperativeMatrixNV = 5357,
-    CapabilityFragmentShaderSampleInterlockEXT = 5363,
-    CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
-    CapabilityShaderSMBuiltinsNV = 5373,
-    CapabilityFragmentShaderPixelInterlockEXT = 5378,
-    CapabilityDemoteToHelperInvocation = 5379,
-    CapabilityDemoteToHelperInvocationEXT = 5379,
-    CapabilityDisplacementMicromapNV = 5380,
-    CapabilityRayTracingOpacityMicromapEXT = 5381,
-    CapabilityShaderInvocationReorderNV = 5383,
-    CapabilityBindlessTextureNV = 5390,
-    CapabilityRayQueryPositionFetchKHR = 5391,
-    CapabilityCooperativeVectorNV = 5394,
-    CapabilityAtomicFloat16VectorNV = 5404,
-    CapabilityRayTracingDisplacementMicromapNV = 5409,
-    CapabilityRawAccessChainsNV = 5414,
-    CapabilityRayTracingSpheresGeometryNV = 5418,
-    CapabilityRayTracingLinearSweptSpheresGeometryNV = 5419,
-    CapabilityCooperativeMatrixReductionsNV = 5430,
-    CapabilityCooperativeMatrixConversionsNV = 5431,
-    CapabilityCooperativeMatrixPerElementOperationsNV = 5432,
-    CapabilityCooperativeMatrixTensorAddressingNV = 5433,
-    CapabilityCooperativeMatrixBlockLoadsNV = 5434,
-    CapabilityCooperativeVectorTrainingNV = 5435,
-    CapabilityRayTracingClusterAccelerationStructureNV = 5437,
-    CapabilityTensorAddressingNV = 5439,
-    CapabilitySubgroupShuffleINTEL = 5568,
-    CapabilitySubgroupBufferBlockIOINTEL = 5569,
-    CapabilitySubgroupImageBlockIOINTEL = 5570,
-    CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
-    CapabilityRoundToInfinityINTEL = 5582,
-    CapabilityFloatingPointModeINTEL = 5583,
-    CapabilityIntegerFunctions2INTEL = 5584,
-    CapabilityFunctionPointersINTEL = 5603,
-    CapabilityIndirectReferencesINTEL = 5604,
-    CapabilityAsmINTEL = 5606,
-    CapabilityAtomicFloat32MinMaxEXT = 5612,
-    CapabilityAtomicFloat64MinMaxEXT = 5613,
-    CapabilityAtomicFloat16MinMaxEXT = 5616,
-    CapabilityVectorComputeINTEL = 5617,
-    CapabilityVectorAnyINTEL = 5619,
-    CapabilityExpectAssumeKHR = 5629,
-    CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
-    CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
-    CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
-    CapabilityVariableLengthArrayINTEL = 5817,
-    CapabilityFunctionFloatControlINTEL = 5821,
-    CapabilityFPGAMemoryAttributesINTEL = 5824,
-    CapabilityFPFastMathModeINTEL = 5837,
-    CapabilityArbitraryPrecisionIntegersINTEL = 5844,
-    CapabilityArbitraryPrecisionFloatingPointINTEL = 5845,
-    CapabilityUnstructuredLoopControlsINTEL = 5886,
-    CapabilityFPGALoopControlsINTEL = 5888,
-    CapabilityKernelAttributesINTEL = 5892,
-    CapabilityFPGAKernelAttributesINTEL = 5897,
-    CapabilityFPGAMemoryAccessesINTEL = 5898,
-    CapabilityFPGAClusterAttributesINTEL = 5904,
-    CapabilityLoopFuseINTEL = 5906,
-    CapabilityFPGADSPControlINTEL = 5908,
-    CapabilityMemoryAccessAliasingINTEL = 5910,
-    CapabilityFPGAInvocationPipeliningAttributesINTEL = 5916,
-    CapabilityFPGABufferLocationINTEL = 5920,
-    CapabilityArbitraryPrecisionFixedPointINTEL = 5922,
-    CapabilityUSMStorageClassesINTEL = 5935,
-    CapabilityRuntimeAlignedAttributeINTEL = 5939,
-    CapabilityIOPipesINTEL = 5943,
-    CapabilityBlockingPipesINTEL = 5945,
-    CapabilityFPGARegINTEL = 5948,
-    CapabilityDotProductInputAll = 6016,
-    CapabilityDotProductInputAllKHR = 6016,
-    CapabilityDotProductInput4x8Bit = 6017,
-    CapabilityDotProductInput4x8BitKHR = 6017,
-    CapabilityDotProductInput4x8BitPacked = 6018,
-    CapabilityDotProductInput4x8BitPackedKHR = 6018,
-    CapabilityDotProduct = 6019,
-    CapabilityDotProductKHR = 6019,
-    CapabilityRayCullMaskKHR = 6020,
-    CapabilityCooperativeMatrixKHR = 6022,
-    CapabilityReplicatedCompositesEXT = 6024,
-    CapabilityBitInstructions = 6025,
-    CapabilityGroupNonUniformRotateKHR = 6026,
-    CapabilityFloatControls2 = 6029,
-    CapabilityAtomicFloat32AddEXT = 6033,
-    CapabilityAtomicFloat64AddEXT = 6034,
-    CapabilityLongCompositesINTEL = 6089,
-    CapabilityOptNoneEXT = 6094,
-    CapabilityOptNoneINTEL = 6094,
-    CapabilityAtomicFloat16AddEXT = 6095,
-    CapabilityDebugInfoModuleINTEL = 6114,
-    CapabilityBFloat16ConversionINTEL = 6115,
-    CapabilitySplitBarrierINTEL = 6141,
-    CapabilityArithmeticFenceEXT = 6144,
-    CapabilityFPGAClusterAttributesV2INTEL = 6150,
-    CapabilityFPGAKernelAttributesv2INTEL = 6161,
-    CapabilityFPMaxErrorINTEL = 6169,
-    CapabilityFPGALatencyControlINTEL = 6171,
-    CapabilityFPGAArgumentInterfacesINTEL = 6174,
-    CapabilityGlobalVariableHostAccessINTEL = 6187,
-    CapabilityGlobalVariableFPGADecorationsINTEL = 6189,
-    CapabilitySubgroupBufferPrefetchINTEL = 6220,
-    CapabilityGroupUniformArithmeticKHR = 6400,
-    CapabilityMaskedGatherScatterINTEL = 6427,
-    CapabilityCacheControlsINTEL = 6441,
-    CapabilityRegisterLimitsINTEL = 6460,
-    CapabilityMax = 0x7fffffff,
-};
-
-enum RayFlagsShift {
-    RayFlagsOpaqueKHRShift = 0,
-    RayFlagsNoOpaqueKHRShift = 1,
-    RayFlagsTerminateOnFirstHitKHRShift = 2,
-    RayFlagsSkipClosestHitShaderKHRShift = 3,
-    RayFlagsCullBackFacingTrianglesKHRShift = 4,
-    RayFlagsCullFrontFacingTrianglesKHRShift = 5,
-    RayFlagsCullOpaqueKHRShift = 6,
-    RayFlagsCullNoOpaqueKHRShift = 7,
-    RayFlagsSkipTrianglesKHRShift = 8,
-    RayFlagsSkipAABBsKHRShift = 9,
-    RayFlagsForceOpacityMicromap2StateEXTShift = 10,
-    RayFlagsMax = 0x7fffffff,
-};
-
-enum RayFlagsMask : unsigned {
-    RayFlagsMaskNone = 0,
-    RayFlagsOpaqueKHRMask = 0x00000001,
-    RayFlagsNoOpaqueKHRMask = 0x00000002,
-    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
-    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
-    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
-    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
-    RayFlagsCullOpaqueKHRMask = 0x00000040,
-    RayFlagsCullNoOpaqueKHRMask = 0x00000080,
-    RayFlagsSkipTrianglesKHRMask = 0x00000100,
-    RayFlagsSkipAABBsKHRMask = 0x00000200,
-    RayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
-};
-
-enum RayQueryIntersection {
-    RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
-    RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
-    RayQueryIntersectionMax = 0x7fffffff,
-};
-
-enum RayQueryCommittedIntersectionType {
-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
-    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
-    RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
-};
-
-enum RayQueryCandidateIntersectionType {
-    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
-    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
-    RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
-};
-
-enum FragmentShadingRateShift {
-    FragmentShadingRateVertical2PixelsShift = 0,
-    FragmentShadingRateVertical4PixelsShift = 1,
-    FragmentShadingRateHorizontal2PixelsShift = 2,
-    FragmentShadingRateHorizontal4PixelsShift = 3,
-    FragmentShadingRateMax = 0x7fffffff,
-};
-
-enum FragmentShadingRateMask : unsigned {
-    FragmentShadingRateMaskNone = 0,
-    FragmentShadingRateVertical2PixelsMask = 0x00000001,
-    FragmentShadingRateVertical4PixelsMask = 0x00000002,
-    FragmentShadingRateHorizontal2PixelsMask = 0x00000004,
-    FragmentShadingRateHorizontal4PixelsMask = 0x00000008,
-};
-
-enum FPDenormMode {
-    FPDenormModePreserve = 0,
-    FPDenormModeFlushToZero = 1,
-    FPDenormModeMax = 0x7fffffff,
-};
-
-enum FPOperationMode {
-    FPOperationModeIEEE = 0,
-    FPOperationModeALT = 1,
-    FPOperationModeMax = 0x7fffffff,
-};
-
-enum QuantizationModes {
-    QuantizationModesTRN = 0,
-    QuantizationModesTRN_ZERO = 1,
-    QuantizationModesRND = 2,
-    QuantizationModesRND_ZERO = 3,
-    QuantizationModesRND_INF = 4,
-    QuantizationModesRND_MIN_INF = 5,
-    QuantizationModesRND_CONV = 6,
-    QuantizationModesRND_CONV_ODD = 7,
-    QuantizationModesMax = 0x7fffffff,
-};
-
-enum OverflowModes {
-    OverflowModesWRAP = 0,
-    OverflowModesSAT = 1,
-    OverflowModesSAT_ZERO = 2,
-    OverflowModesSAT_SYM = 3,
-    OverflowModesMax = 0x7fffffff,
-};
-
-enum PackedVectorFormat {
-    PackedVectorFormatPackedVectorFormat4x8Bit = 0,
-    PackedVectorFormatPackedVectorFormat4x8BitKHR = 0,
-    PackedVectorFormatMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixOperandsShift {
-    CooperativeMatrixOperandsMatrixASignedComponentsKHRShift = 0,
-    CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift = 1,
-    CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift = 2,
-    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift = 3,
-    CooperativeMatrixOperandsSaturatingAccumulationKHRShift = 4,
-    CooperativeMatrixOperandsMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixOperandsMask : unsigned {
-    CooperativeMatrixOperandsMaskNone = 0,
-    CooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001,
-    CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002,
-    CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004,
-    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008,
-    CooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010,
-};
-
-enum CooperativeMatrixLayout {
-    CooperativeMatrixLayoutRowMajorKHR = 0,
-    CooperativeMatrixLayoutColumnMajorKHR = 1,
-    CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202,
-    CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203,
-    CooperativeMatrixLayoutMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixUse {
-    CooperativeMatrixUseMatrixAKHR = 0,
-    CooperativeMatrixUseMatrixBKHR = 1,
-    CooperativeMatrixUseMatrixAccumulatorKHR = 2,
-    CooperativeMatrixUseMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixReduceShift {
-    CooperativeMatrixReduceRowShift = 0,
-    CooperativeMatrixReduceColumnShift = 1,
-    CooperativeMatrixReduce2x2Shift = 2,
-    CooperativeMatrixReduceMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixReduceMask : unsigned {
-    CooperativeMatrixReduceMaskNone = 0,
-    CooperativeMatrixReduceRowMask = 0x00000001,
-    CooperativeMatrixReduceColumnMask = 0x00000002,
-    CooperativeMatrixReduce2x2Mask = 0x00000004,
-};
-
-enum TensorClampMode {
-    TensorClampModeUndefined = 0,
-    TensorClampModeConstant = 1,
-    TensorClampModeClampToEdge = 2,
-    TensorClampModeRepeat = 3,
-    TensorClampModeRepeatMirrored = 4,
-    TensorClampModeMax = 0x7fffffff,
-};
-
-enum TensorAddressingOperandsShift {
-    TensorAddressingOperandsTensorViewShift = 0,
-    TensorAddressingOperandsDecodeFuncShift = 1,
-    TensorAddressingOperandsMax = 0x7fffffff,
-};
-
-enum TensorAddressingOperandsMask : unsigned {
-    TensorAddressingOperandsMaskNone = 0,
-    TensorAddressingOperandsTensorViewMask = 0x00000001,
-    TensorAddressingOperandsDecodeFuncMask = 0x00000002,
-};
-
-enum InitializationModeQualifier {
-    InitializationModeQualifierInitOnDeviceReprogramINTEL = 0,
-    InitializationModeQualifierInitOnDeviceResetINTEL = 1,
-    InitializationModeQualifierMax = 0x7fffffff,
-};
-
-enum HostAccessQualifier {
-    HostAccessQualifierNoneINTEL = 0,
-    HostAccessQualifierReadINTEL = 1,
-    HostAccessQualifierWriteINTEL = 2,
-    HostAccessQualifierReadWriteINTEL = 3,
-    HostAccessQualifierMax = 0x7fffffff,
-};
-
-enum LoadCacheControl {
-    LoadCacheControlUncachedINTEL = 0,
-    LoadCacheControlCachedINTEL = 1,
-    LoadCacheControlStreamingINTEL = 2,
-    LoadCacheControlInvalidateAfterReadINTEL = 3,
-    LoadCacheControlConstCachedINTEL = 4,
-    LoadCacheControlMax = 0x7fffffff,
-};
-
-enum StoreCacheControl {
-    StoreCacheControlUncachedINTEL = 0,
-    StoreCacheControlWriteThroughINTEL = 1,
-    StoreCacheControlWriteBackINTEL = 2,
-    StoreCacheControlStreamingINTEL = 3,
-    StoreCacheControlMax = 0x7fffffff,
-};
-
-enum NamedMaximumNumberOfRegisters {
-    NamedMaximumNumberOfRegistersAutoINTEL = 0,
-    NamedMaximumNumberOfRegistersMax = 0x7fffffff,
-};
-
-enum RawAccessChainOperandsShift {
-    RawAccessChainOperandsRobustnessPerComponentNVShift = 0,
-    RawAccessChainOperandsRobustnessPerElementNVShift = 1,
-    RawAccessChainOperandsMax = 0x7fffffff,
-};
-
-enum RawAccessChainOperandsMask : unsigned {
-    RawAccessChainOperandsMaskNone = 0,
-    RawAccessChainOperandsRobustnessPerComponentNVMask = 0x00000001,
-    RawAccessChainOperandsRobustnessPerElementNVMask = 0x00000002,
-};
-
-enum FPEncoding {
-    FPEncodingBFloat16KHR = 0,
-    FPEncodingMax = 0x7fffffff,
-};
-
-enum CooperativeVectorMatrixLayout {
-    CooperativeVectorMatrixLayoutRowMajorNV = 0,
-    CooperativeVectorMatrixLayoutColumnMajorNV = 1,
-    CooperativeVectorMatrixLayoutInferencingOptimalNV = 2,
-    CooperativeVectorMatrixLayoutTrainingOptimalNV = 3,
-    CooperativeVectorMatrixLayoutMax = 0x7fffffff,
-};
-
-enum ComponentType {
-    ComponentTypeFloat16NV = 0,
-    ComponentTypeFloat32NV = 1,
-    ComponentTypeFloat64NV = 2,
-    ComponentTypeSignedInt8NV = 3,
-    ComponentTypeSignedInt16NV = 4,
-    ComponentTypeSignedInt32NV = 5,
-    ComponentTypeSignedInt64NV = 6,
-    ComponentTypeUnsignedInt8NV = 7,
-    ComponentTypeUnsignedInt16NV = 8,
-    ComponentTypeUnsignedInt32NV = 9,
-    ComponentTypeUnsignedInt64NV = 10,
-    ComponentTypeSignedInt8PackedNV = 1000491000,
-    ComponentTypeUnsignedInt8PackedNV = 1000491001,
-    ComponentTypeFloatE4M3NV = 1000491002,
-    ComponentTypeFloatE5M2NV = 1000491003,
-    ComponentTypeMax = 0x7fffffff,
-};
-
-enum Op {
-    OpNop = 0,
-    OpUndef = 1,
-    OpSourceContinued = 2,
-    OpSource = 3,
-    OpSourceExtension = 4,
-    OpName = 5,
-    OpMemberName = 6,
-    OpString = 7,
-    OpLine = 8,
-    OpExtension = 10,
-    OpExtInstImport = 11,
-    OpExtInst = 12,
-    OpMemoryModel = 14,
-    OpEntryPoint = 15,
-    OpExecutionMode = 16,
-    OpCapability = 17,
-    OpTypeVoid = 19,
-    OpTypeBool = 20,
-    OpTypeInt = 21,
-    OpTypeFloat = 22,
-    OpTypeVector = 23,
-    OpTypeMatrix = 24,
-    OpTypeImage = 25,
-    OpTypeSampler = 26,
-    OpTypeSampledImage = 27,
-    OpTypeArray = 28,
-    OpTypeRuntimeArray = 29,
-    OpTypeStruct = 30,
-    OpTypeOpaque = 31,
-    OpTypePointer = 32,
-    OpTypeFunction = 33,
-    OpTypeEvent = 34,
-    OpTypeDeviceEvent = 35,
-    OpTypeReserveId = 36,
-    OpTypeQueue = 37,
-    OpTypePipe = 38,
-    OpTypeForwardPointer = 39,
-    OpConstantTrue = 41,
-    OpConstantFalse = 42,
-    OpConstant = 43,
-    OpConstantComposite = 44,
-    OpConstantSampler = 45,
-    OpConstantNull = 46,
-    OpSpecConstantTrue = 48,
-    OpSpecConstantFalse = 49,
-    OpSpecConstant = 50,
-    OpSpecConstantComposite = 51,
-    OpSpecConstantOp = 52,
-    OpFunction = 54,
-    OpFunctionParameter = 55,
-    OpFunctionEnd = 56,
-    OpFunctionCall = 57,
-    OpVariable = 59,
-    OpImageTexelPointer = 60,
-    OpLoad = 61,
-    OpStore = 62,
-    OpCopyMemory = 63,
-    OpCopyMemorySized = 64,
-    OpAccessChain = 65,
-    OpInBoundsAccessChain = 66,
-    OpPtrAccessChain = 67,
-    OpArrayLength = 68,
-    OpGenericPtrMemSemantics = 69,
-    OpInBoundsPtrAccessChain = 70,
-    OpDecorate = 71,
-    OpMemberDecorate = 72,
-    OpDecorationGroup = 73,
-    OpGroupDecorate = 74,
-    OpGroupMemberDecorate = 75,
-    OpVectorExtractDynamic = 77,
-    OpVectorInsertDynamic = 78,
-    OpVectorShuffle = 79,
-    OpCompositeConstruct = 80,
-    OpCompositeExtract = 81,
-    OpCompositeInsert = 82,
-    OpCopyObject = 83,
-    OpTranspose = 84,
-    OpSampledImage = 86,
-    OpImageSampleImplicitLod = 87,
-    OpImageSampleExplicitLod = 88,
-    OpImageSampleDrefImplicitLod = 89,
-    OpImageSampleDrefExplicitLod = 90,
-    OpImageSampleProjImplicitLod = 91,
-    OpImageSampleProjExplicitLod = 92,
-    OpImageSampleProjDrefImplicitLod = 93,
-    OpImageSampleProjDrefExplicitLod = 94,
-    OpImageFetch = 95,
-    OpImageGather = 96,
-    OpImageDrefGather = 97,
-    OpImageRead = 98,
-    OpImageWrite = 99,
-    OpImage = 100,
-    OpImageQueryFormat = 101,
-    OpImageQueryOrder = 102,
-    OpImageQuerySizeLod = 103,
-    OpImageQuerySize = 104,
-    OpImageQueryLod = 105,
-    OpImageQueryLevels = 106,
-    OpImageQuerySamples = 107,
-    OpConvertFToU = 109,
-    OpConvertFToS = 110,
-    OpConvertSToF = 111,
-    OpConvertUToF = 112,
-    OpUConvert = 113,
-    OpSConvert = 114,
-    OpFConvert = 115,
-    OpQuantizeToF16 = 116,
-    OpConvertPtrToU = 117,
-    OpSatConvertSToU = 118,
-    OpSatConvertUToS = 119,
-    OpConvertUToPtr = 120,
-    OpPtrCastToGeneric = 121,
-    OpGenericCastToPtr = 122,
-    OpGenericCastToPtrExplicit = 123,
-    OpBitcast = 124,
-    OpSNegate = 126,
-    OpFNegate = 127,
-    OpIAdd = 128,
-    OpFAdd = 129,
-    OpISub = 130,
-    OpFSub = 131,
-    OpIMul = 132,
-    OpFMul = 133,
-    OpUDiv = 134,
-    OpSDiv = 135,
-    OpFDiv = 136,
-    OpUMod = 137,
-    OpSRem = 138,
-    OpSMod = 139,
-    OpFRem = 140,
-    OpFMod = 141,
-    OpVectorTimesScalar = 142,
-    OpMatrixTimesScalar = 143,
-    OpVectorTimesMatrix = 144,
-    OpMatrixTimesVector = 145,
-    OpMatrixTimesMatrix = 146,
-    OpOuterProduct = 147,
-    OpDot = 148,
-    OpIAddCarry = 149,
-    OpISubBorrow = 150,
-    OpUMulExtended = 151,
-    OpSMulExtended = 152,
-    OpAny = 154,
-    OpAll = 155,
-    OpIsNan = 156,
-    OpIsInf = 157,
-    OpIsFinite = 158,
-    OpIsNormal = 159,
-    OpSignBitSet = 160,
-    OpLessOrGreater = 161,
-    OpOrdered = 162,
-    OpUnordered = 163,
-    OpLogicalEqual = 164,
-    OpLogicalNotEqual = 165,
-    OpLogicalOr = 166,
-    OpLogicalAnd = 167,
-    OpLogicalNot = 168,
-    OpSelect = 169,
-    OpIEqual = 170,
-    OpINotEqual = 171,
-    OpUGreaterThan = 172,
-    OpSGreaterThan = 173,
-    OpUGreaterThanEqual = 174,
-    OpSGreaterThanEqual = 175,
-    OpULessThan = 176,
-    OpSLessThan = 177,
-    OpULessThanEqual = 178,
-    OpSLessThanEqual = 179,
-    OpFOrdEqual = 180,
-    OpFUnordEqual = 181,
-    OpFOrdNotEqual = 182,
-    OpFUnordNotEqual = 183,
-    OpFOrdLessThan = 184,
-    OpFUnordLessThan = 185,
-    OpFOrdGreaterThan = 186,
-    OpFUnordGreaterThan = 187,
-    OpFOrdLessThanEqual = 188,
-    OpFUnordLessThanEqual = 189,
-    OpFOrdGreaterThanEqual = 190,
-    OpFUnordGreaterThanEqual = 191,
-    OpShiftRightLogical = 194,
-    OpShiftRightArithmetic = 195,
-    OpShiftLeftLogical = 196,
-    OpBitwiseOr = 197,
-    OpBitwiseXor = 198,
-    OpBitwiseAnd = 199,
-    OpNot = 200,
-    OpBitFieldInsert = 201,
-    OpBitFieldSExtract = 202,
-    OpBitFieldUExtract = 203,
-    OpBitReverse = 204,
-    OpBitCount = 205,
-    OpDPdx = 207,
-    OpDPdy = 208,
-    OpFwidth = 209,
-    OpDPdxFine = 210,
-    OpDPdyFine = 211,
-    OpFwidthFine = 212,
-    OpDPdxCoarse = 213,
-    OpDPdyCoarse = 214,
-    OpFwidthCoarse = 215,
-    OpEmitVertex = 218,
-    OpEndPrimitive = 219,
-    OpEmitStreamVertex = 220,
-    OpEndStreamPrimitive = 221,
-    OpControlBarrier = 224,
-    OpMemoryBarrier = 225,
-    OpAtomicLoad = 227,
-    OpAtomicStore = 228,
-    OpAtomicExchange = 229,
-    OpAtomicCompareExchange = 230,
-    OpAtomicCompareExchangeWeak = 231,
-    OpAtomicIIncrement = 232,
-    OpAtomicIDecrement = 233,
-    OpAtomicIAdd = 234,
-    OpAtomicISub = 235,
-    OpAtomicSMin = 236,
-    OpAtomicUMin = 237,
-    OpAtomicSMax = 238,
-    OpAtomicUMax = 239,
-    OpAtomicAnd = 240,
-    OpAtomicOr = 241,
-    OpAtomicXor = 242,
-    OpPhi = 245,
-    OpLoopMerge = 246,
-    OpSelectionMerge = 247,
-    OpLabel = 248,
-    OpBranch = 249,
-    OpBranchConditional = 250,
-    OpSwitch = 251,
-    OpKill = 252,
-    OpReturn = 253,
-    OpReturnValue = 254,
-    OpUnreachable = 255,
-    OpLifetimeStart = 256,
-    OpLifetimeStop = 257,
-    OpGroupAsyncCopy = 259,
-    OpGroupWaitEvents = 260,
-    OpGroupAll = 261,
-    OpGroupAny = 262,
-    OpGroupBroadcast = 263,
-    OpGroupIAdd = 264,
-    OpGroupFAdd = 265,
-    OpGroupFMin = 266,
-    OpGroupUMin = 267,
-    OpGroupSMin = 268,
-    OpGroupFMax = 269,
-    OpGroupUMax = 270,
-    OpGroupSMax = 271,
-    OpReadPipe = 274,
-    OpWritePipe = 275,
-    OpReservedReadPipe = 276,
-    OpReservedWritePipe = 277,
-    OpReserveReadPipePackets = 278,
-    OpReserveWritePipePackets = 279,
-    OpCommitReadPipe = 280,
-    OpCommitWritePipe = 281,
-    OpIsValidReserveId = 282,
-    OpGetNumPipePackets = 283,
-    OpGetMaxPipePackets = 284,
-    OpGroupReserveReadPipePackets = 285,
-    OpGroupReserveWritePipePackets = 286,
-    OpGroupCommitReadPipe = 287,
-    OpGroupCommitWritePipe = 288,
-    OpEnqueueMarker = 291,
-    OpEnqueueKernel = 292,
-    OpGetKernelNDrangeSubGroupCount = 293,
-    OpGetKernelNDrangeMaxSubGroupSize = 294,
-    OpGetKernelWorkGroupSize = 295,
-    OpGetKernelPreferredWorkGroupSizeMultiple = 296,
-    OpRetainEvent = 297,
-    OpReleaseEvent = 298,
-    OpCreateUserEvent = 299,
-    OpIsValidEvent = 300,
-    OpSetUserEventStatus = 301,
-    OpCaptureEventProfilingInfo = 302,
-    OpGetDefaultQueue = 303,
-    OpBuildNDRange = 304,
-    OpImageSparseSampleImplicitLod = 305,
-    OpImageSparseSampleExplicitLod = 306,
-    OpImageSparseSampleDrefImplicitLod = 307,
-    OpImageSparseSampleDrefExplicitLod = 308,
-    OpImageSparseSampleProjImplicitLod = 309,
-    OpImageSparseSampleProjExplicitLod = 310,
-    OpImageSparseSampleProjDrefImplicitLod = 311,
-    OpImageSparseSampleProjDrefExplicitLod = 312,
-    OpImageSparseFetch = 313,
-    OpImageSparseGather = 314,
-    OpImageSparseDrefGather = 315,
-    OpImageSparseTexelsResident = 316,
-    OpNoLine = 317,
-    OpAtomicFlagTestAndSet = 318,
-    OpAtomicFlagClear = 319,
-    OpImageSparseRead = 320,
-    OpSizeOf = 321,
-    OpTypePipeStorage = 322,
-    OpConstantPipeStorage = 323,
-    OpCreatePipeFromPipeStorage = 324,
-    OpGetKernelLocalSizeForSubgroupCount = 325,
-    OpGetKernelMaxNumSubgroups = 326,
-    OpTypeNamedBarrier = 327,
-    OpNamedBarrierInitialize = 328,
-    OpMemoryNamedBarrier = 329,
-    OpModuleProcessed = 330,
-    OpExecutionModeId = 331,
-    OpDecorateId = 332,
-    OpGroupNonUniformElect = 333,
-    OpGroupNonUniformAll = 334,
-    OpGroupNonUniformAny = 335,
-    OpGroupNonUniformAllEqual = 336,
-    OpGroupNonUniformBroadcast = 337,
-    OpGroupNonUniformBroadcastFirst = 338,
-    OpGroupNonUniformBallot = 339,
-    OpGroupNonUniformInverseBallot = 340,
-    OpGroupNonUniformBallotBitExtract = 341,
-    OpGroupNonUniformBallotBitCount = 342,
-    OpGroupNonUniformBallotFindLSB = 343,
-    OpGroupNonUniformBallotFindMSB = 344,
-    OpGroupNonUniformShuffle = 345,
-    OpGroupNonUniformShuffleXor = 346,
-    OpGroupNonUniformShuffleUp = 347,
-    OpGroupNonUniformShuffleDown = 348,
-    OpGroupNonUniformIAdd = 349,
-    OpGroupNonUniformFAdd = 350,
-    OpGroupNonUniformIMul = 351,
-    OpGroupNonUniformFMul = 352,
-    OpGroupNonUniformSMin = 353,
-    OpGroupNonUniformUMin = 354,
-    OpGroupNonUniformFMin = 355,
-    OpGroupNonUniformSMax = 356,
-    OpGroupNonUniformUMax = 357,
-    OpGroupNonUniformFMax = 358,
-    OpGroupNonUniformBitwiseAnd = 359,
-    OpGroupNonUniformBitwiseOr = 360,
-    OpGroupNonUniformBitwiseXor = 361,
-    OpGroupNonUniformLogicalAnd = 362,
-    OpGroupNonUniformLogicalOr = 363,
-    OpGroupNonUniformLogicalXor = 364,
-    OpGroupNonUniformQuadBroadcast = 365,
-    OpGroupNonUniformQuadSwap = 366,
-    OpCopyLogical = 400,
-    OpPtrEqual = 401,
-    OpPtrNotEqual = 402,
-    OpPtrDiff = 403,
-    OpColorAttachmentReadEXT = 4160,
-    OpDepthAttachmentReadEXT = 4161,
-    OpStencilAttachmentReadEXT = 4162,
-    OpTerminateInvocation = 4416,
-    OpTypeUntypedPointerKHR = 4417,
-    OpUntypedVariableKHR = 4418,
-    OpUntypedAccessChainKHR = 4419,
-    OpUntypedInBoundsAccessChainKHR = 4420,
-    OpSubgroupBallotKHR = 4421,
-    OpSubgroupFirstInvocationKHR = 4422,
-    OpUntypedPtrAccessChainKHR = 4423,
-    OpUntypedInBoundsPtrAccessChainKHR = 4424,
-    OpUntypedArrayLengthKHR = 4425,
-    OpUntypedPrefetchKHR = 4426,
-    OpSubgroupAllKHR = 4428,
-    OpSubgroupAnyKHR = 4429,
-    OpSubgroupAllEqualKHR = 4430,
-    OpGroupNonUniformRotateKHR = 4431,
-    OpSubgroupReadInvocationKHR = 4432,
-    OpExtInstWithForwardRefsKHR = 4433,
-    OpTraceRayKHR = 4445,
-    OpExecuteCallableKHR = 4446,
-    OpConvertUToAccelerationStructureKHR = 4447,
-    OpIgnoreIntersectionKHR = 4448,
-    OpTerminateRayKHR = 4449,
-    OpSDot = 4450,
-    OpSDotKHR = 4450,
-    OpUDot = 4451,
-    OpUDotKHR = 4451,
-    OpSUDot = 4452,
-    OpSUDotKHR = 4452,
-    OpSDotAccSat = 4453,
-    OpSDotAccSatKHR = 4453,
-    OpUDotAccSat = 4454,
-    OpUDotAccSatKHR = 4454,
-    OpSUDotAccSat = 4455,
-    OpSUDotAccSatKHR = 4455,
-    OpTypeCooperativeMatrixKHR = 4456,
-    OpCooperativeMatrixLoadKHR = 4457,
-    OpCooperativeMatrixStoreKHR = 4458,
-    OpCooperativeMatrixMulAddKHR = 4459,
-    OpCooperativeMatrixLengthKHR = 4460,
-    OpConstantCompositeReplicateEXT = 4461,
-    OpSpecConstantCompositeReplicateEXT = 4462,
-    OpCompositeConstructReplicateEXT = 4463,
-    OpTypeRayQueryKHR = 4472,
-    OpRayQueryInitializeKHR = 4473,
-    OpRayQueryTerminateKHR = 4474,
-    OpRayQueryGenerateIntersectionKHR = 4475,
-    OpRayQueryConfirmIntersectionKHR = 4476,
-    OpRayQueryProceedKHR = 4477,
-    OpRayQueryGetIntersectionTypeKHR = 4479,
-    OpImageSampleWeightedQCOM = 4480,
-    OpImageBoxFilterQCOM = 4481,
-    OpImageBlockMatchSSDQCOM = 4482,
-    OpImageBlockMatchSADQCOM = 4483,
-    OpImageBlockMatchWindowSSDQCOM = 4500,
-    OpImageBlockMatchWindowSADQCOM = 4501,
-    OpImageBlockMatchGatherSSDQCOM = 4502,
-    OpImageBlockMatchGatherSADQCOM = 4503,
-    OpGroupIAddNonUniformAMD = 5000,
-    OpGroupFAddNonUniformAMD = 5001,
-    OpGroupFMinNonUniformAMD = 5002,
-    OpGroupUMinNonUniformAMD = 5003,
-    OpGroupSMinNonUniformAMD = 5004,
-    OpGroupFMaxNonUniformAMD = 5005,
-    OpGroupUMaxNonUniformAMD = 5006,
-    OpGroupSMaxNonUniformAMD = 5007,
-    OpFragmentMaskFetchAMD = 5011,
-    OpFragmentFetchAMD = 5012,
-    OpReadClockKHR = 5056,
-    OpAllocateNodePayloadsAMDX = 5074,
-    OpEnqueueNodePayloadsAMDX = 5075,
-    OpTypeNodePayloadArrayAMDX = 5076,
-    OpFinishWritingNodePayloadAMDX = 5078,
-    OpNodePayloadArrayLengthAMDX = 5090,
-    OpIsNodePayloadValidAMDX = 5101,
-    OpConstantStringAMDX = 5103,
-    OpSpecConstantStringAMDX = 5104,
-    OpGroupNonUniformQuadAllKHR = 5110,
-    OpGroupNonUniformQuadAnyKHR = 5111,
-    OpHitObjectRecordHitMotionNV = 5249,
-    OpHitObjectRecordHitWithIndexMotionNV = 5250,
-    OpHitObjectRecordMissMotionNV = 5251,
-    OpHitObjectGetWorldToObjectNV = 5252,
-    OpHitObjectGetObjectToWorldNV = 5253,
-    OpHitObjectGetObjectRayDirectionNV = 5254,
-    OpHitObjectGetObjectRayOriginNV = 5255,
-    OpHitObjectTraceRayMotionNV = 5256,
-    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
-    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
-    OpHitObjectRecordEmptyNV = 5259,
-    OpHitObjectTraceRayNV = 5260,
-    OpHitObjectRecordHitNV = 5261,
-    OpHitObjectRecordHitWithIndexNV = 5262,
-    OpHitObjectRecordMissNV = 5263,
-    OpHitObjectExecuteShaderNV = 5264,
-    OpHitObjectGetCurrentTimeNV = 5265,
-    OpHitObjectGetAttributesNV = 5266,
-    OpHitObjectGetHitKindNV = 5267,
-    OpHitObjectGetPrimitiveIndexNV = 5268,
-    OpHitObjectGetGeometryIndexNV = 5269,
-    OpHitObjectGetInstanceIdNV = 5270,
-    OpHitObjectGetInstanceCustomIndexNV = 5271,
-    OpHitObjectGetWorldRayDirectionNV = 5272,
-    OpHitObjectGetWorldRayOriginNV = 5273,
-    OpHitObjectGetRayTMaxNV = 5274,
-    OpHitObjectGetRayTMinNV = 5275,
-    OpHitObjectIsEmptyNV = 5276,
-    OpHitObjectIsHitNV = 5277,
-    OpHitObjectIsMissNV = 5278,
-    OpReorderThreadWithHitObjectNV = 5279,
-    OpReorderThreadWithHintNV = 5280,
-    OpTypeHitObjectNV = 5281,
-    OpImageSampleFootprintNV = 5283,
-    OpTypeCooperativeVectorNV = 5288,
-    OpCooperativeVectorMatrixMulNV = 5289,
-    OpCooperativeVectorOuterProductAccumulateNV = 5290,
-    OpCooperativeVectorReduceSumAccumulateNV = 5291,
-    OpCooperativeVectorMatrixMulAddNV = 5292,
-    OpCooperativeMatrixConvertNV = 5293,
-    OpEmitMeshTasksEXT = 5294,
-    OpSetMeshOutputsEXT = 5295,
-    OpGroupNonUniformPartitionNV = 5296,
-    OpWritePackedPrimitiveIndices4x8NV = 5299,
-    OpFetchMicroTriangleVertexPositionNV = 5300,
-    OpFetchMicroTriangleVertexBarycentricNV = 5301,
-    OpCooperativeVectorLoadNV = 5302,
-    OpCooperativeVectorStoreNV = 5303,
-    OpReportIntersectionKHR = 5334,
-    OpReportIntersectionNV = 5334,
-    OpIgnoreIntersectionNV = 5335,
-    OpTerminateRayNV = 5336,
-    OpTraceNV = 5337,
-    OpTraceMotionNV = 5338,
-    OpTraceRayMotionNV = 5339,
-    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
-    OpTypeAccelerationStructureKHR = 5341,
-    OpTypeAccelerationStructureNV = 5341,
-    OpExecuteCallableNV = 5344,
-    OpRayQueryGetIntersectionClusterIdNV = 5345,
-    OpHitObjectGetClusterIdNV = 5346,
-    OpTypeCooperativeMatrixNV = 5358,
-    OpCooperativeMatrixLoadNV = 5359,
-    OpCooperativeMatrixStoreNV = 5360,
-    OpCooperativeMatrixMulAddNV = 5361,
-    OpCooperativeMatrixLengthNV = 5362,
-    OpBeginInvocationInterlockEXT = 5364,
-    OpEndInvocationInterlockEXT = 5365,
-    OpCooperativeMatrixReduceNV = 5366,
-    OpCooperativeMatrixLoadTensorNV = 5367,
-    OpCooperativeMatrixStoreTensorNV = 5368,
-    OpCooperativeMatrixPerElementOpNV = 5369,
-    OpTypeTensorLayoutNV = 5370,
-    OpTypeTensorViewNV = 5371,
-    OpCreateTensorLayoutNV = 5372,
-    OpTensorLayoutSetDimensionNV = 5373,
-    OpTensorLayoutSetStrideNV = 5374,
-    OpTensorLayoutSliceNV = 5375,
-    OpTensorLayoutSetClampValueNV = 5376,
-    OpCreateTensorViewNV = 5377,
-    OpTensorViewSetDimensionNV = 5378,
-    OpTensorViewSetStrideNV = 5379,
-    OpDemoteToHelperInvocation = 5380,
-    OpDemoteToHelperInvocationEXT = 5380,
-    OpIsHelperInvocationEXT = 5381,
-    OpTensorViewSetClipNV = 5382,
-    OpTensorLayoutSetBlockSizeNV = 5384,
-    OpCooperativeMatrixTransposeNV = 5390,
-    OpConvertUToImageNV = 5391,
-    OpConvertUToSamplerNV = 5392,
-    OpConvertImageToUNV = 5393,
-    OpConvertSamplerToUNV = 5394,
-    OpConvertUToSampledImageNV = 5395,
-    OpConvertSampledImageToUNV = 5396,
-    OpSamplerImageAddressingModeNV = 5397,
-    OpRawAccessChainNV = 5398,
-    OpRayQueryGetIntersectionSpherePositionNV = 5427,
-    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
-    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
-    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
-    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
-    OpHitObjectGetSpherePositionNV = 5432,
-    OpHitObjectGetSphereRadiusNV = 5433,
-    OpHitObjectGetLSSPositionsNV = 5434,
-    OpHitObjectGetLSSRadiiNV = 5435,
-    OpHitObjectIsSphereHitNV = 5436,
-    OpHitObjectIsLSSHitNV = 5437,
-    OpRayQueryIsSphereHitNV = 5438,
-    OpRayQueryIsLSSHitNV = 5439,
-    OpSubgroupShuffleINTEL = 5571,
-    OpSubgroupShuffleDownINTEL = 5572,
-    OpSubgroupShuffleUpINTEL = 5573,
-    OpSubgroupShuffleXorINTEL = 5574,
-    OpSubgroupBlockReadINTEL = 5575,
-    OpSubgroupBlockWriteINTEL = 5576,
-    OpSubgroupImageBlockReadINTEL = 5577,
-    OpSubgroupImageBlockWriteINTEL = 5578,
-    OpSubgroupImageMediaBlockReadINTEL = 5580,
-    OpSubgroupImageMediaBlockWriteINTEL = 5581,
-    OpUCountLeadingZerosINTEL = 5585,
-    OpUCountTrailingZerosINTEL = 5586,
-    OpAbsISubINTEL = 5587,
-    OpAbsUSubINTEL = 5588,
-    OpIAddSatINTEL = 5589,
-    OpUAddSatINTEL = 5590,
-    OpIAverageINTEL = 5591,
-    OpUAverageINTEL = 5592,
-    OpIAverageRoundedINTEL = 5593,
-    OpUAverageRoundedINTEL = 5594,
-    OpISubSatINTEL = 5595,
-    OpUSubSatINTEL = 5596,
-    OpIMul32x16INTEL = 5597,
-    OpUMul32x16INTEL = 5598,
-    OpConstantFunctionPointerINTEL = 5600,
-    OpFunctionPointerCallINTEL = 5601,
-    OpAsmTargetINTEL = 5609,
-    OpAsmINTEL = 5610,
-    OpAsmCallINTEL = 5611,
-    OpAtomicFMinEXT = 5614,
-    OpAtomicFMaxEXT = 5615,
-    OpAssumeTrueKHR = 5630,
-    OpExpectKHR = 5631,
-    OpDecorateString = 5632,
-    OpDecorateStringGOOGLE = 5632,
-    OpMemberDecorateString = 5633,
-    OpMemberDecorateStringGOOGLE = 5633,
-    OpVmeImageINTEL = 5699,
-    OpTypeVmeImageINTEL = 5700,
-    OpTypeAvcImePayloadINTEL = 5701,
-    OpTypeAvcRefPayloadINTEL = 5702,
-    OpTypeAvcSicPayloadINTEL = 5703,
-    OpTypeAvcMcePayloadINTEL = 5704,
-    OpTypeAvcMceResultINTEL = 5705,
-    OpTypeAvcImeResultINTEL = 5706,
-    OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
-    OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
-    OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
-    OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
-    OpTypeAvcRefResultINTEL = 5711,
-    OpTypeAvcSicResultINTEL = 5712,
-    OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
-    OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
-    OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
-    OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
-    OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
-    OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
-    OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
-    OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
-    OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
-    OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
-    OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
-    OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
-    OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
-    OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
-    OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
-    OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
-    OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
-    OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
-    OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
-    OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
-    OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
-    OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
-    OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
-    OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
-    OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
-    OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
-    OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
-    OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
-    OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
-    OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
-    OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
-    OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
-    OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
-    OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
-    OpSubgroupAvcImeInitializeINTEL = 5747,
-    OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
-    OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
-    OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
-    OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
-    OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
-    OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
-    OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
-    OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
-    OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
-    OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
-    OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
-    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
-    OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
-    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
-    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
-    OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
-    OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
-    OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
-    OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
-    OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
-    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
-    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
-    OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
-    OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
-    OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
-    OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
-    OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
-    OpSubgroupAvcFmeInitializeINTEL = 5781,
-    OpSubgroupAvcBmeInitializeINTEL = 5782,
-    OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
-    OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
-    OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
-    OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
-    OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
-    OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
-    OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
-    OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
-    OpSubgroupAvcSicInitializeINTEL = 5791,
-    OpSubgroupAvcSicConfigureSkcINTEL = 5792,
-    OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
-    OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
-    OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
-    OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
-    OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
-    OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
-    OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
-    OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
-    OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
-    OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
-    OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
-    OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
-    OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
-    OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
-    OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
-    OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
-    OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
-    OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
-    OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
-    OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
-    OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
-    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
-    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
-    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
-    OpVariableLengthArrayINTEL = 5818,
-    OpSaveMemoryINTEL = 5819,
-    OpRestoreMemoryINTEL = 5820,
-    OpArbitraryFloatSinCosPiINTEL = 5840,
-    OpArbitraryFloatCastINTEL = 5841,
-    OpArbitraryFloatCastFromIntINTEL = 5842,
-    OpArbitraryFloatCastToIntINTEL = 5843,
-    OpArbitraryFloatAddINTEL = 5846,
-    OpArbitraryFloatSubINTEL = 5847,
-    OpArbitraryFloatMulINTEL = 5848,
-    OpArbitraryFloatDivINTEL = 5849,
-    OpArbitraryFloatGTINTEL = 5850,
-    OpArbitraryFloatGEINTEL = 5851,
-    OpArbitraryFloatLTINTEL = 5852,
-    OpArbitraryFloatLEINTEL = 5853,
-    OpArbitraryFloatEQINTEL = 5854,
-    OpArbitraryFloatRecipINTEL = 5855,
-    OpArbitraryFloatRSqrtINTEL = 5856,
-    OpArbitraryFloatCbrtINTEL = 5857,
-    OpArbitraryFloatHypotINTEL = 5858,
-    OpArbitraryFloatSqrtINTEL = 5859,
-    OpArbitraryFloatLogINTEL = 5860,
-    OpArbitraryFloatLog2INTEL = 5861,
-    OpArbitraryFloatLog10INTEL = 5862,
-    OpArbitraryFloatLog1pINTEL = 5863,
-    OpArbitraryFloatExpINTEL = 5864,
-    OpArbitraryFloatExp2INTEL = 5865,
-    OpArbitraryFloatExp10INTEL = 5866,
-    OpArbitraryFloatExpm1INTEL = 5867,
-    OpArbitraryFloatSinINTEL = 5868,
-    OpArbitraryFloatCosINTEL = 5869,
-    OpArbitraryFloatSinCosINTEL = 5870,
-    OpArbitraryFloatSinPiINTEL = 5871,
-    OpArbitraryFloatCosPiINTEL = 5872,
-    OpArbitraryFloatASinINTEL = 5873,
-    OpArbitraryFloatASinPiINTEL = 5874,
-    OpArbitraryFloatACosINTEL = 5875,
-    OpArbitraryFloatACosPiINTEL = 5876,
-    OpArbitraryFloatATanINTEL = 5877,
-    OpArbitraryFloatATanPiINTEL = 5878,
-    OpArbitraryFloatATan2INTEL = 5879,
-    OpArbitraryFloatPowINTEL = 5880,
-    OpArbitraryFloatPowRINTEL = 5881,
-    OpArbitraryFloatPowNINTEL = 5882,
-    OpLoopControlINTEL = 5887,
-    OpAliasDomainDeclINTEL = 5911,
-    OpAliasScopeDeclINTEL = 5912,
-    OpAliasScopeListDeclINTEL = 5913,
-    OpFixedSqrtINTEL = 5923,
-    OpFixedRecipINTEL = 5924,
-    OpFixedRsqrtINTEL = 5925,
-    OpFixedSinINTEL = 5926,
-    OpFixedCosINTEL = 5927,
-    OpFixedSinCosINTEL = 5928,
-    OpFixedSinPiINTEL = 5929,
-    OpFixedCosPiINTEL = 5930,
-    OpFixedSinCosPiINTEL = 5931,
-    OpFixedLogINTEL = 5932,
-    OpFixedExpINTEL = 5933,
-    OpPtrCastToCrossWorkgroupINTEL = 5934,
-    OpCrossWorkgroupCastToPtrINTEL = 5938,
-    OpReadPipeBlockingINTEL = 5946,
-    OpWritePipeBlockingINTEL = 5947,
-    OpFPGARegINTEL = 5949,
-    OpRayQueryGetRayTMinKHR = 6016,
-    OpRayQueryGetRayFlagsKHR = 6017,
-    OpRayQueryGetIntersectionTKHR = 6018,
-    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
-    OpRayQueryGetIntersectionInstanceIdKHR = 6020,
-    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
-    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
-    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
-    OpRayQueryGetIntersectionBarycentricsKHR = 6024,
-    OpRayQueryGetIntersectionFrontFaceKHR = 6025,
-    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
-    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
-    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
-    OpRayQueryGetWorldRayDirectionKHR = 6029,
-    OpRayQueryGetWorldRayOriginKHR = 6030,
-    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
-    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
-    OpAtomicFAddEXT = 6035,
-    OpTypeBufferSurfaceINTEL = 6086,
-    OpTypeStructContinuedINTEL = 6090,
-    OpConstantCompositeContinuedINTEL = 6091,
-    OpSpecConstantCompositeContinuedINTEL = 6092,
-    OpCompositeConstructContinuedINTEL = 6096,
-    OpConvertFToBF16INTEL = 6116,
-    OpConvertBF16ToFINTEL = 6117,
-    OpControlBarrierArriveINTEL = 6142,
-    OpControlBarrierWaitINTEL = 6143,
-    OpArithmeticFenceEXT = 6145,
-    OpSubgroupBlockPrefetchINTEL = 6221,
-    OpGroupIMulKHR = 6401,
-    OpGroupFMulKHR = 6402,
-    OpGroupBitwiseAndKHR = 6403,
-    OpGroupBitwiseOrKHR = 6404,
-    OpGroupBitwiseXorKHR = 6405,
-    OpGroupLogicalAndKHR = 6406,
-    OpGroupLogicalOrKHR = 6407,
-    OpGroupLogicalXorKHR = 6408,
-    OpMaskedGatherINTEL = 6428,
-    OpMaskedScatterINTEL = 6429,
-    OpMax = 0x7fffffff,
-};
-
-#ifdef SPV_ENABLE_UTILITY_CODE
-#ifndef __cplusplus
-#include <stdbool.h>
-#endif
-inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
-    *hasResult = *hasResultType = false;
-    switch (opcode) {
-    default: /* unknown opcode */ break;
-    case OpNop: *hasResult = false; *hasResultType = false; break;
-    case OpUndef: *hasResult = true; *hasResultType = true; break;
-    case OpSourceContinued: *hasResult = false; *hasResultType = false; break;
-    case OpSource: *hasResult = false; *hasResultType = false; break;
-    case OpSourceExtension: *hasResult = false; *hasResultType = false; break;
-    case OpName: *hasResult = false; *hasResultType = false; break;
-    case OpMemberName: *hasResult = false; *hasResultType = false; break;
-    case OpString: *hasResult = true; *hasResultType = false; break;
-    case OpLine: *hasResult = false; *hasResultType = false; break;
-    case OpExtension: *hasResult = false; *hasResultType = false; break;
-    case OpExtInstImport: *hasResult = true; *hasResultType = false; break;
-    case OpExtInst: *hasResult = true; *hasResultType = true; break;
-    case OpMemoryModel: *hasResult = false; *hasResultType = false; break;
-    case OpEntryPoint: *hasResult = false; *hasResultType = false; break;
-    case OpExecutionMode: *hasResult = false; *hasResultType = false; break;
-    case OpCapability: *hasResult = false; *hasResultType = false; break;
-    case OpTypeVoid: *hasResult = true; *hasResultType = false; break;
-    case OpTypeBool: *hasResult = true; *hasResultType = false; break;
-    case OpTypeInt: *hasResult = true; *hasResultType = false; break;
-    case OpTypeFloat: *hasResult = true; *hasResultType = false; break;
-    case OpTypeVector: *hasResult = true; *hasResultType = false; break;
-    case OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
-    case OpTypeImage: *hasResult = true; *hasResultType = false; break;
-    case OpTypeSampler: *hasResult = true; *hasResultType = false; break;
-    case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
-    case OpTypeArray: *hasResult = true; *hasResultType = false; break;
-    case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
-    case OpTypeStruct: *hasResult = true; *hasResultType = false; break;
-    case OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
-    case OpTypePointer: *hasResult = true; *hasResultType = false; break;
-    case OpTypeFunction: *hasResult = true; *hasResultType = false; break;
-    case OpTypeEvent: *hasResult = true; *hasResultType = false; break;
-    case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
-    case OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
-    case OpTypeQueue: *hasResult = true; *hasResultType = false; break;
-    case OpTypePipe: *hasResult = true; *hasResultType = false; break;
-    case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
-    case OpConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case OpConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case OpConstant: *hasResult = true; *hasResultType = true; break;
-    case OpConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case OpConstantSampler: *hasResult = true; *hasResultType = true; break;
-    case OpConstantNull: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstant: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
-    case OpFunction: *hasResult = true; *hasResultType = true; break;
-    case OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
-    case OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
-    case OpFunctionCall: *hasResult = true; *hasResultType = true; break;
-    case OpVariable: *hasResult = true; *hasResultType = true; break;
-    case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
-    case OpLoad: *hasResult = true; *hasResultType = true; break;
-    case OpStore: *hasResult = false; *hasResultType = false; break;
-    case OpCopyMemory: *hasResult = false; *hasResultType = false; break;
-    case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
-    case OpAccessChain: *hasResult = true; *hasResultType = true; break;
-    case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
-    case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case OpArrayLength: *hasResult = true; *hasResultType = true; break;
-    case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
-    case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
-    case OpDecorate: *hasResult = false; *hasResultType = false; break;
-    case OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
-    case OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
-    case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
-    case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
-    case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
-    case OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
-    case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
-    case OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
-    case OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
-    case OpCopyObject: *hasResult = true; *hasResultType = true; break;
-    case OpTranspose: *hasResult = true; *hasResultType = true; break;
-    case OpSampledImage: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageFetch: *hasResult = true; *hasResultType = true; break;
-    case OpImageGather: *hasResult = true; *hasResultType = true; break;
-    case OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
-    case OpImageRead: *hasResult = true; *hasResultType = true; break;
-    case OpImageWrite: *hasResult = false; *hasResultType = false; break;
-    case OpImage: *hasResult = true; *hasResultType = true; break;
-    case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
-    case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
-    case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
-    case OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
-    case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
-    case OpConvertFToU: *hasResult = true; *hasResultType = true; break;
-    case OpConvertFToS: *hasResult = true; *hasResultType = true; break;
-    case OpConvertSToF: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToF: *hasResult = true; *hasResultType = true; break;
-    case OpUConvert: *hasResult = true; *hasResultType = true; break;
-    case OpSConvert: *hasResult = true; *hasResultType = true; break;
-    case OpFConvert: *hasResult = true; *hasResultType = true; break;
-    case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
-    case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
-    case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
-    case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
-    case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
-    case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
-    case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
-    case OpBitcast: *hasResult = true; *hasResultType = true; break;
-    case OpSNegate: *hasResult = true; *hasResultType = true; break;
-    case OpFNegate: *hasResult = true; *hasResultType = true; break;
-    case OpIAdd: *hasResult = true; *hasResultType = true; break;
-    case OpFAdd: *hasResult = true; *hasResultType = true; break;
-    case OpISub: *hasResult = true; *hasResultType = true; break;
-    case OpFSub: *hasResult = true; *hasResultType = true; break;
-    case OpIMul: *hasResult = true; *hasResultType = true; break;
-    case OpFMul: *hasResult = true; *hasResultType = true; break;
-    case OpUDiv: *hasResult = true; *hasResultType = true; break;
-    case OpSDiv: *hasResult = true; *hasResultType = true; break;
-    case OpFDiv: *hasResult = true; *hasResultType = true; break;
-    case OpUMod: *hasResult = true; *hasResultType = true; break;
-    case OpSRem: *hasResult = true; *hasResultType = true; break;
-    case OpSMod: *hasResult = true; *hasResultType = true; break;
-    case OpFRem: *hasResult = true; *hasResultType = true; break;
-    case OpFMod: *hasResult = true; *hasResultType = true; break;
-    case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
-    case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
-    case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
-    case OpOuterProduct: *hasResult = true; *hasResultType = true; break;
-    case OpDot: *hasResult = true; *hasResultType = true; break;
-    case OpIAddCarry: *hasResult = true; *hasResultType = true; break;
-    case OpISubBorrow: *hasResult = true; *hasResultType = true; break;
-    case OpUMulExtended: *hasResult = true; *hasResultType = true; break;
-    case OpSMulExtended: *hasResult = true; *hasResultType = true; break;
-    case OpAny: *hasResult = true; *hasResultType = true; break;
-    case OpAll: *hasResult = true; *hasResultType = true; break;
-    case OpIsNan: *hasResult = true; *hasResultType = true; break;
-    case OpIsInf: *hasResult = true; *hasResultType = true; break;
-    case OpIsFinite: *hasResult = true; *hasResultType = true; break;
-    case OpIsNormal: *hasResult = true; *hasResultType = true; break;
-    case OpSignBitSet: *hasResult = true; *hasResultType = true; break;
-    case OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
-    case OpOrdered: *hasResult = true; *hasResultType = true; break;
-    case OpUnordered: *hasResult = true; *hasResultType = true; break;
-    case OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
-    case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
-    case OpLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case OpLogicalNot: *hasResult = true; *hasResultType = true; break;
-    case OpSelect: *hasResult = true; *hasResultType = true; break;
-    case OpIEqual: *hasResult = true; *hasResultType = true; break;
-    case OpINotEqual: *hasResult = true; *hasResultType = true; break;
-    case OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpULessThan: *hasResult = true; *hasResultType = true; break;
-    case OpSLessThan: *hasResult = true; *hasResultType = true; break;
-    case OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
-    case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
-    case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
-    case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
-    case OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case OpNot: *hasResult = true; *hasResultType = true; break;
-    case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
-    case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
-    case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
-    case OpBitReverse: *hasResult = true; *hasResultType = true; break;
-    case OpBitCount: *hasResult = true; *hasResultType = true; break;
-    case OpDPdx: *hasResult = true; *hasResultType = true; break;
-    case OpDPdy: *hasResult = true; *hasResultType = true; break;
-    case OpFwidth: *hasResult = true; *hasResultType = true; break;
-    case OpDPdxFine: *hasResult = true; *hasResultType = true; break;
-    case OpDPdyFine: *hasResult = true; *hasResultType = true; break;
-    case OpFwidthFine: *hasResult = true; *hasResultType = true; break;
-    case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
-    case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
-    case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
-    case OpEmitVertex: *hasResult = false; *hasResultType = false; break;
-    case OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
-    case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
-    case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
-    case OpControlBarrier: *hasResult = false; *hasResultType = false; break;
-    case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
-    case OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicStore: *hasResult = false; *hasResultType = false; break;
-    case OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicISub: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicOr: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicXor: *hasResult = true; *hasResultType = true; break;
-    case OpPhi: *hasResult = true; *hasResultType = true; break;
-    case OpLoopMerge: *hasResult = false; *hasResultType = false; break;
-    case OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
-    case OpLabel: *hasResult = true; *hasResultType = false; break;
-    case OpBranch: *hasResult = false; *hasResultType = false; break;
-    case OpBranchConditional: *hasResult = false; *hasResultType = false; break;
-    case OpSwitch: *hasResult = false; *hasResultType = false; break;
-    case OpKill: *hasResult = false; *hasResultType = false; break;
-    case OpReturn: *hasResult = false; *hasResultType = false; break;
-    case OpReturnValue: *hasResult = false; *hasResultType = false; break;
-    case OpUnreachable: *hasResult = false; *hasResultType = false; break;
-    case OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
-    case OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
-    case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
-    case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
-    case OpGroupAll: *hasResult = true; *hasResultType = true; break;
-    case OpGroupAny: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
-    case OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupUMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupSMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMax: *hasResult = true; *hasResultType = true; break;
-    case OpGroupUMax: *hasResult = true; *hasResultType = true; break;
-    case OpGroupSMax: *hasResult = true; *hasResultType = true; break;
-    case OpReadPipe: *hasResult = true; *hasResultType = true; break;
-    case OpWritePipe: *hasResult = true; *hasResultType = true; break;
-    case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
-    case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
-    case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
-    case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
-    case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
-    case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
-    case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
-    case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
-    case OpRetainEvent: *hasResult = false; *hasResultType = false; break;
-    case OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
-    case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
-    case OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
-    case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
-    case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
-    case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
-    case OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
-    case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
-    case OpNoLine: *hasResult = false; *hasResultType = false; break;
-    case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
-    case OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
-    case OpSizeOf: *hasResult = true; *hasResultType = true; break;
-    case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
-    case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
-    case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
-    case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
-    case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
-    case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
-    case OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
-    case OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
-    case OpDecorateId: *hasResult = false; *hasResultType = false; break;
-    case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
-    case OpCopyLogical: *hasResult = true; *hasResultType = true; break;
-    case OpPtrEqual: *hasResult = true; *hasResultType = true; break;
-    case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
-    case OpPtrDiff: *hasResult = true; *hasResultType = true; break;
-    case OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
-    case OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break;
-    case OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedAccessChainKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedInBoundsAccessChainKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break;
-    case OpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break;
-    case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
-    case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
-    case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
-    case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
-    case OpSDot: *hasResult = true; *hasResultType = true; break;
-    case OpUDot: *hasResult = true; *hasResultType = true; break;
-    case OpSUDot: *hasResult = true; *hasResultType = true; break;
-    case OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpTypeCooperativeMatrixKHR: *hasResult = true; *hasResultType = false; break;
-    case OpCooperativeMatrixLoadKHR: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break;
-    case OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
-    case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
-    case OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
-    case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
-    case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
-    case OpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break;
-    case OpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
-    case OpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break;
-    case OpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break;
-    case OpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break;
-    case OpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break;
-    case OpConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
-    case OpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
-    case OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
-    case OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
-    case OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
-    case OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
-    case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
-    case OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
-    case OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break;
-    case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
-    case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
-    case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
-    case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
-    case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
-    case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
-    case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
-    case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
-    case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
-    case OpTraceNV: *hasResult = false; *hasResultType = false; break;
-    case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
-    case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
-    case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
-    case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
-    case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break;
-    case OpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break;
-    case OpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break;
-    case OpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break;
-    case OpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break;
-    case OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
-    case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break;
-    case OpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixTransposeNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
-    case OpRawAccessChainNV: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
-    case OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
-    case OpExpectKHR: *hasResult = true; *hasResultType = true; break;
-    case OpDecorateString: *hasResult = false; *hasResultType = false; break;
-    case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
-    case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
-    case OpRayQueryGetIntersectionClusterIdNV: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpCompositeConstructContinuedINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpConvertFToBF16INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
-    case OpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break;
-    }
-}
-inline const char* SourceLanguageToString(SourceLanguage value) {
-    switch (value) {
-    case SourceLanguageUnknown: return "Unknown";
-    case SourceLanguageESSL: return "ESSL";
-    case SourceLanguageGLSL: return "GLSL";
-    case SourceLanguageOpenCL_C: return "OpenCL_C";
-    case SourceLanguageOpenCL_CPP: return "OpenCL_CPP";
-    case SourceLanguageHLSL: return "HLSL";
-    case SourceLanguageCPP_for_OpenCL: return "CPP_for_OpenCL";
-    case SourceLanguageSYCL: return "SYCL";
-    case SourceLanguageHERO_C: return "HERO_C";
-    case SourceLanguageNZSL: return "NZSL";
-    case SourceLanguageWGSL: return "WGSL";
-    case SourceLanguageSlang: return "Slang";
-    case SourceLanguageZig: return "Zig";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ExecutionModelToString(ExecutionModel value) {
-    switch (value) {
-    case ExecutionModelVertex: return "Vertex";
-    case ExecutionModelTessellationControl: return "TessellationControl";
-    case ExecutionModelTessellationEvaluation: return "TessellationEvaluation";
-    case ExecutionModelGeometry: return "Geometry";
-    case ExecutionModelFragment: return "Fragment";
-    case ExecutionModelGLCompute: return "GLCompute";
-    case ExecutionModelKernel: return "Kernel";
-    case ExecutionModelTaskNV: return "TaskNV";
-    case ExecutionModelMeshNV: return "MeshNV";
-    case ExecutionModelRayGenerationKHR: return "RayGenerationKHR";
-    case ExecutionModelIntersectionKHR: return "IntersectionKHR";
-    case ExecutionModelAnyHitKHR: return "AnyHitKHR";
-    case ExecutionModelClosestHitKHR: return "ClosestHitKHR";
-    case ExecutionModelMissKHR: return "MissKHR";
-    case ExecutionModelCallableKHR: return "CallableKHR";
-    case ExecutionModelTaskEXT: return "TaskEXT";
-    case ExecutionModelMeshEXT: return "MeshEXT";
-    default: return "Unknown";
-    }
-}
-
-inline const char* AddressingModelToString(AddressingModel value) {
-    switch (value) {
-    case AddressingModelLogical: return "Logical";
-    case AddressingModelPhysical32: return "Physical32";
-    case AddressingModelPhysical64: return "Physical64";
-    case AddressingModelPhysicalStorageBuffer64: return "PhysicalStorageBuffer64";
-    default: return "Unknown";
-    }
-}
-
-inline const char* MemoryModelToString(MemoryModel value) {
-    switch (value) {
-    case MemoryModelSimple: return "Simple";
-    case MemoryModelGLSL450: return "GLSL450";
-    case MemoryModelOpenCL: return "OpenCL";
-    case MemoryModelVulkan: return "Vulkan";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ExecutionModeToString(ExecutionMode value) {
-    switch (value) {
-    case ExecutionModeInvocations: return "Invocations";
-    case ExecutionModeSpacingEqual: return "SpacingEqual";
-    case ExecutionModeSpacingFractionalEven: return "SpacingFractionalEven";
-    case ExecutionModeSpacingFractionalOdd: return "SpacingFractionalOdd";
-    case ExecutionModeVertexOrderCw: return "VertexOrderCw";
-    case ExecutionModeVertexOrderCcw: return "VertexOrderCcw";
-    case ExecutionModePixelCenterInteger: return "PixelCenterInteger";
-    case ExecutionModeOriginUpperLeft: return "OriginUpperLeft";
-    case ExecutionModeOriginLowerLeft: return "OriginLowerLeft";
-    case ExecutionModeEarlyFragmentTests: return "EarlyFragmentTests";
-    case ExecutionModePointMode: return "PointMode";
-    case ExecutionModeXfb: return "Xfb";
-    case ExecutionModeDepthReplacing: return "DepthReplacing";
-    case ExecutionModeDepthGreater: return "DepthGreater";
-    case ExecutionModeDepthLess: return "DepthLess";
-    case ExecutionModeDepthUnchanged: return "DepthUnchanged";
-    case ExecutionModeLocalSize: return "LocalSize";
-    case ExecutionModeLocalSizeHint: return "LocalSizeHint";
-    case ExecutionModeInputPoints: return "InputPoints";
-    case ExecutionModeInputLines: return "InputLines";
-    case ExecutionModeInputLinesAdjacency: return "InputLinesAdjacency";
-    case ExecutionModeTriangles: return "Triangles";
-    case ExecutionModeInputTrianglesAdjacency: return "InputTrianglesAdjacency";
-    case ExecutionModeQuads: return "Quads";
-    case ExecutionModeIsolines: return "Isolines";
-    case ExecutionModeOutputVertices: return "OutputVertices";
-    case ExecutionModeOutputPoints: return "OutputPoints";
-    case ExecutionModeOutputLineStrip: return "OutputLineStrip";
-    case ExecutionModeOutputTriangleStrip: return "OutputTriangleStrip";
-    case ExecutionModeVecTypeHint: return "VecTypeHint";
-    case ExecutionModeContractionOff: return "ContractionOff";
-    case ExecutionModeInitializer: return "Initializer";
-    case ExecutionModeFinalizer: return "Finalizer";
-    case ExecutionModeSubgroupSize: return "SubgroupSize";
-    case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
-    case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
-    case ExecutionModeLocalSizeId: return "LocalSizeId";
-    case ExecutionModeLocalSizeHintId: return "LocalSizeHintId";
-    case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
-    case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
-    case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
-    case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR";
-    case ExecutionModePostDepthCoverage: return "PostDepthCoverage";
-    case ExecutionModeDenormPreserve: return "DenormPreserve";
-    case ExecutionModeDenormFlushToZero: return "DenormFlushToZero";
-    case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
-    case ExecutionModeRoundingModeRTE: return "RoundingModeRTE";
-    case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ";
-    case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
-    case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
-    case ExecutionModeCoalescingAMDX: return "CoalescingAMDX";
-    case ExecutionModeIsApiEntryAMDX: return "IsApiEntryAMDX";
-    case ExecutionModeMaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX";
-    case ExecutionModeStaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX";
-    case ExecutionModeShaderIndexAMDX: return "ShaderIndexAMDX";
-    case ExecutionModeMaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX";
-    case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD";
-    case ExecutionModeStencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD";
-    case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD";
-    case ExecutionModeStencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD";
-    case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
-    case ExecutionModeStencilRefLessBackAMD: return "StencilRefLessBackAMD";
-    case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR";
-    case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR";
-    case ExecutionModeSharesInputWithAMDX: return "SharesInputWithAMDX";
-    case ExecutionModeOutputLinesEXT: return "OutputLinesEXT";
-    case ExecutionModeOutputPrimitivesEXT: return "OutputPrimitivesEXT";
-    case ExecutionModeDerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR";
-    case ExecutionModeDerivativeGroupLinearKHR: return "DerivativeGroupLinearKHR";
-    case ExecutionModeOutputTrianglesEXT: return "OutputTrianglesEXT";
-    case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT";
-    case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT";
-    case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT";
-    case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT";
-    case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT";
-    case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
-    case ExecutionModeSharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL";
-    case ExecutionModeRoundingModeRTPINTEL: return "RoundingModeRTPINTEL";
-    case ExecutionModeRoundingModeRTNINTEL: return "RoundingModeRTNINTEL";
-    case ExecutionModeFloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL";
-    case ExecutionModeFloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL";
-    case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL";
-    case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL";
-    case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
-    case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
-    case ExecutionModeSchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL";
-    case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconvergesKHR";
-    case ExecutionModeFPFastMathDefault: return "FPFastMathDefault";
-    case ExecutionModeStreamingInterfaceINTEL: return "StreamingInterfaceINTEL";
-    case ExecutionModeRegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL";
-    case ExecutionModeNamedBarrierCountINTEL: return "NamedBarrierCountINTEL";
-    case ExecutionModeMaximumRegistersINTEL: return "MaximumRegistersINTEL";
-    case ExecutionModeMaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL";
-    case ExecutionModeNamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* StorageClassToString(StorageClass value) {
-    switch (value) {
-    case StorageClassUniformConstant: return "UniformConstant";
-    case StorageClassInput: return "Input";
-    case StorageClassUniform: return "Uniform";
-    case StorageClassOutput: return "Output";
-    case StorageClassWorkgroup: return "Workgroup";
-    case StorageClassCrossWorkgroup: return "CrossWorkgroup";
-    case StorageClassPrivate: return "Private";
-    case StorageClassFunction: return "Function";
-    case StorageClassGeneric: return "Generic";
-    case StorageClassPushConstant: return "PushConstant";
-    case StorageClassAtomicCounter: return "AtomicCounter";
-    case StorageClassImage: return "Image";
-    case StorageClassStorageBuffer: return "StorageBuffer";
-    case StorageClassTileImageEXT: return "TileImageEXT";
-    case StorageClassNodePayloadAMDX: return "NodePayloadAMDX";
-    case StorageClassCallableDataKHR: return "CallableDataKHR";
-    case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR";
-    case StorageClassRayPayloadKHR: return "RayPayloadKHR";
-    case StorageClassHitAttributeKHR: return "HitAttributeKHR";
-    case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR";
-    case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR";
-    case StorageClassPhysicalStorageBuffer: return "PhysicalStorageBuffer";
-    case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV";
-    case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
-    case StorageClassCodeSectionINTEL: return "CodeSectionINTEL";
-    case StorageClassDeviceOnlyINTEL: return "DeviceOnlyINTEL";
-    case StorageClassHostOnlyINTEL: return "HostOnlyINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* DimToString(Dim value) {
-    switch (value) {
-    case Dim1D: return "1D";
-    case Dim2D: return "2D";
-    case Dim3D: return "3D";
-    case DimCube: return "Cube";
-    case DimRect: return "Rect";
-    case DimBuffer: return "Buffer";
-    case DimSubpassData: return "SubpassData";
-    case DimTileImageDataEXT: return "TileImageDataEXT";
-    default: return "Unknown";
-    }
-}
-
-inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) {
-    switch (value) {
-    case SamplerAddressingModeNone: return "None";
-    case SamplerAddressingModeClampToEdge: return "ClampToEdge";
-    case SamplerAddressingModeClamp: return "Clamp";
-    case SamplerAddressingModeRepeat: return "Repeat";
-    case SamplerAddressingModeRepeatMirrored: return "RepeatMirrored";
-    default: return "Unknown";
-    }
-}
-
-inline const char* SamplerFilterModeToString(SamplerFilterMode value) {
-    switch (value) {
-    case SamplerFilterModeNearest: return "Nearest";
-    case SamplerFilterModeLinear: return "Linear";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ImageFormatToString(ImageFormat value) {
-    switch (value) {
-    case ImageFormatUnknown: return "Unknown";
-    case ImageFormatRgba32f: return "Rgba32f";
-    case ImageFormatRgba16f: return "Rgba16f";
-    case ImageFormatR32f: return "R32f";
-    case ImageFormatRgba8: return "Rgba8";
-    case ImageFormatRgba8Snorm: return "Rgba8Snorm";
-    case ImageFormatRg32f: return "Rg32f";
-    case ImageFormatRg16f: return "Rg16f";
-    case ImageFormatR11fG11fB10f: return "R11fG11fB10f";
-    case ImageFormatR16f: return "R16f";
-    case ImageFormatRgba16: return "Rgba16";
-    case ImageFormatRgb10A2: return "Rgb10A2";
-    case ImageFormatRg16: return "Rg16";
-    case ImageFormatRg8: return "Rg8";
-    case ImageFormatR16: return "R16";
-    case ImageFormatR8: return "R8";
-    case ImageFormatRgba16Snorm: return "Rgba16Snorm";
-    case ImageFormatRg16Snorm: return "Rg16Snorm";
-    case ImageFormatRg8Snorm: return "Rg8Snorm";
-    case ImageFormatR16Snorm: return "R16Snorm";
-    case ImageFormatR8Snorm: return "R8Snorm";
-    case ImageFormatRgba32i: return "Rgba32i";
-    case ImageFormatRgba16i: return "Rgba16i";
-    case ImageFormatRgba8i: return "Rgba8i";
-    case ImageFormatR32i: return "R32i";
-    case ImageFormatRg32i: return "Rg32i";
-    case ImageFormatRg16i: return "Rg16i";
-    case ImageFormatRg8i: return "Rg8i";
-    case ImageFormatR16i: return "R16i";
-    case ImageFormatR8i: return "R8i";
-    case ImageFormatRgba32ui: return "Rgba32ui";
-    case ImageFormatRgba16ui: return "Rgba16ui";
-    case ImageFormatRgba8ui: return "Rgba8ui";
-    case ImageFormatR32ui: return "R32ui";
-    case ImageFormatRgb10a2ui: return "Rgb10a2ui";
-    case ImageFormatRg32ui: return "Rg32ui";
-    case ImageFormatRg16ui: return "Rg16ui";
-    case ImageFormatRg8ui: return "Rg8ui";
-    case ImageFormatR16ui: return "R16ui";
-    case ImageFormatR8ui: return "R8ui";
-    case ImageFormatR64ui: return "R64ui";
-    case ImageFormatR64i: return "R64i";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ImageChannelOrderToString(ImageChannelOrder value) {
-    switch (value) {
-    case ImageChannelOrderR: return "R";
-    case ImageChannelOrderA: return "A";
-    case ImageChannelOrderRG: return "RG";
-    case ImageChannelOrderRA: return "RA";
-    case ImageChannelOrderRGB: return "RGB";
-    case ImageChannelOrderRGBA: return "RGBA";
-    case ImageChannelOrderBGRA: return "BGRA";
-    case ImageChannelOrderARGB: return "ARGB";
-    case ImageChannelOrderIntensity: return "Intensity";
-    case ImageChannelOrderLuminance: return "Luminance";
-    case ImageChannelOrderRx: return "Rx";
-    case ImageChannelOrderRGx: return "RGx";
-    case ImageChannelOrderRGBx: return "RGBx";
-    case ImageChannelOrderDepth: return "Depth";
-    case ImageChannelOrderDepthStencil: return "DepthStencil";
-    case ImageChannelOrdersRGB: return "sRGB";
-    case ImageChannelOrdersRGBx: return "sRGBx";
-    case ImageChannelOrdersRGBA: return "sRGBA";
-    case ImageChannelOrdersBGRA: return "sBGRA";
-    case ImageChannelOrderABGR: return "ABGR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) {
-    switch (value) {
-    case ImageChannelDataTypeSnormInt8: return "SnormInt8";
-    case ImageChannelDataTypeSnormInt16: return "SnormInt16";
-    case ImageChannelDataTypeUnormInt8: return "UnormInt8";
-    case ImageChannelDataTypeUnormInt16: return "UnormInt16";
-    case ImageChannelDataTypeUnormShort565: return "UnormShort565";
-    case ImageChannelDataTypeUnormShort555: return "UnormShort555";
-    case ImageChannelDataTypeUnormInt101010: return "UnormInt101010";
-    case ImageChannelDataTypeSignedInt8: return "SignedInt8";
-    case ImageChannelDataTypeSignedInt16: return "SignedInt16";
-    case ImageChannelDataTypeSignedInt32: return "SignedInt32";
-    case ImageChannelDataTypeUnsignedInt8: return "UnsignedInt8";
-    case ImageChannelDataTypeUnsignedInt16: return "UnsignedInt16";
-    case ImageChannelDataTypeUnsignedInt32: return "UnsignedInt32";
-    case ImageChannelDataTypeHalfFloat: return "HalfFloat";
-    case ImageChannelDataTypeFloat: return "Float";
-    case ImageChannelDataTypeUnormInt24: return "UnormInt24";
-    case ImageChannelDataTypeUnormInt101010_2: return "UnormInt101010_2";
-    case ImageChannelDataTypeUnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT";
-    case ImageChannelDataTypeUnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT";
-    case ImageChannelDataTypeUnormInt2_101010EXT: return "UnormInt2_101010EXT";
-    default: return "Unknown";
-    }
-}
-
-inline const char* FPRoundingModeToString(FPRoundingMode value) {
-    switch (value) {
-    case FPRoundingModeRTE: return "RTE";
-    case FPRoundingModeRTZ: return "RTZ";
-    case FPRoundingModeRTP: return "RTP";
-    case FPRoundingModeRTN: return "RTN";
-    default: return "Unknown";
-    }
-}
-
-inline const char* LinkageTypeToString(LinkageType value) {
-    switch (value) {
-    case LinkageTypeExport: return "Export";
-    case LinkageTypeImport: return "Import";
-    case LinkageTypeLinkOnceODR: return "LinkOnceODR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* AccessQualifierToString(AccessQualifier value) {
-    switch (value) {
-    case AccessQualifierReadOnly: return "ReadOnly";
-    case AccessQualifierWriteOnly: return "WriteOnly";
-    case AccessQualifierReadWrite: return "ReadWrite";
-    default: return "Unknown";
-    }
-}
-
-inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) {
-    switch (value) {
-    case FunctionParameterAttributeZext: return "Zext";
-    case FunctionParameterAttributeSext: return "Sext";
-    case FunctionParameterAttributeByVal: return "ByVal";
-    case FunctionParameterAttributeSret: return "Sret";
-    case FunctionParameterAttributeNoAlias: return "NoAlias";
-    case FunctionParameterAttributeNoCapture: return "NoCapture";
-    case FunctionParameterAttributeNoWrite: return "NoWrite";
-    case FunctionParameterAttributeNoReadWrite: return "NoReadWrite";
-    case FunctionParameterAttributeRuntimeAlignedINTEL: return "RuntimeAlignedINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* DecorationToString(Decoration value) {
-    switch (value) {
-    case DecorationRelaxedPrecision: return "RelaxedPrecision";
-    case DecorationSpecId: return "SpecId";
-    case DecorationBlock: return "Block";
-    case DecorationBufferBlock: return "BufferBlock";
-    case DecorationRowMajor: return "RowMajor";
-    case DecorationColMajor: return "ColMajor";
-    case DecorationArrayStride: return "ArrayStride";
-    case DecorationMatrixStride: return "MatrixStride";
-    case DecorationGLSLShared: return "GLSLShared";
-    case DecorationGLSLPacked: return "GLSLPacked";
-    case DecorationCPacked: return "CPacked";
-    case DecorationBuiltIn: return "BuiltIn";
-    case DecorationNoPerspective: return "NoPerspective";
-    case DecorationFlat: return "Flat";
-    case DecorationPatch: return "Patch";
-    case DecorationCentroid: return "Centroid";
-    case DecorationSample: return "Sample";
-    case DecorationInvariant: return "Invariant";
-    case DecorationRestrict: return "Restrict";
-    case DecorationAliased: return "Aliased";
-    case DecorationVolatile: return "Volatile";
-    case DecorationConstant: return "Constant";
-    case DecorationCoherent: return "Coherent";
-    case DecorationNonWritable: return "NonWritable";
-    case DecorationNonReadable: return "NonReadable";
-    case DecorationUniform: return "Uniform";
-    case DecorationUniformId: return "UniformId";
-    case DecorationSaturatedConversion: return "SaturatedConversion";
-    case DecorationStream: return "Stream";
-    case DecorationLocation: return "Location";
-    case DecorationComponent: return "Component";
-    case DecorationIndex: return "Index";
-    case DecorationBinding: return "Binding";
-    case DecorationDescriptorSet: return "DescriptorSet";
-    case DecorationOffset: return "Offset";
-    case DecorationXfbBuffer: return "XfbBuffer";
-    case DecorationXfbStride: return "XfbStride";
-    case DecorationFuncParamAttr: return "FuncParamAttr";
-    case DecorationFPRoundingMode: return "FPRoundingMode";
-    case DecorationFPFastMathMode: return "FPFastMathMode";
-    case DecorationLinkageAttributes: return "LinkageAttributes";
-    case DecorationNoContraction: return "NoContraction";
-    case DecorationInputAttachmentIndex: return "InputAttachmentIndex";
-    case DecorationAlignment: return "Alignment";
-    case DecorationMaxByteOffset: return "MaxByteOffset";
-    case DecorationAlignmentId: return "AlignmentId";
-    case DecorationMaxByteOffsetId: return "MaxByteOffsetId";
-    case DecorationNoSignedWrap: return "NoSignedWrap";
-    case DecorationNoUnsignedWrap: return "NoUnsignedWrap";
-    case DecorationWeightTextureQCOM: return "WeightTextureQCOM";
-    case DecorationBlockMatchTextureQCOM: return "BlockMatchTextureQCOM";
-    case DecorationBlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM";
-    case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
-    case DecorationNodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX";
-    case DecorationNodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX";
-    case DecorationTrackFinishWritingAMDX: return "TrackFinishWritingAMDX";
-    case DecorationPayloadNodeNameAMDX: return "PayloadNodeNameAMDX";
-    case DecorationPayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX";
-    case DecorationPayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX";
-    case DecorationPayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX";
-    case DecorationPayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX";
-    case DecorationOverrideCoverageNV: return "OverrideCoverageNV";
-    case DecorationPassthroughNV: return "PassthroughNV";
-    case DecorationViewportRelativeNV: return "ViewportRelativeNV";
-    case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
-    case DecorationPerPrimitiveEXT: return "PerPrimitiveEXT";
-    case DecorationPerViewNV: return "PerViewNV";
-    case DecorationPerTaskNV: return "PerTaskNV";
-    case DecorationPerVertexKHR: return "PerVertexKHR";
-    case DecorationNonUniform: return "NonUniform";
-    case DecorationRestrictPointer: return "RestrictPointer";
-    case DecorationAliasedPointer: return "AliasedPointer";
-    case DecorationHitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV";
-    case DecorationBindlessSamplerNV: return "BindlessSamplerNV";
-    case DecorationBindlessImageNV: return "BindlessImageNV";
-    case DecorationBoundSamplerNV: return "BoundSamplerNV";
-    case DecorationBoundImageNV: return "BoundImageNV";
-    case DecorationSIMTCallINTEL: return "SIMTCallINTEL";
-    case DecorationReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL";
-    case DecorationClobberINTEL: return "ClobberINTEL";
-    case DecorationSideEffectsINTEL: return "SideEffectsINTEL";
-    case DecorationVectorComputeVariableINTEL: return "VectorComputeVariableINTEL";
-    case DecorationFuncParamIOKindINTEL: return "FuncParamIOKindINTEL";
-    case DecorationVectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL";
-    case DecorationStackCallINTEL: return "StackCallINTEL";
-    case DecorationGlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL";
-    case DecorationCounterBuffer: return "CounterBuffer";
-    case DecorationHlslSemanticGOOGLE: return "HlslSemanticGOOGLE";
-    case DecorationUserTypeGOOGLE: return "UserTypeGOOGLE";
-    case DecorationFunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL";
-    case DecorationFunctionDenormModeINTEL: return "FunctionDenormModeINTEL";
-    case DecorationRegisterINTEL: return "RegisterINTEL";
-    case DecorationMemoryINTEL: return "MemoryINTEL";
-    case DecorationNumbanksINTEL: return "NumbanksINTEL";
-    case DecorationBankwidthINTEL: return "BankwidthINTEL";
-    case DecorationMaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL";
-    case DecorationSinglepumpINTEL: return "SinglepumpINTEL";
-    case DecorationDoublepumpINTEL: return "DoublepumpINTEL";
-    case DecorationMaxReplicatesINTEL: return "MaxReplicatesINTEL";
-    case DecorationSimpleDualPortINTEL: return "SimpleDualPortINTEL";
-    case DecorationMergeINTEL: return "MergeINTEL";
-    case DecorationBankBitsINTEL: return "BankBitsINTEL";
-    case DecorationForcePow2DepthINTEL: return "ForcePow2DepthINTEL";
-    case DecorationStridesizeINTEL: return "StridesizeINTEL";
-    case DecorationWordsizeINTEL: return "WordsizeINTEL";
-    case DecorationTrueDualPortINTEL: return "TrueDualPortINTEL";
-    case DecorationBurstCoalesceINTEL: return "BurstCoalesceINTEL";
-    case DecorationCacheSizeINTEL: return "CacheSizeINTEL";
-    case DecorationDontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL";
-    case DecorationPrefetchINTEL: return "PrefetchINTEL";
-    case DecorationStallEnableINTEL: return "StallEnableINTEL";
-    case DecorationFuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL";
-    case DecorationMathOpDSPModeINTEL: return "MathOpDSPModeINTEL";
-    case DecorationAliasScopeINTEL: return "AliasScopeINTEL";
-    case DecorationNoAliasINTEL: return "NoAliasINTEL";
-    case DecorationInitiationIntervalINTEL: return "InitiationIntervalINTEL";
-    case DecorationMaxConcurrencyINTEL: return "MaxConcurrencyINTEL";
-    case DecorationPipelineEnableINTEL: return "PipelineEnableINTEL";
-    case DecorationBufferLocationINTEL: return "BufferLocationINTEL";
-    case DecorationIOPipeStorageINTEL: return "IOPipeStorageINTEL";
-    case DecorationFunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL";
-    case DecorationSingleElementVectorINTEL: return "SingleElementVectorINTEL";
-    case DecorationVectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL";
-    case DecorationMediaBlockIOINTEL: return "MediaBlockIOINTEL";
-    case DecorationStallFreeINTEL: return "StallFreeINTEL";
-    case DecorationFPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL";
-    case DecorationLatencyControlLabelINTEL: return "LatencyControlLabelINTEL";
-    case DecorationLatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL";
-    case DecorationConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL";
-    case DecorationRegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL";
-    case DecorationMMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL";
-    case DecorationMMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL";
-    case DecorationMMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL";
-    case DecorationMMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL";
-    case DecorationMMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL";
-    case DecorationMMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL";
-    case DecorationStableKernelArgumentINTEL: return "StableKernelArgumentINTEL";
-    case DecorationHostAccessINTEL: return "HostAccessINTEL";
-    case DecorationInitModeINTEL: return "InitModeINTEL";
-    case DecorationImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL";
-    case DecorationCacheControlLoadINTEL: return "CacheControlLoadINTEL";
-    case DecorationCacheControlStoreINTEL: return "CacheControlStoreINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* BuiltInToString(BuiltIn value) {
-    switch (value) {
-    case BuiltInPosition: return "Position";
-    case BuiltInPointSize: return "PointSize";
-    case BuiltInClipDistance: return "ClipDistance";
-    case BuiltInCullDistance: return "CullDistance";
-    case BuiltInVertexId: return "VertexId";
-    case BuiltInInstanceId: return "InstanceId";
-    case BuiltInPrimitiveId: return "PrimitiveId";
-    case BuiltInInvocationId: return "InvocationId";
-    case BuiltInLayer: return "Layer";
-    case BuiltInViewportIndex: return "ViewportIndex";
-    case BuiltInTessLevelOuter: return "TessLevelOuter";
-    case BuiltInTessLevelInner: return "TessLevelInner";
-    case BuiltInTessCoord: return "TessCoord";
-    case BuiltInPatchVertices: return "PatchVertices";
-    case BuiltInFragCoord: return "FragCoord";
-    case BuiltInPointCoord: return "PointCoord";
-    case BuiltInFrontFacing: return "FrontFacing";
-    case BuiltInSampleId: return "SampleId";
-    case BuiltInSamplePosition: return "SamplePosition";
-    case BuiltInSampleMask: return "SampleMask";
-    case BuiltInFragDepth: return "FragDepth";
-    case BuiltInHelperInvocation: return "HelperInvocation";
-    case BuiltInNumWorkgroups: return "NumWorkgroups";
-    case BuiltInWorkgroupSize: return "WorkgroupSize";
-    case BuiltInWorkgroupId: return "WorkgroupId";
-    case BuiltInLocalInvocationId: return "LocalInvocationId";
-    case BuiltInGlobalInvocationId: return "GlobalInvocationId";
-    case BuiltInLocalInvocationIndex: return "LocalInvocationIndex";
-    case BuiltInWorkDim: return "WorkDim";
-    case BuiltInGlobalSize: return "GlobalSize";
-    case BuiltInEnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize";
-    case BuiltInGlobalOffset: return "GlobalOffset";
-    case BuiltInGlobalLinearId: return "GlobalLinearId";
-    case BuiltInSubgroupSize: return "SubgroupSize";
-    case BuiltInSubgroupMaxSize: return "SubgroupMaxSize";
-    case BuiltInNumSubgroups: return "NumSubgroups";
-    case BuiltInNumEnqueuedSubgroups: return "NumEnqueuedSubgroups";
-    case BuiltInSubgroupId: return "SubgroupId";
-    case BuiltInSubgroupLocalInvocationId: return "SubgroupLocalInvocationId";
-    case BuiltInVertexIndex: return "VertexIndex";
-    case BuiltInInstanceIndex: return "InstanceIndex";
-    case BuiltInCoreIDARM: return "CoreIDARM";
-    case BuiltInCoreCountARM: return "CoreCountARM";
-    case BuiltInCoreMaxIDARM: return "CoreMaxIDARM";
-    case BuiltInWarpIDARM: return "WarpIDARM";
-    case BuiltInWarpMaxIDARM: return "WarpMaxIDARM";
-    case BuiltInSubgroupEqMask: return "SubgroupEqMask";
-    case BuiltInSubgroupGeMask: return "SubgroupGeMask";
-    case BuiltInSubgroupGtMask: return "SubgroupGtMask";
-    case BuiltInSubgroupLeMask: return "SubgroupLeMask";
-    case BuiltInSubgroupLtMask: return "SubgroupLtMask";
-    case BuiltInBaseVertex: return "BaseVertex";
-    case BuiltInBaseInstance: return "BaseInstance";
-    case BuiltInDrawIndex: return "DrawIndex";
-    case BuiltInPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR";
-    case BuiltInDeviceIndex: return "DeviceIndex";
-    case BuiltInViewIndex: return "ViewIndex";
-    case BuiltInShadingRateKHR: return "ShadingRateKHR";
-    case BuiltInBaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD";
-    case BuiltInBaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD";
-    case BuiltInBaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD";
-    case BuiltInBaryCoordSmoothAMD: return "BaryCoordSmoothAMD";
-    case BuiltInBaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD";
-    case BuiltInBaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD";
-    case BuiltInBaryCoordPullModelAMD: return "BaryCoordPullModelAMD";
-    case BuiltInFragStencilRefEXT: return "FragStencilRefEXT";
-    case BuiltInRemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX";
-    case BuiltInShaderIndexAMDX: return "ShaderIndexAMDX";
-    case BuiltInViewportMaskNV: return "ViewportMaskNV";
-    case BuiltInSecondaryPositionNV: return "SecondaryPositionNV";
-    case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV";
-    case BuiltInPositionPerViewNV: return "PositionPerViewNV";
-    case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
-    case BuiltInFullyCoveredEXT: return "FullyCoveredEXT";
-    case BuiltInTaskCountNV: return "TaskCountNV";
-    case BuiltInPrimitiveCountNV: return "PrimitiveCountNV";
-    case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV";
-    case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV";
-    case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV";
-    case BuiltInLayerPerViewNV: return "LayerPerViewNV";
-    case BuiltInMeshViewCountNV: return "MeshViewCountNV";
-    case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV";
-    case BuiltInBaryCoordKHR: return "BaryCoordKHR";
-    case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR";
-    case BuiltInFragSizeEXT: return "FragSizeEXT";
-    case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT";
-    case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT";
-    case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
-    case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
-    case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT";
-    case BuiltInLaunchIdKHR: return "LaunchIdKHR";
-    case BuiltInLaunchSizeKHR: return "LaunchSizeKHR";
-    case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR";
-    case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR";
-    case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR";
-    case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR";
-    case BuiltInRayTminKHR: return "RayTminKHR";
-    case BuiltInRayTmaxKHR: return "RayTmaxKHR";
-    case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
-    case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR";
-    case BuiltInWorldToObjectKHR: return "WorldToObjectKHR";
-    case BuiltInHitTNV: return "HitTNV";
-    case BuiltInHitKindKHR: return "HitKindKHR";
-    case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV";
-    case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
-    case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
-    case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
-    case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
-    case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
-    case BuiltInWarpsPerSMNV: return "WarpsPerSMNV";
-    case BuiltInSMCountNV: return "SMCountNV";
-    case BuiltInWarpIDNV: return "WarpIDNV";
-    case BuiltInSMIDNV: return "SMIDNV";
-    case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
-    case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
-    case BuiltInCullMaskKHR: return "CullMaskKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ScopeToString(Scope value) {
-    switch (value) {
-    case ScopeCrossDevice: return "CrossDevice";
-    case ScopeDevice: return "Device";
-    case ScopeWorkgroup: return "Workgroup";
-    case ScopeSubgroup: return "Subgroup";
-    case ScopeInvocation: return "Invocation";
-    case ScopeQueueFamily: return "QueueFamily";
-    case ScopeShaderCallKHR: return "ShaderCallKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* GroupOperationToString(GroupOperation value) {
-    switch (value) {
-    case GroupOperationReduce: return "Reduce";
-    case GroupOperationInclusiveScan: return "InclusiveScan";
-    case GroupOperationExclusiveScan: return "ExclusiveScan";
-    case GroupOperationClusteredReduce: return "ClusteredReduce";
-    case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV";
-    case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV";
-    case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV";
-    default: return "Unknown";
-    }
-}
-
-inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) {
-    switch (value) {
-    case KernelEnqueueFlagsNoWait: return "NoWait";
-    case KernelEnqueueFlagsWaitKernel: return "WaitKernel";
-    case KernelEnqueueFlagsWaitWorkGroup: return "WaitWorkGroup";
-    default: return "Unknown";
-    }
-}
-
-inline const char* CapabilityToString(Capability value) {
-    switch (value) {
-    case CapabilityMatrix: return "Matrix";
-    case CapabilityShader: return "Shader";
-    case CapabilityGeometry: return "Geometry";
-    case CapabilityTessellation: return "Tessellation";
-    case CapabilityAddresses: return "Addresses";
-    case CapabilityLinkage: return "Linkage";
-    case CapabilityKernel: return "Kernel";
-    case CapabilityVector16: return "Vector16";
-    case CapabilityFloat16Buffer: return "Float16Buffer";
-    case CapabilityFloat16: return "Float16";
-    case CapabilityFloat64: return "Float64";
-    case CapabilityInt64: return "Int64";
-    case CapabilityInt64Atomics: return "Int64Atomics";
-    case CapabilityImageBasic: return "ImageBasic";
-    case CapabilityImageReadWrite: return "ImageReadWrite";
-    case CapabilityImageMipmap: return "ImageMipmap";
-    case CapabilityPipes: return "Pipes";
-    case CapabilityGroups: return "Groups";
-    case CapabilityDeviceEnqueue: return "DeviceEnqueue";
-    case CapabilityLiteralSampler: return "LiteralSampler";
-    case CapabilityAtomicStorage: return "AtomicStorage";
-    case CapabilityInt16: return "Int16";
-    case CapabilityTessellationPointSize: return "TessellationPointSize";
-    case CapabilityGeometryPointSize: return "GeometryPointSize";
-    case CapabilityImageGatherExtended: return "ImageGatherExtended";
-    case CapabilityStorageImageMultisample: return "StorageImageMultisample";
-    case CapabilityUniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing";
-    case CapabilitySampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing";
-    case CapabilityStorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing";
-    case CapabilityStorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing";
-    case CapabilityClipDistance: return "ClipDistance";
-    case CapabilityCullDistance: return "CullDistance";
-    case CapabilityImageCubeArray: return "ImageCubeArray";
-    case CapabilitySampleRateShading: return "SampleRateShading";
-    case CapabilityImageRect: return "ImageRect";
-    case CapabilitySampledRect: return "SampledRect";
-    case CapabilityGenericPointer: return "GenericPointer";
-    case CapabilityInt8: return "Int8";
-    case CapabilityInputAttachment: return "InputAttachment";
-    case CapabilitySparseResidency: return "SparseResidency";
-    case CapabilityMinLod: return "MinLod";
-    case CapabilitySampled1D: return "Sampled1D";
-    case CapabilityImage1D: return "Image1D";
-    case CapabilitySampledCubeArray: return "SampledCubeArray";
-    case CapabilitySampledBuffer: return "SampledBuffer";
-    case CapabilityImageBuffer: return "ImageBuffer";
-    case CapabilityImageMSArray: return "ImageMSArray";
-    case CapabilityStorageImageExtendedFormats: return "StorageImageExtendedFormats";
-    case CapabilityImageQuery: return "ImageQuery";
-    case CapabilityDerivativeControl: return "DerivativeControl";
-    case CapabilityInterpolationFunction: return "InterpolationFunction";
-    case CapabilityTransformFeedback: return "TransformFeedback";
-    case CapabilityGeometryStreams: return "GeometryStreams";
-    case CapabilityStorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat";
-    case CapabilityStorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat";
-    case CapabilityMultiViewport: return "MultiViewport";
-    case CapabilitySubgroupDispatch: return "SubgroupDispatch";
-    case CapabilityNamedBarrier: return "NamedBarrier";
-    case CapabilityPipeStorage: return "PipeStorage";
-    case CapabilityGroupNonUniform: return "GroupNonUniform";
-    case CapabilityGroupNonUniformVote: return "GroupNonUniformVote";
-    case CapabilityGroupNonUniformArithmetic: return "GroupNonUniformArithmetic";
-    case CapabilityGroupNonUniformBallot: return "GroupNonUniformBallot";
-    case CapabilityGroupNonUniformShuffle: return "GroupNonUniformShuffle";
-    case CapabilityGroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative";
-    case CapabilityGroupNonUniformClustered: return "GroupNonUniformClustered";
-    case CapabilityGroupNonUniformQuad: return "GroupNonUniformQuad";
-    case CapabilityShaderLayer: return "ShaderLayer";
-    case CapabilityShaderViewportIndex: return "ShaderViewportIndex";
-    case CapabilityUniformDecoration: return "UniformDecoration";
-    case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM";
-    case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT";
-    case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT";
-    case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT";
-    case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM";
-    case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR";
-    case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR";
-    case CapabilityDrawParameters: return "DrawParameters";
-    case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR";
-    case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR";
-    case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR";
-    case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR";
-    case CapabilityStorageBuffer16BitAccess: return "StorageBuffer16BitAccess";
-    case CapabilityStorageUniform16: return "StorageUniform16";
-    case CapabilityStoragePushConstant16: return "StoragePushConstant16";
-    case CapabilityStorageInputOutput16: return "StorageInputOutput16";
-    case CapabilityDeviceGroup: return "DeviceGroup";
-    case CapabilityMultiView: return "MultiView";
-    case CapabilityVariablePointersStorageBuffer: return "VariablePointersStorageBuffer";
-    case CapabilityVariablePointers: return "VariablePointers";
-    case CapabilityAtomicStorageOps: return "AtomicStorageOps";
-    case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage";
-    case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess";
-    case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess";
-    case CapabilityStoragePushConstant8: return "StoragePushConstant8";
-    case CapabilityDenormPreserve: return "DenormPreserve";
-    case CapabilityDenormFlushToZero: return "DenormFlushToZero";
-    case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
-    case CapabilityRoundingModeRTE: return "RoundingModeRTE";
-    case CapabilityRoundingModeRTZ: return "RoundingModeRTZ";
-    case CapabilityRayQueryProvisionalKHR: return "RayQueryProvisionalKHR";
-    case CapabilityRayQueryKHR: return "RayQueryKHR";
-    case CapabilityUntypedPointersKHR: return "UntypedPointersKHR";
-    case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
-    case CapabilityRayTracingKHR: return "RayTracingKHR";
-    case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
-    case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
-    case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
-    case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
-    case CapabilityFloat16ImageAMD: return "Float16ImageAMD";
-    case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
-    case CapabilityFragmentMaskAMD: return "FragmentMaskAMD";
-    case CapabilityStencilExportEXT: return "StencilExportEXT";
-    case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD";
-    case CapabilityInt64ImageEXT: return "Int64ImageEXT";
-    case CapabilityShaderClockKHR: return "ShaderClockKHR";
-    case CapabilityShaderEnqueueAMDX: return "ShaderEnqueueAMDX";
-    case CapabilityQuadControlKHR: return "QuadControlKHR";
-    case CapabilityBFloat16TypeKHR: return "BFloat16TypeKHR";
-    case CapabilityBFloat16DotProductKHR: return "BFloat16DotProductKHR";
-    case CapabilityBFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR";
-    case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV";
-    case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
-    case CapabilityShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT";
-    case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV";
-    case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV";
-    case CapabilityPerViewAttributesNV: return "PerViewAttributesNV";
-    case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
-    case CapabilityMeshShadingNV: return "MeshShadingNV";
-    case CapabilityImageFootprintNV: return "ImageFootprintNV";
-    case CapabilityMeshShadingEXT: return "MeshShadingEXT";
-    case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR";
-    case CapabilityComputeDerivativeGroupQuadsKHR: return "ComputeDerivativeGroupQuadsKHR";
-    case CapabilityFragmentDensityEXT: return "FragmentDensityEXT";
-    case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV";
-    case CapabilityShaderNonUniform: return "ShaderNonUniform";
-    case CapabilityRuntimeDescriptorArray: return "RuntimeDescriptorArray";
-    case CapabilityInputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing";
-    case CapabilityUniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing";
-    case CapabilityStorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing";
-    case CapabilityUniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing";
-    case CapabilitySampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing";
-    case CapabilityStorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing";
-    case CapabilityStorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing";
-    case CapabilityInputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing";
-    case CapabilityUniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing";
-    case CapabilityStorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing";
-    case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
-    case CapabilityRayTracingNV: return "RayTracingNV";
-    case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV";
-    case CapabilityVulkanMemoryModel: return "VulkanMemoryModel";
-    case CapabilityVulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope";
-    case CapabilityPhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses";
-    case CapabilityComputeDerivativeGroupLinearKHR: return "ComputeDerivativeGroupLinearKHR";
-    case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
-    case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV";
-    case CapabilityFragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT";
-    case CapabilityFragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT";
-    case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV";
-    case CapabilityFragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT";
-    case CapabilityDemoteToHelperInvocation: return "DemoteToHelperInvocation";
-    case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV";
-    case CapabilityRayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT";
-    case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
-    case CapabilityBindlessTextureNV: return "BindlessTextureNV";
-    case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
-    case CapabilityCooperativeVectorNV: return "CooperativeVectorNV";
-    case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
-    case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
-    case CapabilityRawAccessChainsNV: return "RawAccessChainsNV";
-    case CapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
-    case CapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
-    case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
-    case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
-    case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
-    case CapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
-    case CapabilityTensorAddressingNV: return "TensorAddressingNV";
-    case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
-    case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
-    case CapabilitySubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL";
-    case CapabilitySubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL";
-    case CapabilityRoundToInfinityINTEL: return "RoundToInfinityINTEL";
-    case CapabilityFloatingPointModeINTEL: return "FloatingPointModeINTEL";
-    case CapabilityIntegerFunctions2INTEL: return "IntegerFunctions2INTEL";
-    case CapabilityFunctionPointersINTEL: return "FunctionPointersINTEL";
-    case CapabilityIndirectReferencesINTEL: return "IndirectReferencesINTEL";
-    case CapabilityAsmINTEL: return "AsmINTEL";
-    case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT";
-    case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT";
-    case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT";
-    case CapabilityVectorComputeINTEL: return "VectorComputeINTEL";
-    case CapabilityVectorAnyINTEL: return "VectorAnyINTEL";
-    case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR";
-    case CapabilitySubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL";
-    case CapabilitySubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL";
-    case CapabilitySubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL";
-    case CapabilityVariableLengthArrayINTEL: return "VariableLengthArrayINTEL";
-    case CapabilityFunctionFloatControlINTEL: return "FunctionFloatControlINTEL";
-    case CapabilityFPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL";
-    case CapabilityFPFastMathModeINTEL: return "FPFastMathModeINTEL";
-    case CapabilityArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL";
-    case CapabilityArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL";
-    case CapabilityUnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL";
-    case CapabilityFPGALoopControlsINTEL: return "FPGALoopControlsINTEL";
-    case CapabilityKernelAttributesINTEL: return "KernelAttributesINTEL";
-    case CapabilityFPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL";
-    case CapabilityFPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL";
-    case CapabilityFPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL";
-    case CapabilityLoopFuseINTEL: return "LoopFuseINTEL";
-    case CapabilityFPGADSPControlINTEL: return "FPGADSPControlINTEL";
-    case CapabilityMemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL";
-    case CapabilityFPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL";
-    case CapabilityFPGABufferLocationINTEL: return "FPGABufferLocationINTEL";
-    case CapabilityArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL";
-    case CapabilityUSMStorageClassesINTEL: return "USMStorageClassesINTEL";
-    case CapabilityRuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL";
-    case CapabilityIOPipesINTEL: return "IOPipesINTEL";
-    case CapabilityBlockingPipesINTEL: return "BlockingPipesINTEL";
-    case CapabilityFPGARegINTEL: return "FPGARegINTEL";
-    case CapabilityDotProductInputAll: return "DotProductInputAll";
-    case CapabilityDotProductInput4x8Bit: return "DotProductInput4x8Bit";
-    case CapabilityDotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked";
-    case CapabilityDotProduct: return "DotProduct";
-    case CapabilityRayCullMaskKHR: return "RayCullMaskKHR";
-    case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR";
-    case CapabilityReplicatedCompositesEXT: return "ReplicatedCompositesEXT";
-    case CapabilityBitInstructions: return "BitInstructions";
-    case CapabilityGroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR";
-    case CapabilityFloatControls2: return "FloatControls2";
-    case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
-    case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
-    case CapabilityLongCompositesINTEL: return "LongCompositesINTEL";
-    case CapabilityOptNoneEXT: return "OptNoneEXT";
-    case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
-    case CapabilityDebugInfoModuleINTEL: return "DebugInfoModuleINTEL";
-    case CapabilityBFloat16ConversionINTEL: return "BFloat16ConversionINTEL";
-    case CapabilitySplitBarrierINTEL: return "SplitBarrierINTEL";
-    case CapabilityArithmeticFenceEXT: return "ArithmeticFenceEXT";
-    case CapabilityFPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL";
-    case CapabilityFPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL";
-    case CapabilityFPMaxErrorINTEL: return "FPMaxErrorINTEL";
-    case CapabilityFPGALatencyControlINTEL: return "FPGALatencyControlINTEL";
-    case CapabilityFPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL";
-    case CapabilityGlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL";
-    case CapabilityGlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL";
-    case CapabilitySubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL";
-    case CapabilityGroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
-    case CapabilityMaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
-    case CapabilityCacheControlsINTEL: return "CacheControlsINTEL";
-    case CapabilityRegisterLimitsINTEL: return "RegisterLimitsINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* RayQueryIntersectionToString(RayQueryIntersection value) {
-    switch (value) {
-    case RayQueryIntersectionRayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR";
-    case RayQueryIntersectionRayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) {
-    switch (value) {
-    case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR";
-    case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR";
-    case RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) {
-    switch (value) {
-    case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR";
-    case RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* FPDenormModeToString(FPDenormMode value) {
-    switch (value) {
-    case FPDenormModePreserve: return "Preserve";
-    case FPDenormModeFlushToZero: return "FlushToZero";
-    default: return "Unknown";
-    }
-}
-
-inline const char* FPOperationModeToString(FPOperationMode value) {
-    switch (value) {
-    case FPOperationModeIEEE: return "IEEE";
-    case FPOperationModeALT: return "ALT";
-    default: return "Unknown";
-    }
-}
-
-inline const char* QuantizationModesToString(QuantizationModes value) {
-    switch (value) {
-    case QuantizationModesTRN: return "TRN";
-    case QuantizationModesTRN_ZERO: return "TRN_ZERO";
-    case QuantizationModesRND: return "RND";
-    case QuantizationModesRND_ZERO: return "RND_ZERO";
-    case QuantizationModesRND_INF: return "RND_INF";
-    case QuantizationModesRND_MIN_INF: return "RND_MIN_INF";
-    case QuantizationModesRND_CONV: return "RND_CONV";
-    case QuantizationModesRND_CONV_ODD: return "RND_CONV_ODD";
-    default: return "Unknown";
-    }
-}
-
-inline const char* OverflowModesToString(OverflowModes value) {
-    switch (value) {
-    case OverflowModesWRAP: return "WRAP";
-    case OverflowModesSAT: return "SAT";
-    case OverflowModesSAT_ZERO: return "SAT_ZERO";
-    case OverflowModesSAT_SYM: return "SAT_SYM";
-    default: return "Unknown";
-    }
-}
-
-inline const char* PackedVectorFormatToString(PackedVectorFormat value) {
-    switch (value) {
-    case PackedVectorFormatPackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit";
-    default: return "Unknown";
-    }
-}
-
-inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) {
-    switch (value) {
-    case CooperativeMatrixLayoutRowMajorKHR: return "RowMajorKHR";
-    case CooperativeMatrixLayoutColumnMajorKHR: return "ColumnMajorKHR";
-    case CooperativeMatrixLayoutRowBlockedInterleavedARM: return "RowBlockedInterleavedARM";
-    case CooperativeMatrixLayoutColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM";
-    default: return "Unknown";
-    }
-}
-
-inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) {
-    switch (value) {
-    case CooperativeMatrixUseMatrixAKHR: return "MatrixAKHR";
-    case CooperativeMatrixUseMatrixBKHR: return "MatrixBKHR";
-    case CooperativeMatrixUseMatrixAccumulatorKHR: return "MatrixAccumulatorKHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* TensorClampModeToString(TensorClampMode value) {
-    switch (value) {
-    case TensorClampModeUndefined: return "Undefined";
-    case TensorClampModeConstant: return "Constant";
-    case TensorClampModeClampToEdge: return "ClampToEdge";
-    case TensorClampModeRepeat: return "Repeat";
-    case TensorClampModeRepeatMirrored: return "RepeatMirrored";
-    default: return "Unknown";
-    }
-}
-
-inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) {
-    switch (value) {
-    case InitializationModeQualifierInitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL";
-    case InitializationModeQualifierInitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* HostAccessQualifierToString(HostAccessQualifier value) {
-    switch (value) {
-    case HostAccessQualifierNoneINTEL: return "NoneINTEL";
-    case HostAccessQualifierReadINTEL: return "ReadINTEL";
-    case HostAccessQualifierWriteINTEL: return "WriteINTEL";
-    case HostAccessQualifierReadWriteINTEL: return "ReadWriteINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* LoadCacheControlToString(LoadCacheControl value) {
-    switch (value) {
-    case LoadCacheControlUncachedINTEL: return "UncachedINTEL";
-    case LoadCacheControlCachedINTEL: return "CachedINTEL";
-    case LoadCacheControlStreamingINTEL: return "StreamingINTEL";
-    case LoadCacheControlInvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL";
-    case LoadCacheControlConstCachedINTEL: return "ConstCachedINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* StoreCacheControlToString(StoreCacheControl value) {
-    switch (value) {
-    case StoreCacheControlUncachedINTEL: return "UncachedINTEL";
-    case StoreCacheControlWriteThroughINTEL: return "WriteThroughINTEL";
-    case StoreCacheControlWriteBackINTEL: return "WriteBackINTEL";
-    case StoreCacheControlStreamingINTEL: return "StreamingINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) {
-    switch (value) {
-    case NamedMaximumNumberOfRegistersAutoINTEL: return "AutoINTEL";
-    default: return "Unknown";
-    }
-}
-
-inline const char* FPEncodingToString(FPEncoding value) {
-    switch (value) {
-    case FPEncodingBFloat16KHR: return "BFloat16KHR";
-    default: return "Unknown";
-    }
-}
-
-inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) {
-    switch (value) {
-    case CooperativeVectorMatrixLayoutRowMajorNV: return "RowMajorNV";
-    case CooperativeVectorMatrixLayoutColumnMajorNV: return "ColumnMajorNV";
-    case CooperativeVectorMatrixLayoutInferencingOptimalNV: return "InferencingOptimalNV";
-    case CooperativeVectorMatrixLayoutTrainingOptimalNV: return "TrainingOptimalNV";
-    default: return "Unknown";
-    }
-}
-
-inline const char* ComponentTypeToString(ComponentType value) {
-    switch (value) {
-    case ComponentTypeFloat16NV: return "Float16NV";
-    case ComponentTypeFloat32NV: return "Float32NV";
-    case ComponentTypeFloat64NV: return "Float64NV";
-    case ComponentTypeSignedInt8NV: return "SignedInt8NV";
-    case ComponentTypeSignedInt16NV: return "SignedInt16NV";
-    case ComponentTypeSignedInt32NV: return "SignedInt32NV";
-    case ComponentTypeSignedInt64NV: return "SignedInt64NV";
-    case ComponentTypeUnsignedInt8NV: return "UnsignedInt8NV";
-    case ComponentTypeUnsignedInt16NV: return "UnsignedInt16NV";
-    case ComponentTypeUnsignedInt32NV: return "UnsignedInt32NV";
-    case ComponentTypeUnsignedInt64NV: return "UnsignedInt64NV";
-    case ComponentTypeSignedInt8PackedNV: return "SignedInt8PackedNV";
-    case ComponentTypeUnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
-    case ComponentTypeFloatE4M3NV: return "FloatE4M3NV";
-    case ComponentTypeFloatE5M2NV: return "FloatE5M2NV";
-    default: return "Unknown";
-    }
-}
-
-inline const char* OpToString(Op value) {
-    switch (value) {
-    case OpNop: return "OpNop";
-    case OpUndef: return "OpUndef";
-    case OpSourceContinued: return "OpSourceContinued";
-    case OpSource: return "OpSource";
-    case OpSourceExtension: return "OpSourceExtension";
-    case OpName: return "OpName";
-    case OpMemberName: return "OpMemberName";
-    case OpString: return "OpString";
-    case OpLine: return "OpLine";
-    case OpExtension: return "OpExtension";
-    case OpExtInstImport: return "OpExtInstImport";
-    case OpExtInst: return "OpExtInst";
-    case OpMemoryModel: return "OpMemoryModel";
-    case OpEntryPoint: return "OpEntryPoint";
-    case OpExecutionMode: return "OpExecutionMode";
-    case OpCapability: return "OpCapability";
-    case OpTypeVoid: return "OpTypeVoid";
-    case OpTypeBool: return "OpTypeBool";
-    case OpTypeInt: return "OpTypeInt";
-    case OpTypeFloat: return "OpTypeFloat";
-    case OpTypeVector: return "OpTypeVector";
-    case OpTypeMatrix: return "OpTypeMatrix";
-    case OpTypeImage: return "OpTypeImage";
-    case OpTypeSampler: return "OpTypeSampler";
-    case OpTypeSampledImage: return "OpTypeSampledImage";
-    case OpTypeArray: return "OpTypeArray";
-    case OpTypeRuntimeArray: return "OpTypeRuntimeArray";
-    case OpTypeStruct: return "OpTypeStruct";
-    case OpTypeOpaque: return "OpTypeOpaque";
-    case OpTypePointer: return "OpTypePointer";
-    case OpTypeFunction: return "OpTypeFunction";
-    case OpTypeEvent: return "OpTypeEvent";
-    case OpTypeDeviceEvent: return "OpTypeDeviceEvent";
-    case OpTypeReserveId: return "OpTypeReserveId";
-    case OpTypeQueue: return "OpTypeQueue";
-    case OpTypePipe: return "OpTypePipe";
-    case OpTypeForwardPointer: return "OpTypeForwardPointer";
-    case OpConstantTrue: return "OpConstantTrue";
-    case OpConstantFalse: return "OpConstantFalse";
-    case OpConstant: return "OpConstant";
-    case OpConstantComposite: return "OpConstantComposite";
-    case OpConstantSampler: return "OpConstantSampler";
-    case OpConstantNull: return "OpConstantNull";
-    case OpSpecConstantTrue: return "OpSpecConstantTrue";
-    case OpSpecConstantFalse: return "OpSpecConstantFalse";
-    case OpSpecConstant: return "OpSpecConstant";
-    case OpSpecConstantComposite: return "OpSpecConstantComposite";
-    case OpSpecConstantOp: return "OpSpecConstantOp";
-    case OpFunction: return "OpFunction";
-    case OpFunctionParameter: return "OpFunctionParameter";
-    case OpFunctionEnd: return "OpFunctionEnd";
-    case OpFunctionCall: return "OpFunctionCall";
-    case OpVariable: return "OpVariable";
-    case OpImageTexelPointer: return "OpImageTexelPointer";
-    case OpLoad: return "OpLoad";
-    case OpStore: return "OpStore";
-    case OpCopyMemory: return "OpCopyMemory";
-    case OpCopyMemorySized: return "OpCopyMemorySized";
-    case OpAccessChain: return "OpAccessChain";
-    case OpInBoundsAccessChain: return "OpInBoundsAccessChain";
-    case OpPtrAccessChain: return "OpPtrAccessChain";
-    case OpArrayLength: return "OpArrayLength";
-    case OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics";
-    case OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain";
-    case OpDecorate: return "OpDecorate";
-    case OpMemberDecorate: return "OpMemberDecorate";
-    case OpDecorationGroup: return "OpDecorationGroup";
-    case OpGroupDecorate: return "OpGroupDecorate";
-    case OpGroupMemberDecorate: return "OpGroupMemberDecorate";
-    case OpVectorExtractDynamic: return "OpVectorExtractDynamic";
-    case OpVectorInsertDynamic: return "OpVectorInsertDynamic";
-    case OpVectorShuffle: return "OpVectorShuffle";
-    case OpCompositeConstruct: return "OpCompositeConstruct";
-    case OpCompositeExtract: return "OpCompositeExtract";
-    case OpCompositeInsert: return "OpCompositeInsert";
-    case OpCopyObject: return "OpCopyObject";
-    case OpTranspose: return "OpTranspose";
-    case OpSampledImage: return "OpSampledImage";
-    case OpImageSampleImplicitLod: return "OpImageSampleImplicitLod";
-    case OpImageSampleExplicitLod: return "OpImageSampleExplicitLod";
-    case OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod";
-    case OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod";
-    case OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod";
-    case OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod";
-    case OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod";
-    case OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod";
-    case OpImageFetch: return "OpImageFetch";
-    case OpImageGather: return "OpImageGather";
-    case OpImageDrefGather: return "OpImageDrefGather";
-    case OpImageRead: return "OpImageRead";
-    case OpImageWrite: return "OpImageWrite";
-    case OpImage: return "OpImage";
-    case OpImageQueryFormat: return "OpImageQueryFormat";
-    case OpImageQueryOrder: return "OpImageQueryOrder";
-    case OpImageQuerySizeLod: return "OpImageQuerySizeLod";
-    case OpImageQuerySize: return "OpImageQuerySize";
-    case OpImageQueryLod: return "OpImageQueryLod";
-    case OpImageQueryLevels: return "OpImageQueryLevels";
-    case OpImageQuerySamples: return "OpImageQuerySamples";
-    case OpConvertFToU: return "OpConvertFToU";
-    case OpConvertFToS: return "OpConvertFToS";
-    case OpConvertSToF: return "OpConvertSToF";
-    case OpConvertUToF: return "OpConvertUToF";
-    case OpUConvert: return "OpUConvert";
-    case OpSConvert: return "OpSConvert";
-    case OpFConvert: return "OpFConvert";
-    case OpQuantizeToF16: return "OpQuantizeToF16";
-    case OpConvertPtrToU: return "OpConvertPtrToU";
-    case OpSatConvertSToU: return "OpSatConvertSToU";
-    case OpSatConvertUToS: return "OpSatConvertUToS";
-    case OpConvertUToPtr: return "OpConvertUToPtr";
-    case OpPtrCastToGeneric: return "OpPtrCastToGeneric";
-    case OpGenericCastToPtr: return "OpGenericCastToPtr";
-    case OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit";
-    case OpBitcast: return "OpBitcast";
-    case OpSNegate: return "OpSNegate";
-    case OpFNegate: return "OpFNegate";
-    case OpIAdd: return "OpIAdd";
-    case OpFAdd: return "OpFAdd";
-    case OpISub: return "OpISub";
-    case OpFSub: return "OpFSub";
-    case OpIMul: return "OpIMul";
-    case OpFMul: return "OpFMul";
-    case OpUDiv: return "OpUDiv";
-    case OpSDiv: return "OpSDiv";
-    case OpFDiv: return "OpFDiv";
-    case OpUMod: return "OpUMod";
-    case OpSRem: return "OpSRem";
-    case OpSMod: return "OpSMod";
-    case OpFRem: return "OpFRem";
-    case OpFMod: return "OpFMod";
-    case OpVectorTimesScalar: return "OpVectorTimesScalar";
-    case OpMatrixTimesScalar: return "OpMatrixTimesScalar";
-    case OpVectorTimesMatrix: return "OpVectorTimesMatrix";
-    case OpMatrixTimesVector: return "OpMatrixTimesVector";
-    case OpMatrixTimesMatrix: return "OpMatrixTimesMatrix";
-    case OpOuterProduct: return "OpOuterProduct";
-    case OpDot: return "OpDot";
-    case OpIAddCarry: return "OpIAddCarry";
-    case OpISubBorrow: return "OpISubBorrow";
-    case OpUMulExtended: return "OpUMulExtended";
-    case OpSMulExtended: return "OpSMulExtended";
-    case OpAny: return "OpAny";
-    case OpAll: return "OpAll";
-    case OpIsNan: return "OpIsNan";
-    case OpIsInf: return "OpIsInf";
-    case OpIsFinite: return "OpIsFinite";
-    case OpIsNormal: return "OpIsNormal";
-    case OpSignBitSet: return "OpSignBitSet";
-    case OpLessOrGreater: return "OpLessOrGreater";
-    case OpOrdered: return "OpOrdered";
-    case OpUnordered: return "OpUnordered";
-    case OpLogicalEqual: return "OpLogicalEqual";
-    case OpLogicalNotEqual: return "OpLogicalNotEqual";
-    case OpLogicalOr: return "OpLogicalOr";
-    case OpLogicalAnd: return "OpLogicalAnd";
-    case OpLogicalNot: return "OpLogicalNot";
-    case OpSelect: return "OpSelect";
-    case OpIEqual: return "OpIEqual";
-    case OpINotEqual: return "OpINotEqual";
-    case OpUGreaterThan: return "OpUGreaterThan";
-    case OpSGreaterThan: return "OpSGreaterThan";
-    case OpUGreaterThanEqual: return "OpUGreaterThanEqual";
-    case OpSGreaterThanEqual: return "OpSGreaterThanEqual";
-    case OpULessThan: return "OpULessThan";
-    case OpSLessThan: return "OpSLessThan";
-    case OpULessThanEqual: return "OpULessThanEqual";
-    case OpSLessThanEqual: return "OpSLessThanEqual";
-    case OpFOrdEqual: return "OpFOrdEqual";
-    case OpFUnordEqual: return "OpFUnordEqual";
-    case OpFOrdNotEqual: return "OpFOrdNotEqual";
-    case OpFUnordNotEqual: return "OpFUnordNotEqual";
-    case OpFOrdLessThan: return "OpFOrdLessThan";
-    case OpFUnordLessThan: return "OpFUnordLessThan";
-    case OpFOrdGreaterThan: return "OpFOrdGreaterThan";
-    case OpFUnordGreaterThan: return "OpFUnordGreaterThan";
-    case OpFOrdLessThanEqual: return "OpFOrdLessThanEqual";
-    case OpFUnordLessThanEqual: return "OpFUnordLessThanEqual";
-    case OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual";
-    case OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual";
-    case OpShiftRightLogical: return "OpShiftRightLogical";
-    case OpShiftRightArithmetic: return "OpShiftRightArithmetic";
-    case OpShiftLeftLogical: return "OpShiftLeftLogical";
-    case OpBitwiseOr: return "OpBitwiseOr";
-    case OpBitwiseXor: return "OpBitwiseXor";
-    case OpBitwiseAnd: return "OpBitwiseAnd";
-    case OpNot: return "OpNot";
-    case OpBitFieldInsert: return "OpBitFieldInsert";
-    case OpBitFieldSExtract: return "OpBitFieldSExtract";
-    case OpBitFieldUExtract: return "OpBitFieldUExtract";
-    case OpBitReverse: return "OpBitReverse";
-    case OpBitCount: return "OpBitCount";
-    case OpDPdx: return "OpDPdx";
-    case OpDPdy: return "OpDPdy";
-    case OpFwidth: return "OpFwidth";
-    case OpDPdxFine: return "OpDPdxFine";
-    case OpDPdyFine: return "OpDPdyFine";
-    case OpFwidthFine: return "OpFwidthFine";
-    case OpDPdxCoarse: return "OpDPdxCoarse";
-    case OpDPdyCoarse: return "OpDPdyCoarse";
-    case OpFwidthCoarse: return "OpFwidthCoarse";
-    case OpEmitVertex: return "OpEmitVertex";
-    case OpEndPrimitive: return "OpEndPrimitive";
-    case OpEmitStreamVertex: return "OpEmitStreamVertex";
-    case OpEndStreamPrimitive: return "OpEndStreamPrimitive";
-    case OpControlBarrier: return "OpControlBarrier";
-    case OpMemoryBarrier: return "OpMemoryBarrier";
-    case OpAtomicLoad: return "OpAtomicLoad";
-    case OpAtomicStore: return "OpAtomicStore";
-    case OpAtomicExchange: return "OpAtomicExchange";
-    case OpAtomicCompareExchange: return "OpAtomicCompareExchange";
-    case OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak";
-    case OpAtomicIIncrement: return "OpAtomicIIncrement";
-    case OpAtomicIDecrement: return "OpAtomicIDecrement";
-    case OpAtomicIAdd: return "OpAtomicIAdd";
-    case OpAtomicISub: return "OpAtomicISub";
-    case OpAtomicSMin: return "OpAtomicSMin";
-    case OpAtomicUMin: return "OpAtomicUMin";
-    case OpAtomicSMax: return "OpAtomicSMax";
-    case OpAtomicUMax: return "OpAtomicUMax";
-    case OpAtomicAnd: return "OpAtomicAnd";
-    case OpAtomicOr: return "OpAtomicOr";
-    case OpAtomicXor: return "OpAtomicXor";
-    case OpPhi: return "OpPhi";
-    case OpLoopMerge: return "OpLoopMerge";
-    case OpSelectionMerge: return "OpSelectionMerge";
-    case OpLabel: return "OpLabel";
-    case OpBranch: return "OpBranch";
-    case OpBranchConditional: return "OpBranchConditional";
-    case OpSwitch: return "OpSwitch";
-    case OpKill: return "OpKill";
-    case OpReturn: return "OpReturn";
-    case OpReturnValue: return "OpReturnValue";
-    case OpUnreachable: return "OpUnreachable";
-    case OpLifetimeStart: return "OpLifetimeStart";
-    case OpLifetimeStop: return "OpLifetimeStop";
-    case OpGroupAsyncCopy: return "OpGroupAsyncCopy";
-    case OpGroupWaitEvents: return "OpGroupWaitEvents";
-    case OpGroupAll: return "OpGroupAll";
-    case OpGroupAny: return "OpGroupAny";
-    case OpGroupBroadcast: return "OpGroupBroadcast";
-    case OpGroupIAdd: return "OpGroupIAdd";
-    case OpGroupFAdd: return "OpGroupFAdd";
-    case OpGroupFMin: return "OpGroupFMin";
-    case OpGroupUMin: return "OpGroupUMin";
-    case OpGroupSMin: return "OpGroupSMin";
-    case OpGroupFMax: return "OpGroupFMax";
-    case OpGroupUMax: return "OpGroupUMax";
-    case OpGroupSMax: return "OpGroupSMax";
-    case OpReadPipe: return "OpReadPipe";
-    case OpWritePipe: return "OpWritePipe";
-    case OpReservedReadPipe: return "OpReservedReadPipe";
-    case OpReservedWritePipe: return "OpReservedWritePipe";
-    case OpReserveReadPipePackets: return "OpReserveReadPipePackets";
-    case OpReserveWritePipePackets: return "OpReserveWritePipePackets";
-    case OpCommitReadPipe: return "OpCommitReadPipe";
-    case OpCommitWritePipe: return "OpCommitWritePipe";
-    case OpIsValidReserveId: return "OpIsValidReserveId";
-    case OpGetNumPipePackets: return "OpGetNumPipePackets";
-    case OpGetMaxPipePackets: return "OpGetMaxPipePackets";
-    case OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets";
-    case OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets";
-    case OpGroupCommitReadPipe: return "OpGroupCommitReadPipe";
-    case OpGroupCommitWritePipe: return "OpGroupCommitWritePipe";
-    case OpEnqueueMarker: return "OpEnqueueMarker";
-    case OpEnqueueKernel: return "OpEnqueueKernel";
-    case OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount";
-    case OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize";
-    case OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize";
-    case OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple";
-    case OpRetainEvent: return "OpRetainEvent";
-    case OpReleaseEvent: return "OpReleaseEvent";
-    case OpCreateUserEvent: return "OpCreateUserEvent";
-    case OpIsValidEvent: return "OpIsValidEvent";
-    case OpSetUserEventStatus: return "OpSetUserEventStatus";
-    case OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo";
-    case OpGetDefaultQueue: return "OpGetDefaultQueue";
-    case OpBuildNDRange: return "OpBuildNDRange";
-    case OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod";
-    case OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod";
-    case OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod";
-    case OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod";
-    case OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod";
-    case OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod";
-    case OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod";
-    case OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod";
-    case OpImageSparseFetch: return "OpImageSparseFetch";
-    case OpImageSparseGather: return "OpImageSparseGather";
-    case OpImageSparseDrefGather: return "OpImageSparseDrefGather";
-    case OpImageSparseTexelsResident: return "OpImageSparseTexelsResident";
-    case OpNoLine: return "OpNoLine";
-    case OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet";
-    case OpAtomicFlagClear: return "OpAtomicFlagClear";
-    case OpImageSparseRead: return "OpImageSparseRead";
-    case OpSizeOf: return "OpSizeOf";
-    case OpTypePipeStorage: return "OpTypePipeStorage";
-    case OpConstantPipeStorage: return "OpConstantPipeStorage";
-    case OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage";
-    case OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount";
-    case OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups";
-    case OpTypeNamedBarrier: return "OpTypeNamedBarrier";
-    case OpNamedBarrierInitialize: return "OpNamedBarrierInitialize";
-    case OpMemoryNamedBarrier: return "OpMemoryNamedBarrier";
-    case OpModuleProcessed: return "OpModuleProcessed";
-    case OpExecutionModeId: return "OpExecutionModeId";
-    case OpDecorateId: return "OpDecorateId";
-    case OpGroupNonUniformElect: return "OpGroupNonUniformElect";
-    case OpGroupNonUniformAll: return "OpGroupNonUniformAll";
-    case OpGroupNonUniformAny: return "OpGroupNonUniformAny";
-    case OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual";
-    case OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast";
-    case OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst";
-    case OpGroupNonUniformBallot: return "OpGroupNonUniformBallot";
-    case OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot";
-    case OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract";
-    case OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount";
-    case OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB";
-    case OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB";
-    case OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle";
-    case OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor";
-    case OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp";
-    case OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown";
-    case OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd";
-    case OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd";
-    case OpGroupNonUniformIMul: return "OpGroupNonUniformIMul";
-    case OpGroupNonUniformFMul: return "OpGroupNonUniformFMul";
-    case OpGroupNonUniformSMin: return "OpGroupNonUniformSMin";
-    case OpGroupNonUniformUMin: return "OpGroupNonUniformUMin";
-    case OpGroupNonUniformFMin: return "OpGroupNonUniformFMin";
-    case OpGroupNonUniformSMax: return "OpGroupNonUniformSMax";
-    case OpGroupNonUniformUMax: return "OpGroupNonUniformUMax";
-    case OpGroupNonUniformFMax: return "OpGroupNonUniformFMax";
-    case OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd";
-    case OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr";
-    case OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor";
-    case OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd";
-    case OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr";
-    case OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor";
-    case OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast";
-    case OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap";
-    case OpCopyLogical: return "OpCopyLogical";
-    case OpPtrEqual: return "OpPtrEqual";
-    case OpPtrNotEqual: return "OpPtrNotEqual";
-    case OpPtrDiff: return "OpPtrDiff";
-    case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
-    case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
-    case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
-    case OpTerminateInvocation: return "OpTerminateInvocation";
-    case OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR";
-    case OpUntypedVariableKHR: return "OpUntypedVariableKHR";
-    case OpUntypedAccessChainKHR: return "OpUntypedAccessChainKHR";
-    case OpUntypedInBoundsAccessChainKHR: return "OpUntypedInBoundsAccessChainKHR";
-    case OpSubgroupBallotKHR: return "OpSubgroupBallotKHR";
-    case OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR";
-    case OpUntypedPtrAccessChainKHR: return "OpUntypedPtrAccessChainKHR";
-    case OpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR";
-    case OpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR";
-    case OpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR";
-    case OpSubgroupAllKHR: return "OpSubgroupAllKHR";
-    case OpSubgroupAnyKHR: return "OpSubgroupAnyKHR";
-    case OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR";
-    case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
-    case OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR";
-    case OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR";
-    case OpTraceRayKHR: return "OpTraceRayKHR";
-    case OpExecuteCallableKHR: return "OpExecuteCallableKHR";
-    case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
-    case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR";
-    case OpTerminateRayKHR: return "OpTerminateRayKHR";
-    case OpSDot: return "OpSDot";
-    case OpUDot: return "OpUDot";
-    case OpSUDot: return "OpSUDot";
-    case OpSDotAccSat: return "OpSDotAccSat";
-    case OpUDotAccSat: return "OpUDotAccSat";
-    case OpSUDotAccSat: return "OpSUDotAccSat";
-    case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR";
-    case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR";
-    case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR";
-    case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR";
-    case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR";
-    case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
-    case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
-    case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
-    case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
-    case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
-    case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR";
-    case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR";
-    case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR";
-    case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR";
-    case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR";
-    case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM";
-    case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
-    case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
-    case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
-    case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
-    case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
-    case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
-    case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
-    case OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD";
-    case OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD";
-    case OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD";
-    case OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD";
-    case OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD";
-    case OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD";
-    case OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD";
-    case OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD";
-    case OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD";
-    case OpFragmentFetchAMD: return "OpFragmentFetchAMD";
-    case OpReadClockKHR: return "OpReadClockKHR";
-    case OpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX";
-    case OpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX";
-    case OpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX";
-    case OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX";
-    case OpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX";
-    case OpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX";
-    case OpConstantStringAMDX: return "OpConstantStringAMDX";
-    case OpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX";
-    case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
-    case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
-    case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
-    case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
-    case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV";
-    case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV";
-    case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV";
-    case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV";
-    case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV";
-    case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV";
-    case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
-    case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
-    case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV";
-    case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV";
-    case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV";
-    case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV";
-    case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV";
-    case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV";
-    case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV";
-    case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV";
-    case OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV";
-    case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV";
-    case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV";
-    case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV";
-    case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV";
-    case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV";
-    case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV";
-    case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV";
-    case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV";
-    case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV";
-    case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV";
-    case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV";
-    case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV";
-    case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
-    case OpTypeHitObjectNV: return "OpTypeHitObjectNV";
-    case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
-    case OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
-    case OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
-    case OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
-    case OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
-    case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
-    case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
-    case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
-    case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
-    case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
-    case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
-    case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
-    case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
-    case OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
-    case OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
-    case OpReportIntersectionKHR: return "OpReportIntersectionKHR";
-    case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
-    case OpTerminateRayNV: return "OpTerminateRayNV";
-    case OpTraceNV: return "OpTraceNV";
-    case OpTraceMotionNV: return "OpTraceMotionNV";
-    case OpTraceRayMotionNV: return "OpTraceRayMotionNV";
-    case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
-    case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
-    case OpExecuteCallableNV: return "OpExecuteCallableNV";
-    case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
-    case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
-    case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
-    case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV";
-    case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
-    case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
-    case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
-    case OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
-    case OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
-    case OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
-    case OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
-    case OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
-    case OpTypeTensorViewNV: return "OpTypeTensorViewNV";
-    case OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
-    case OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
-    case OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
-    case OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
-    case OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
-    case OpCreateTensorViewNV: return "OpCreateTensorViewNV";
-    case OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
-    case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
-    case OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation";
-    case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
-    case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
-    case OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
-    case OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
-    case OpConvertUToImageNV: return "OpConvertUToImageNV";
-    case OpConvertUToSamplerNV: return "OpConvertUToSamplerNV";
-    case OpConvertImageToUNV: return "OpConvertImageToUNV";
-    case OpConvertSamplerToUNV: return "OpConvertSamplerToUNV";
-    case OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV";
-    case OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV";
-    case OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV";
-    case OpRawAccessChainNV: return "OpRawAccessChainNV";
-    case OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL";
-    case OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL";
-    case OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL";
-    case OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL";
-    case OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL";
-    case OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL";
-    case OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL";
-    case OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL";
-    case OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL";
-    case OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL";
-    case OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL";
-    case OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL";
-    case OpAbsISubINTEL: return "OpAbsISubINTEL";
-    case OpAbsUSubINTEL: return "OpAbsUSubINTEL";
-    case OpIAddSatINTEL: return "OpIAddSatINTEL";
-    case OpUAddSatINTEL: return "OpUAddSatINTEL";
-    case OpIAverageINTEL: return "OpIAverageINTEL";
-    case OpUAverageINTEL: return "OpUAverageINTEL";
-    case OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL";
-    case OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL";
-    case OpISubSatINTEL: return "OpISubSatINTEL";
-    case OpUSubSatINTEL: return "OpUSubSatINTEL";
-    case OpIMul32x16INTEL: return "OpIMul32x16INTEL";
-    case OpUMul32x16INTEL: return "OpUMul32x16INTEL";
-    case OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL";
-    case OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL";
-    case OpAsmTargetINTEL: return "OpAsmTargetINTEL";
-    case OpAsmINTEL: return "OpAsmINTEL";
-    case OpAsmCallINTEL: return "OpAsmCallINTEL";
-    case OpAtomicFMinEXT: return "OpAtomicFMinEXT";
-    case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
-    case OpAssumeTrueKHR: return "OpAssumeTrueKHR";
-    case OpExpectKHR: return "OpExpectKHR";
-    case OpDecorateString: return "OpDecorateString";
-    case OpMemberDecorateString: return "OpMemberDecorateString";
-    case OpVmeImageINTEL: return "OpVmeImageINTEL";
-    case OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL";
-    case OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL";
-    case OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL";
-    case OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL";
-    case OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL";
-    case OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL";
-    case OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL";
-    case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL";
-    case OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL";
-    case OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL";
-    case OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL";
-    case OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL";
-    case OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL";
-    case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL";
-    case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL";
-    case OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL";
-    case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL";
-    case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL";
-    case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL";
-    case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL";
-    case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL";
-    case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL";
-    case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL";
-    case OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL";
-    case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL";
-    case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL";
-    case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL";
-    case OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL";
-    case OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL";
-    case OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL";
-    case OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL";
-    case OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL";
-    case OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL";
-    case OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL";
-    case OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL";
-    case OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL";
-    case OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL";
-    case OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL";
-    case OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL";
-    case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL";
-    case OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL";
-    case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL";
-    case OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL";
-    case OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL";
-    case OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL";
-    case OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL";
-    case OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL";
-    case OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL";
-    case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL";
-    case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL";
-    case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL";
-    case OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL";
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL";
-    case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL";
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL";
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL";
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL";
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL";
-    case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL";
-    case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL";
-    case OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL";
-    case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL";
-    case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL";
-    case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL";
-    case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL";
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL";
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL";
-    case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL";
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL";
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL";
-    case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL";
-    case OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL";
-    case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL";
-    case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL";
-    case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL";
-    case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL";
-    case OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL";
-    case OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL";
-    case OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL";
-    case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL";
-    case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL";
-    case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL";
-    case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL";
-    case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL";
-    case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL";
-    case OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL";
-    case OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL";
-    case OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL";
-    case OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL";
-    case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL";
-    case OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL";
-    case OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL";
-    case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL";
-    case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL";
-    case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL";
-    case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL";
-    case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL";
-    case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL";
-    case OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL";
-    case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL";
-    case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL";
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL";
-    case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL";
-    case OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL";
-    case OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL";
-    case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL";
-    case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL";
-    case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL";
-    case OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL";
-    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL";
-    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL";
-    case OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL";
-    case OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL";
-    case OpSaveMemoryINTEL: return "OpSaveMemoryINTEL";
-    case OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL";
-    case OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL";
-    case OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL";
-    case OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL";
-    case OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL";
-    case OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL";
-    case OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL";
-    case OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL";
-    case OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL";
-    case OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL";
-    case OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL";
-    case OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL";
-    case OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL";
-    case OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL";
-    case OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL";
-    case OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL";
-    case OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL";
-    case OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL";
-    case OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL";
-    case OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL";
-    case OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL";
-    case OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL";
-    case OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL";
-    case OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL";
-    case OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL";
-    case OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL";
-    case OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL";
-    case OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL";
-    case OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL";
-    case OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL";
-    case OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL";
-    case OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL";
-    case OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL";
-    case OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL";
-    case OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL";
-    case OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL";
-    case OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL";
-    case OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL";
-    case OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL";
-    case OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL";
-    case OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL";
-    case OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL";
-    case OpLoopControlINTEL: return "OpLoopControlINTEL";
-    case OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL";
-    case OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL";
-    case OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL";
-    case OpFixedSqrtINTEL: return "OpFixedSqrtINTEL";
-    case OpFixedRecipINTEL: return "OpFixedRecipINTEL";
-    case OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL";
-    case OpFixedSinINTEL: return "OpFixedSinINTEL";
-    case OpFixedCosINTEL: return "OpFixedCosINTEL";
-    case OpFixedSinCosINTEL: return "OpFixedSinCosINTEL";
-    case OpFixedSinPiINTEL: return "OpFixedSinPiINTEL";
-    case OpFixedCosPiINTEL: return "OpFixedCosPiINTEL";
-    case OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL";
-    case OpFixedLogINTEL: return "OpFixedLogINTEL";
-    case OpFixedExpINTEL: return "OpFixedExpINTEL";
-    case OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL";
-    case OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL";
-    case OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL";
-    case OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL";
-    case OpFPGARegINTEL: return "OpFPGARegINTEL";
-    case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR";
-    case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR";
-    case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR";
-    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
-    case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR";
-    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
-    case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR";
-    case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
-    case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR";
-    case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR";
-    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
-    case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
-    case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR";
-    case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR";
-    case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR";
-    case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR";
-    case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR";
-    case OpAtomicFAddEXT: return "OpAtomicFAddEXT";
-    case OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL";
-    case OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL";
-    case OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL";
-    case OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL";
-    case OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL";
-    case OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL";
-    case OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL";
-    case OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL";
-    case OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL";
-    case OpArithmeticFenceEXT: return "OpArithmeticFenceEXT";
-    case OpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL";
-    case OpGroupIMulKHR: return "OpGroupIMulKHR";
-    case OpGroupFMulKHR: return "OpGroupFMulKHR";
-    case OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";
-    case OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR";
-    case OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR";
-    case OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR";
-    case OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR";
-    case OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR";
-    case OpMaskedGatherINTEL: return "OpMaskedGatherINTEL";
-    case OpMaskedScatterINTEL: return "OpMaskedScatterINTEL";
-    default: return "Unknown";
-    }
-}
-
-#endif /* SPV_ENABLE_UTILITY_CODE */
-
-// Overload bitwise operators for mask bit combining
-
-inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
-inline ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
-inline ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
-inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
-inline FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
-inline FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
-inline FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
-inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
-inline SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
-inline SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
-inline SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
-inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
-inline LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
-inline LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
-inline LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
-inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
-inline FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
-inline FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
-inline FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
-inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
-inline MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
-inline MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
-inline MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
-inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
-inline MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
-inline MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
-inline MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
-inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
-inline KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
-inline KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
-inline KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
-inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
-inline RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
-inline RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
-inline RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
-inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
-inline FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
-inline FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
-inline FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
-inline CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) | unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); }
-inline CooperativeMatrixReduceMask operator|(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) | unsigned(b)); }
-inline CooperativeMatrixReduceMask operator&(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) & unsigned(b)); }
-inline CooperativeMatrixReduceMask operator^(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) ^ unsigned(b)); }
-inline CooperativeMatrixReduceMask operator~(CooperativeMatrixReduceMask a) { return CooperativeMatrixReduceMask(~unsigned(a)); }
-inline TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) | unsigned(b)); }
-inline TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); }
-inline TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); }
-inline RawAccessChainOperandsMask operator|(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) | unsigned(b)); }
-inline RawAccessChainOperandsMask operator&(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) & unsigned(b)); }
-inline RawAccessChainOperandsMask operator^(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline RawAccessChainOperandsMask operator~(RawAccessChainOperandsMask a) { return RawAccessChainOperandsMask(~unsigned(a)); }
-
-}  // end namespace spv
-
-#endif  // #ifndef spirv_HPP
-

SPIRV/spirv.hpp11

@@ -0,0 +1,5162 @@
+// Copyright (c) 2014-2024 The Khronos Group Inc.
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Materials.
+// 
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+// 
+// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+// This header is automatically generated by the same tool that creates
+// the Binary Section of the SPIR-V specification.
+
+// Enumeration tokens for SPIR-V, in various styles:
+//   C, C++, C++11, JSON, Lua, Python, C#, D, Beef
+// 
+// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+// - C# will use enum classes in the Specification class located in the "Spv" namespace,
+//     e.g.: Spv.Specification.SourceLanguage.GLSL
+// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
+// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
+//     e.g.: Spv.Specification.SourceLanguage.GLSL
+// 
+// Some tokens act like mask values, which can be OR'd together,
+// while others are mutually exclusive.  The mask-like ones have
+// "Mask" in their name, and a parallel enum that has the shift
+// amount (1 << x) for each corresponding enumerant.
+
+#ifndef spirv_HPP
+#define spirv_HPP
+
+namespace spv {
+
+typedef unsigned int Id;
+
+#define SPV_VERSION 0x10600
+#define SPV_REVISION 1
+
+static const unsigned int MagicNumber = 0x07230203;
+static const unsigned int Version = 0x00010600;
+static const unsigned int Revision = 1;
+static const unsigned int OpCodeMask = 0xffff;
+static const unsigned int WordCountShift = 16;
+
+enum class SourceLanguage : unsigned {
+    Unknown = 0,
+    ESSL = 1,
+    GLSL = 2,
+    OpenCL_C = 3,
+    OpenCL_CPP = 4,
+    HLSL = 5,
+    CPP_for_OpenCL = 6,
+    SYCL = 7,
+    HERO_C = 8,
+    NZSL = 9,
+    WGSL = 10,
+    Slang = 11,
+    Zig = 12,
+    Rust = 13,
+    Max = 0x7fffffff,
+};
+
+enum class ExecutionModel : unsigned {
+    Vertex = 0,
+    TessellationControl = 1,
+    TessellationEvaluation = 2,
+    Geometry = 3,
+    Fragment = 4,
+    GLCompute = 5,
+    Kernel = 6,
+    TaskNV = 5267,
+    MeshNV = 5268,
+    RayGenerationKHR = 5313,
+    RayGenerationNV = 5313,
+    IntersectionKHR = 5314,
+    IntersectionNV = 5314,
+    AnyHitKHR = 5315,
+    AnyHitNV = 5315,
+    ClosestHitKHR = 5316,
+    ClosestHitNV = 5316,
+    MissKHR = 5317,
+    MissNV = 5317,
+    CallableKHR = 5318,
+    CallableNV = 5318,
+    TaskEXT = 5364,
+    MeshEXT = 5365,
+    Max = 0x7fffffff,
+};
+
+enum class AddressingModel : unsigned {
+    Logical = 0,
+    Physical32 = 1,
+    Physical64 = 2,
+    PhysicalStorageBuffer64 = 5348,
+    PhysicalStorageBuffer64EXT = 5348,
+    Max = 0x7fffffff,
+};
+
+enum class MemoryModel : unsigned {
+    Simple = 0,
+    GLSL450 = 1,
+    OpenCL = 2,
+    Vulkan = 3,
+    VulkanKHR = 3,
+    Max = 0x7fffffff,
+};
+
+enum class ExecutionMode : unsigned {
+    Invocations = 0,
+    SpacingEqual = 1,
+    SpacingFractionalEven = 2,
+    SpacingFractionalOdd = 3,
+    VertexOrderCw = 4,
+    VertexOrderCcw = 5,
+    PixelCenterInteger = 6,
+    OriginUpperLeft = 7,
+    OriginLowerLeft = 8,
+    EarlyFragmentTests = 9,
+    PointMode = 10,
+    Xfb = 11,
+    DepthReplacing = 12,
+    DepthGreater = 14,
+    DepthLess = 15,
+    DepthUnchanged = 16,
+    LocalSize = 17,
+    LocalSizeHint = 18,
+    InputPoints = 19,
+    InputLines = 20,
+    InputLinesAdjacency = 21,
+    Triangles = 22,
+    InputTrianglesAdjacency = 23,
+    Quads = 24,
+    Isolines = 25,
+    OutputVertices = 26,
+    OutputPoints = 27,
+    OutputLineStrip = 28,
+    OutputTriangleStrip = 29,
+    VecTypeHint = 30,
+    ContractionOff = 31,
+    Initializer = 33,
+    Finalizer = 34,
+    SubgroupSize = 35,
+    SubgroupsPerWorkgroup = 36,
+    SubgroupsPerWorkgroupId = 37,
+    LocalSizeId = 38,
+    LocalSizeHintId = 39,
+    NonCoherentColorAttachmentReadEXT = 4169,
+    NonCoherentDepthAttachmentReadEXT = 4170,
+    NonCoherentStencilAttachmentReadEXT = 4171,
+    SubgroupUniformControlFlowKHR = 4421,
+    PostDepthCoverage = 4446,
+    DenormPreserve = 4459,
+    DenormFlushToZero = 4460,
+    SignedZeroInfNanPreserve = 4461,
+    RoundingModeRTE = 4462,
+    RoundingModeRTZ = 4463,
+    EarlyAndLateFragmentTestsAMD = 5017,
+    StencilRefReplacingEXT = 5027,
+    CoalescingAMDX = 5069,
+    IsApiEntryAMDX = 5070,
+    MaxNodeRecursionAMDX = 5071,
+    StaticNumWorkgroupsAMDX = 5072,
+    ShaderIndexAMDX = 5073,
+    MaxNumWorkgroupsAMDX = 5077,
+    StencilRefUnchangedFrontAMD = 5079,
+    StencilRefGreaterFrontAMD = 5080,
+    StencilRefLessFrontAMD = 5081,
+    StencilRefUnchangedBackAMD = 5082,
+    StencilRefGreaterBackAMD = 5083,
+    StencilRefLessBackAMD = 5084,
+    QuadDerivativesKHR = 5088,
+    RequireFullQuadsKHR = 5089,
+    SharesInputWithAMDX = 5102,
+    OutputLinesEXT = 5269,
+    OutputLinesNV = 5269,
+    OutputPrimitivesEXT = 5270,
+    OutputPrimitivesNV = 5270,
+    DerivativeGroupQuadsKHR = 5289,
+    DerivativeGroupQuadsNV = 5289,
+    DerivativeGroupLinearKHR = 5290,
+    DerivativeGroupLinearNV = 5290,
+    OutputTrianglesEXT = 5298,
+    OutputTrianglesNV = 5298,
+    PixelInterlockOrderedEXT = 5366,
+    PixelInterlockUnorderedEXT = 5367,
+    SampleInterlockOrderedEXT = 5368,
+    SampleInterlockUnorderedEXT = 5369,
+    ShadingRateInterlockOrderedEXT = 5370,
+    ShadingRateInterlockUnorderedEXT = 5371,
+    SharedLocalMemorySizeINTEL = 5618,
+    RoundingModeRTPINTEL = 5620,
+    RoundingModeRTNINTEL = 5621,
+    FloatingPointModeALTINTEL = 5622,
+    FloatingPointModeIEEEINTEL = 5623,
+    MaxWorkgroupSizeINTEL = 5893,
+    MaxWorkDimINTEL = 5894,
+    NoGlobalOffsetINTEL = 5895,
+    NumSIMDWorkitemsINTEL = 5896,
+    SchedulerTargetFmaxMhzINTEL = 5903,
+    MaximallyReconvergesKHR = 6023,
+    FPFastMathDefault = 6028,
+    StreamingInterfaceINTEL = 6154,
+    RegisterMapInterfaceINTEL = 6160,
+    NamedBarrierCountINTEL = 6417,
+    MaximumRegistersINTEL = 6461,
+    MaximumRegistersIdINTEL = 6462,
+    NamedMaximumRegistersINTEL = 6463,
+    Max = 0x7fffffff,
+};
+
+enum class StorageClass : unsigned {
+    UniformConstant = 0,
+    Input = 1,
+    Uniform = 2,
+    Output = 3,
+    Workgroup = 4,
+    CrossWorkgroup = 5,
+    Private = 6,
+    Function = 7,
+    Generic = 8,
+    PushConstant = 9,
+    AtomicCounter = 10,
+    Image = 11,
+    StorageBuffer = 12,
+    TileImageEXT = 4172,
+    NodePayloadAMDX = 5068,
+    CallableDataKHR = 5328,
+    CallableDataNV = 5328,
+    IncomingCallableDataKHR = 5329,
+    IncomingCallableDataNV = 5329,
+    RayPayloadKHR = 5338,
+    RayPayloadNV = 5338,
+    HitAttributeKHR = 5339,
+    HitAttributeNV = 5339,
+    IncomingRayPayloadKHR = 5342,
+    IncomingRayPayloadNV = 5342,
+    ShaderRecordBufferKHR = 5343,
+    ShaderRecordBufferNV = 5343,
+    PhysicalStorageBuffer = 5349,
+    PhysicalStorageBufferEXT = 5349,
+    HitObjectAttributeNV = 5385,
+    TaskPayloadWorkgroupEXT = 5402,
+    CodeSectionINTEL = 5605,
+    DeviceOnlyINTEL = 5936,
+    HostOnlyINTEL = 5937,
+    Max = 0x7fffffff,
+};
+
+enum class Dim : unsigned {
+    Dim1D = 0,
+    Dim2D = 1,
+    Dim3D = 2,
+    Cube = 3,
+    Rect = 4,
+    Buffer = 5,
+    SubpassData = 6,
+    TileImageDataEXT = 4173,
+    Max = 0x7fffffff,
+};
+
+enum class SamplerAddressingMode : unsigned {
+    None = 0,
+    ClampToEdge = 1,
+    Clamp = 2,
+    Repeat = 3,
+    RepeatMirrored = 4,
+    Max = 0x7fffffff,
+};
+
+enum class SamplerFilterMode : unsigned {
+    Nearest = 0,
+    Linear = 1,
+    Max = 0x7fffffff,
+};
+
+enum class ImageFormat : unsigned {
+    Unknown = 0,
+    Rgba32f = 1,
+    Rgba16f = 2,
+    R32f = 3,
+    Rgba8 = 4,
+    Rgba8Snorm = 5,
+    Rg32f = 6,
+    Rg16f = 7,
+    R11fG11fB10f = 8,
+    R16f = 9,
+    Rgba16 = 10,
+    Rgb10A2 = 11,
+    Rg16 = 12,
+    Rg8 = 13,
+    R16 = 14,
+    R8 = 15,
+    Rgba16Snorm = 16,
+    Rg16Snorm = 17,
+    Rg8Snorm = 18,
+    R16Snorm = 19,
+    R8Snorm = 20,
+    Rgba32i = 21,
+    Rgba16i = 22,
+    Rgba8i = 23,
+    R32i = 24,
+    Rg32i = 25,
+    Rg16i = 26,
+    Rg8i = 27,
+    R16i = 28,
+    R8i = 29,
+    Rgba32ui = 30,
+    Rgba16ui = 31,
+    Rgba8ui = 32,
+    R32ui = 33,
+    Rgb10a2ui = 34,
+    Rg32ui = 35,
+    Rg16ui = 36,
+    Rg8ui = 37,
+    R16ui = 38,
+    R8ui = 39,
+    R64ui = 40,
+    R64i = 41,
+    Max = 0x7fffffff,
+};
+
+enum class ImageChannelOrder : unsigned {
+    R = 0,
+    A = 1,
+    RG = 2,
+    RA = 3,
+    RGB = 4,
+    RGBA = 5,
+    BGRA = 6,
+    ARGB = 7,
+    Intensity = 8,
+    Luminance = 9,
+    Rx = 10,
+    RGx = 11,
+    RGBx = 12,
+    Depth = 13,
+    DepthStencil = 14,
+    sRGB = 15,
+    sRGBx = 16,
+    sRGBA = 17,
+    sBGRA = 18,
+    ABGR = 19,
+    Max = 0x7fffffff,
+};
+
+enum class ImageChannelDataType : unsigned {
+    SnormInt8 = 0,
+    SnormInt16 = 1,
+    UnormInt8 = 2,
+    UnormInt16 = 3,
+    UnormShort565 = 4,
+    UnormShort555 = 5,
+    UnormInt101010 = 6,
+    SignedInt8 = 7,
+    SignedInt16 = 8,
+    SignedInt32 = 9,
+    UnsignedInt8 = 10,
+    UnsignedInt16 = 11,
+    UnsignedInt32 = 12,
+    HalfFloat = 13,
+    Float = 14,
+    UnormInt24 = 15,
+    UnormInt101010_2 = 16,
+    UnsignedIntRaw10EXT = 19,
+    UnsignedIntRaw12EXT = 20,
+    UnormInt2_101010EXT = 21,
+    Max = 0x7fffffff,
+};
+
+enum class ImageOperandsShift : unsigned {
+    Bias = 0,
+    Lod = 1,
+    Grad = 2,
+    ConstOffset = 3,
+    Offset = 4,
+    ConstOffsets = 5,
+    Sample = 6,
+    MinLod = 7,
+    MakeTexelAvailable = 8,
+    MakeTexelAvailableKHR = 8,
+    MakeTexelVisible = 9,
+    MakeTexelVisibleKHR = 9,
+    NonPrivateTexel = 10,
+    NonPrivateTexelKHR = 10,
+    VolatileTexel = 11,
+    VolatileTexelKHR = 11,
+    SignExtend = 12,
+    ZeroExtend = 13,
+    Nontemporal = 14,
+    Offsets = 16,
+    Max = 0x7fffffff,
+};
+
+enum class ImageOperandsMask : unsigned {
+    MaskNone = 0,
+    Bias = 0x00000001,
+    Lod = 0x00000002,
+    Grad = 0x00000004,
+    ConstOffset = 0x00000008,
+    Offset = 0x00000010,
+    ConstOffsets = 0x00000020,
+    Sample = 0x00000040,
+    MinLod = 0x00000080,
+    MakeTexelAvailable = 0x00000100,
+    MakeTexelAvailableKHR = 0x00000100,
+    MakeTexelVisible = 0x00000200,
+    MakeTexelVisibleKHR = 0x00000200,
+    NonPrivateTexel = 0x00000400,
+    NonPrivateTexelKHR = 0x00000400,
+    VolatileTexel = 0x00000800,
+    VolatileTexelKHR = 0x00000800,
+    SignExtend = 0x00001000,
+    ZeroExtend = 0x00002000,
+    Nontemporal = 0x00004000,
+    Offsets = 0x00010000,
+};
+
+enum class FPFastMathModeShift : unsigned {
+    NotNaN = 0,
+    NotInf = 1,
+    NSZ = 2,
+    AllowRecip = 3,
+    Fast = 4,
+    AllowContract = 16,
+    AllowContractFastINTEL = 16,
+    AllowReassoc = 17,
+    AllowReassocINTEL = 17,
+    AllowTransform = 18,
+    Max = 0x7fffffff,
+};
+
+enum class FPFastMathModeMask : unsigned {
+    MaskNone = 0,
+    NotNaN = 0x00000001,
+    NotInf = 0x00000002,
+    NSZ = 0x00000004,
+    AllowRecip = 0x00000008,
+    Fast = 0x00000010,
+    AllowContract = 0x00010000,
+    AllowContractFastINTEL = 0x00010000,
+    AllowReassoc = 0x00020000,
+    AllowReassocINTEL = 0x00020000,
+    AllowTransform = 0x00040000,
+};
+
+enum class FPRoundingMode : unsigned {
+    RTE = 0,
+    RTZ = 1,
+    RTP = 2,
+    RTN = 3,
+    Max = 0x7fffffff,
+};
+
+enum class LinkageType : unsigned {
+    Export = 0,
+    Import = 1,
+    LinkOnceODR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class AccessQualifier : unsigned {
+    ReadOnly = 0,
+    WriteOnly = 1,
+    ReadWrite = 2,
+    Max = 0x7fffffff,
+};
+
+enum class FunctionParameterAttribute : unsigned {
+    Zext = 0,
+    Sext = 1,
+    ByVal = 2,
+    Sret = 3,
+    NoAlias = 4,
+    NoCapture = 5,
+    NoWrite = 6,
+    NoReadWrite = 7,
+    RuntimeAlignedINTEL = 5940,
+    Max = 0x7fffffff,
+};
+
+enum class Decoration : unsigned {
+    RelaxedPrecision = 0,
+    SpecId = 1,
+    Block = 2,
+    BufferBlock = 3,
+    RowMajor = 4,
+    ColMajor = 5,
+    ArrayStride = 6,
+    MatrixStride = 7,
+    GLSLShared = 8,
+    GLSLPacked = 9,
+    CPacked = 10,
+    BuiltIn = 11,
+    NoPerspective = 13,
+    Flat = 14,
+    Patch = 15,
+    Centroid = 16,
+    Sample = 17,
+    Invariant = 18,
+    Restrict = 19,
+    Aliased = 20,
+    Volatile = 21,
+    Constant = 22,
+    Coherent = 23,
+    NonWritable = 24,
+    NonReadable = 25,
+    Uniform = 26,
+    UniformId = 27,
+    SaturatedConversion = 28,
+    Stream = 29,
+    Location = 30,
+    Component = 31,
+    Index = 32,
+    Binding = 33,
+    DescriptorSet = 34,
+    Offset = 35,
+    XfbBuffer = 36,
+    XfbStride = 37,
+    FuncParamAttr = 38,
+    FPRoundingMode = 39,
+    FPFastMathMode = 40,
+    LinkageAttributes = 41,
+    NoContraction = 42,
+    InputAttachmentIndex = 43,
+    Alignment = 44,
+    MaxByteOffset = 45,
+    AlignmentId = 46,
+    MaxByteOffsetId = 47,
+    NoSignedWrap = 4469,
+    NoUnsignedWrap = 4470,
+    WeightTextureQCOM = 4487,
+    BlockMatchTextureQCOM = 4488,
+    BlockMatchSamplerQCOM = 4499,
+    ExplicitInterpAMD = 4999,
+    NodeSharesPayloadLimitsWithAMDX = 5019,
+    NodeMaxPayloadsAMDX = 5020,
+    TrackFinishWritingAMDX = 5078,
+    PayloadNodeNameAMDX = 5091,
+    PayloadNodeBaseIndexAMDX = 5098,
+    PayloadNodeSparseArrayAMDX = 5099,
+    PayloadNodeArraySizeAMDX = 5100,
+    PayloadDispatchIndirectAMDX = 5105,
+    OverrideCoverageNV = 5248,
+    PassthroughNV = 5250,
+    ViewportRelativeNV = 5252,
+    SecondaryViewportRelativeNV = 5256,
+    PerPrimitiveEXT = 5271,
+    PerPrimitiveNV = 5271,
+    PerViewNV = 5272,
+    PerTaskNV = 5273,
+    PerVertexKHR = 5285,
+    PerVertexNV = 5285,
+    NonUniform = 5300,
+    NonUniformEXT = 5300,
+    RestrictPointer = 5355,
+    RestrictPointerEXT = 5355,
+    AliasedPointer = 5356,
+    AliasedPointerEXT = 5356,
+    HitObjectShaderRecordBufferNV = 5386,
+    BindlessSamplerNV = 5398,
+    BindlessImageNV = 5399,
+    BoundSamplerNV = 5400,
+    BoundImageNV = 5401,
+    SIMTCallINTEL = 5599,
+    ReferencedIndirectlyINTEL = 5602,
+    ClobberINTEL = 5607,
+    SideEffectsINTEL = 5608,
+    VectorComputeVariableINTEL = 5624,
+    FuncParamIOKindINTEL = 5625,
+    VectorComputeFunctionINTEL = 5626,
+    StackCallINTEL = 5627,
+    GlobalVariableOffsetINTEL = 5628,
+    CounterBuffer = 5634,
+    HlslCounterBufferGOOGLE = 5634,
+    HlslSemanticGOOGLE = 5635,
+    UserSemantic = 5635,
+    UserTypeGOOGLE = 5636,
+    FunctionRoundingModeINTEL = 5822,
+    FunctionDenormModeINTEL = 5823,
+    RegisterINTEL = 5825,
+    MemoryINTEL = 5826,
+    NumbanksINTEL = 5827,
+    BankwidthINTEL = 5828,
+    MaxPrivateCopiesINTEL = 5829,
+    SinglepumpINTEL = 5830,
+    DoublepumpINTEL = 5831,
+    MaxReplicatesINTEL = 5832,
+    SimpleDualPortINTEL = 5833,
+    MergeINTEL = 5834,
+    BankBitsINTEL = 5835,
+    ForcePow2DepthINTEL = 5836,
+    StridesizeINTEL = 5883,
+    WordsizeINTEL = 5884,
+    TrueDualPortINTEL = 5885,
+    BurstCoalesceINTEL = 5899,
+    CacheSizeINTEL = 5900,
+    DontStaticallyCoalesceINTEL = 5901,
+    PrefetchINTEL = 5902,
+    StallEnableINTEL = 5905,
+    FuseLoopsInFunctionINTEL = 5907,
+    MathOpDSPModeINTEL = 5909,
+    AliasScopeINTEL = 5914,
+    NoAliasINTEL = 5915,
+    InitiationIntervalINTEL = 5917,
+    MaxConcurrencyINTEL = 5918,
+    PipelineEnableINTEL = 5919,
+    BufferLocationINTEL = 5921,
+    IOPipeStorageINTEL = 5944,
+    FunctionFloatingPointModeINTEL = 6080,
+    SingleElementVectorINTEL = 6085,
+    VectorComputeCallableFunctionINTEL = 6087,
+    MediaBlockIOINTEL = 6140,
+    StallFreeINTEL = 6151,
+    FPMaxErrorDecorationINTEL = 6170,
+    LatencyControlLabelINTEL = 6172,
+    LatencyControlConstraintINTEL = 6173,
+    ConduitKernelArgumentINTEL = 6175,
+    RegisterMapKernelArgumentINTEL = 6176,
+    MMHostInterfaceAddressWidthINTEL = 6177,
+    MMHostInterfaceDataWidthINTEL = 6178,
+    MMHostInterfaceLatencyINTEL = 6179,
+    MMHostInterfaceReadWriteModeINTEL = 6180,
+    MMHostInterfaceMaxBurstINTEL = 6181,
+    MMHostInterfaceWaitRequestINTEL = 6182,
+    StableKernelArgumentINTEL = 6183,
+    HostAccessINTEL = 6188,
+    InitModeINTEL = 6190,
+    ImplementInRegisterMapINTEL = 6191,
+    CacheControlLoadINTEL = 6442,
+    CacheControlStoreINTEL = 6443,
+    Max = 0x7fffffff,
+};
+
+enum class BuiltIn : unsigned {
+    Position = 0,
+    PointSize = 1,
+    ClipDistance = 3,
+    CullDistance = 4,
+    VertexId = 5,
+    InstanceId = 6,
+    PrimitiveId = 7,
+    InvocationId = 8,
+    Layer = 9,
+    ViewportIndex = 10,
+    TessLevelOuter = 11,
+    TessLevelInner = 12,
+    TessCoord = 13,
+    PatchVertices = 14,
+    FragCoord = 15,
+    PointCoord = 16,
+    FrontFacing = 17,
+    SampleId = 18,
+    SamplePosition = 19,
+    SampleMask = 20,
+    FragDepth = 22,
+    HelperInvocation = 23,
+    NumWorkgroups = 24,
+    WorkgroupSize = 25,
+    WorkgroupId = 26,
+    LocalInvocationId = 27,
+    GlobalInvocationId = 28,
+    LocalInvocationIndex = 29,
+    WorkDim = 30,
+    GlobalSize = 31,
+    EnqueuedWorkgroupSize = 32,
+    GlobalOffset = 33,
+    GlobalLinearId = 34,
+    SubgroupSize = 36,
+    SubgroupMaxSize = 37,
+    NumSubgroups = 38,
+    NumEnqueuedSubgroups = 39,
+    SubgroupId = 40,
+    SubgroupLocalInvocationId = 41,
+    VertexIndex = 42,
+    InstanceIndex = 43,
+    CoreIDARM = 4160,
+    CoreCountARM = 4161,
+    CoreMaxIDARM = 4162,
+    WarpIDARM = 4163,
+    WarpMaxIDARM = 4164,
+    SubgroupEqMask = 4416,
+    SubgroupEqMaskKHR = 4416,
+    SubgroupGeMask = 4417,
+    SubgroupGeMaskKHR = 4417,
+    SubgroupGtMask = 4418,
+    SubgroupGtMaskKHR = 4418,
+    SubgroupLeMask = 4419,
+    SubgroupLeMaskKHR = 4419,
+    SubgroupLtMask = 4420,
+    SubgroupLtMaskKHR = 4420,
+    BaseVertex = 4424,
+    BaseInstance = 4425,
+    DrawIndex = 4426,
+    PrimitiveShadingRateKHR = 4432,
+    DeviceIndex = 4438,
+    ViewIndex = 4440,
+    ShadingRateKHR = 4444,
+    BaryCoordNoPerspAMD = 4992,
+    BaryCoordNoPerspCentroidAMD = 4993,
+    BaryCoordNoPerspSampleAMD = 4994,
+    BaryCoordSmoothAMD = 4995,
+    BaryCoordSmoothCentroidAMD = 4996,
+    BaryCoordSmoothSampleAMD = 4997,
+    BaryCoordPullModelAMD = 4998,
+    FragStencilRefEXT = 5014,
+    RemainingRecursionLevelsAMDX = 5021,
+    ShaderIndexAMDX = 5073,
+    ViewportMaskNV = 5253,
+    SecondaryPositionNV = 5257,
+    SecondaryViewportMaskNV = 5258,
+    PositionPerViewNV = 5261,
+    ViewportMaskPerViewNV = 5262,
+    FullyCoveredEXT = 5264,
+    TaskCountNV = 5274,
+    PrimitiveCountNV = 5275,
+    PrimitiveIndicesNV = 5276,
+    ClipDistancePerViewNV = 5277,
+    CullDistancePerViewNV = 5278,
+    LayerPerViewNV = 5279,
+    MeshViewCountNV = 5280,
+    MeshViewIndicesNV = 5281,
+    BaryCoordKHR = 5286,
+    BaryCoordNV = 5286,
+    BaryCoordNoPerspKHR = 5287,
+    BaryCoordNoPerspNV = 5287,
+    FragSizeEXT = 5292,
+    FragmentSizeNV = 5292,
+    FragInvocationCountEXT = 5293,
+    InvocationsPerPixelNV = 5293,
+    PrimitivePointIndicesEXT = 5294,
+    PrimitiveLineIndicesEXT = 5295,
+    PrimitiveTriangleIndicesEXT = 5296,
+    CullPrimitiveEXT = 5299,
+    LaunchIdKHR = 5319,
+    LaunchIdNV = 5319,
+    LaunchSizeKHR = 5320,
+    LaunchSizeNV = 5320,
+    WorldRayOriginKHR = 5321,
+    WorldRayOriginNV = 5321,
+    WorldRayDirectionKHR = 5322,
+    WorldRayDirectionNV = 5322,
+    ObjectRayOriginKHR = 5323,
+    ObjectRayOriginNV = 5323,
+    ObjectRayDirectionKHR = 5324,
+    ObjectRayDirectionNV = 5324,
+    RayTminKHR = 5325,
+    RayTminNV = 5325,
+    RayTmaxKHR = 5326,
+    RayTmaxNV = 5326,
+    InstanceCustomIndexKHR = 5327,
+    InstanceCustomIndexNV = 5327,
+    ObjectToWorldKHR = 5330,
+    ObjectToWorldNV = 5330,
+    WorldToObjectKHR = 5331,
+    WorldToObjectNV = 5331,
+    HitTNV = 5332,
+    HitKindKHR = 5333,
+    HitKindNV = 5333,
+    CurrentRayTimeNV = 5334,
+    HitTriangleVertexPositionsKHR = 5335,
+    HitMicroTriangleVertexPositionsNV = 5337,
+    HitMicroTriangleVertexBarycentricsNV = 5344,
+    IncomingRayFlagsKHR = 5351,
+    IncomingRayFlagsNV = 5351,
+    RayGeometryIndexKHR = 5352,
+    HitIsSphereNV = 5359,
+    HitIsLSSNV = 5360,
+    HitSpherePositionNV = 5361,
+    WarpsPerSMNV = 5374,
+    SMCountNV = 5375,
+    WarpIDNV = 5376,
+    SMIDNV = 5377,
+    HitLSSPositionsNV = 5396,
+    HitKindFrontFacingMicroTriangleNV = 5405,
+    HitKindBackFacingMicroTriangleNV = 5406,
+    HitSphereRadiusNV = 5420,
+    HitLSSRadiiNV = 5421,
+    ClusterIDNV = 5436,
+    CullMaskKHR = 6021,
+    Max = 0x7fffffff,
+};
+
+enum class SelectionControlShift : unsigned {
+    Flatten = 0,
+    DontFlatten = 1,
+    Max = 0x7fffffff,
+};
+
+enum class SelectionControlMask : unsigned {
+    MaskNone = 0,
+    Flatten = 0x00000001,
+    DontFlatten = 0x00000002,
+};
+
+enum class LoopControlShift : unsigned {
+    Unroll = 0,
+    DontUnroll = 1,
+    DependencyInfinite = 2,
+    DependencyLength = 3,
+    MinIterations = 4,
+    MaxIterations = 5,
+    IterationMultiple = 6,
+    PeelCount = 7,
+    PartialCount = 8,
+    InitiationIntervalINTEL = 16,
+    MaxConcurrencyINTEL = 17,
+    DependencyArrayINTEL = 18,
+    PipelineEnableINTEL = 19,
+    LoopCoalesceINTEL = 20,
+    MaxInterleavingINTEL = 21,
+    SpeculatedIterationsINTEL = 22,
+    NoFusionINTEL = 23,
+    LoopCountINTEL = 24,
+    MaxReinvocationDelayINTEL = 25,
+    Max = 0x7fffffff,
+};
+
+enum class LoopControlMask : unsigned {
+    MaskNone = 0,
+    Unroll = 0x00000001,
+    DontUnroll = 0x00000002,
+    DependencyInfinite = 0x00000004,
+    DependencyLength = 0x00000008,
+    MinIterations = 0x00000010,
+    MaxIterations = 0x00000020,
+    IterationMultiple = 0x00000040,
+    PeelCount = 0x00000080,
+    PartialCount = 0x00000100,
+    InitiationIntervalINTEL = 0x00010000,
+    MaxConcurrencyINTEL = 0x00020000,
+    DependencyArrayINTEL = 0x00040000,
+    PipelineEnableINTEL = 0x00080000,
+    LoopCoalesceINTEL = 0x00100000,
+    MaxInterleavingINTEL = 0x00200000,
+    SpeculatedIterationsINTEL = 0x00400000,
+    NoFusionINTEL = 0x00800000,
+    LoopCountINTEL = 0x01000000,
+    MaxReinvocationDelayINTEL = 0x02000000,
+};
+
+enum class FunctionControlShift : unsigned {
+    Inline = 0,
+    DontInline = 1,
+    Pure = 2,
+    Const = 3,
+    OptNoneEXT = 16,
+    OptNoneINTEL = 16,
+    Max = 0x7fffffff,
+};
+
+enum class FunctionControlMask : unsigned {
+    MaskNone = 0,
+    Inline = 0x00000001,
+    DontInline = 0x00000002,
+    Pure = 0x00000004,
+    Const = 0x00000008,
+    OptNoneEXT = 0x00010000,
+    OptNoneINTEL = 0x00010000,
+};
+
+enum class MemorySemanticsShift : unsigned {
+    Acquire = 1,
+    Release = 2,
+    AcquireRelease = 3,
+    SequentiallyConsistent = 4,
+    UniformMemory = 6,
+    SubgroupMemory = 7,
+    WorkgroupMemory = 8,
+    CrossWorkgroupMemory = 9,
+    AtomicCounterMemory = 10,
+    ImageMemory = 11,
+    OutputMemory = 12,
+    OutputMemoryKHR = 12,
+    MakeAvailable = 13,
+    MakeAvailableKHR = 13,
+    MakeVisible = 14,
+    MakeVisibleKHR = 14,
+    Volatile = 15,
+    Max = 0x7fffffff,
+};
+
+enum class MemorySemanticsMask : unsigned {
+    MaskNone = 0,
+    Acquire = 0x00000002,
+    Release = 0x00000004,
+    AcquireRelease = 0x00000008,
+    SequentiallyConsistent = 0x00000010,
+    UniformMemory = 0x00000040,
+    SubgroupMemory = 0x00000080,
+    WorkgroupMemory = 0x00000100,
+    CrossWorkgroupMemory = 0x00000200,
+    AtomicCounterMemory = 0x00000400,
+    ImageMemory = 0x00000800,
+    OutputMemory = 0x00001000,
+    OutputMemoryKHR = 0x00001000,
+    MakeAvailable = 0x00002000,
+    MakeAvailableKHR = 0x00002000,
+    MakeVisible = 0x00004000,
+    MakeVisibleKHR = 0x00004000,
+    Volatile = 0x00008000,
+};
+
+enum class MemoryAccessShift : unsigned {
+    Volatile = 0,
+    Aligned = 1,
+    Nontemporal = 2,
+    MakePointerAvailable = 3,
+    MakePointerAvailableKHR = 3,
+    MakePointerVisible = 4,
+    MakePointerVisibleKHR = 4,
+    NonPrivatePointer = 5,
+    NonPrivatePointerKHR = 5,
+    AliasScopeINTELMask = 16,
+    NoAliasINTELMask = 17,
+    Max = 0x7fffffff,
+};
+
+enum class MemoryAccessMask : unsigned {
+    MaskNone = 0,
+    Volatile = 0x00000001,
+    Aligned = 0x00000002,
+    Nontemporal = 0x00000004,
+    MakePointerAvailable = 0x00000008,
+    MakePointerAvailableKHR = 0x00000008,
+    MakePointerVisible = 0x00000010,
+    MakePointerVisibleKHR = 0x00000010,
+    NonPrivatePointer = 0x00000020,
+    NonPrivatePointerKHR = 0x00000020,
+    AliasScopeINTELMask = 0x00010000,
+    NoAliasINTELMask = 0x00020000,
+};
+
+enum class Scope : unsigned {
+    CrossDevice = 0,
+    Device = 1,
+    Workgroup = 2,
+    Subgroup = 3,
+    Invocation = 4,
+    QueueFamily = 5,
+    QueueFamilyKHR = 5,
+    ShaderCallKHR = 6,
+    Max = 0x7fffffff,
+};
+
+enum class GroupOperation : unsigned {
+    Reduce = 0,
+    InclusiveScan = 1,
+    ExclusiveScan = 2,
+    ClusteredReduce = 3,
+    PartitionedReduceNV = 6,
+    PartitionedInclusiveScanNV = 7,
+    PartitionedExclusiveScanNV = 8,
+    Max = 0x7fffffff,
+};
+
+enum class KernelEnqueueFlags : unsigned {
+    NoWait = 0,
+    WaitKernel = 1,
+    WaitWorkGroup = 2,
+    Max = 0x7fffffff,
+};
+
+enum class KernelProfilingInfoShift : unsigned {
+    CmdExecTime = 0,
+    Max = 0x7fffffff,
+};
+
+enum class KernelProfilingInfoMask : unsigned {
+    MaskNone = 0,
+    CmdExecTime = 0x00000001,
+};
+
+enum class Capability : unsigned {
+    Matrix = 0,
+    Shader = 1,
+    Geometry = 2,
+    Tessellation = 3,
+    Addresses = 4,
+    Linkage = 5,
+    Kernel = 6,
+    Vector16 = 7,
+    Float16Buffer = 8,
+    Float16 = 9,
+    Float64 = 10,
+    Int64 = 11,
+    Int64Atomics = 12,
+    ImageBasic = 13,
+    ImageReadWrite = 14,
+    ImageMipmap = 15,
+    Pipes = 17,
+    Groups = 18,
+    DeviceEnqueue = 19,
+    LiteralSampler = 20,
+    AtomicStorage = 21,
+    Int16 = 22,
+    TessellationPointSize = 23,
+    GeometryPointSize = 24,
+    ImageGatherExtended = 25,
+    StorageImageMultisample = 27,
+    UniformBufferArrayDynamicIndexing = 28,
+    SampledImageArrayDynamicIndexing = 29,
+    StorageBufferArrayDynamicIndexing = 30,
+    StorageImageArrayDynamicIndexing = 31,
+    ClipDistance = 32,
+    CullDistance = 33,
+    ImageCubeArray = 34,
+    SampleRateShading = 35,
+    ImageRect = 36,
+    SampledRect = 37,
+    GenericPointer = 38,
+    Int8 = 39,
+    InputAttachment = 40,
+    SparseResidency = 41,
+    MinLod = 42,
+    Sampled1D = 43,
+    Image1D = 44,
+    SampledCubeArray = 45,
+    SampledBuffer = 46,
+    ImageBuffer = 47,
+    ImageMSArray = 48,
+    StorageImageExtendedFormats = 49,
+    ImageQuery = 50,
+    DerivativeControl = 51,
+    InterpolationFunction = 52,
+    TransformFeedback = 53,
+    GeometryStreams = 54,
+    StorageImageReadWithoutFormat = 55,
+    StorageImageWriteWithoutFormat = 56,
+    MultiViewport = 57,
+    SubgroupDispatch = 58,
+    NamedBarrier = 59,
+    PipeStorage = 60,
+    GroupNonUniform = 61,
+    GroupNonUniformVote = 62,
+    GroupNonUniformArithmetic = 63,
+    GroupNonUniformBallot = 64,
+    GroupNonUniformShuffle = 65,
+    GroupNonUniformShuffleRelative = 66,
+    GroupNonUniformClustered = 67,
+    GroupNonUniformQuad = 68,
+    ShaderLayer = 69,
+    ShaderViewportIndex = 70,
+    UniformDecoration = 71,
+    CoreBuiltinsARM = 4165,
+    TileImageColorReadAccessEXT = 4166,
+    TileImageDepthReadAccessEXT = 4167,
+    TileImageStencilReadAccessEXT = 4168,
+    CooperativeMatrixLayoutsARM = 4201,
+    FragmentShadingRateKHR = 4422,
+    SubgroupBallotKHR = 4423,
+    DrawParameters = 4427,
+    WorkgroupMemoryExplicitLayoutKHR = 4428,
+    WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
+    WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
+    SubgroupVoteKHR = 4431,
+    StorageBuffer16BitAccess = 4433,
+    StorageUniformBufferBlock16 = 4433,
+    StorageUniform16 = 4434,
+    UniformAndStorageBuffer16BitAccess = 4434,
+    StoragePushConstant16 = 4435,
+    StorageInputOutput16 = 4436,
+    DeviceGroup = 4437,
+    MultiView = 4439,
+    VariablePointersStorageBuffer = 4441,
+    VariablePointers = 4442,
+    AtomicStorageOps = 4445,
+    SampleMaskPostDepthCoverage = 4447,
+    StorageBuffer8BitAccess = 4448,
+    UniformAndStorageBuffer8BitAccess = 4449,
+    StoragePushConstant8 = 4450,
+    DenormPreserve = 4464,
+    DenormFlushToZero = 4465,
+    SignedZeroInfNanPreserve = 4466,
+    RoundingModeRTE = 4467,
+    RoundingModeRTZ = 4468,
+    RayQueryProvisionalKHR = 4471,
+    RayQueryKHR = 4472,
+    UntypedPointersKHR = 4473,
+    RayTraversalPrimitiveCullingKHR = 4478,
+    RayTracingKHR = 4479,
+    TextureSampleWeightedQCOM = 4484,
+    TextureBoxFilterQCOM = 4485,
+    TextureBlockMatchQCOM = 4486,
+    TextureBlockMatch2QCOM = 4498,
+    Float16ImageAMD = 5008,
+    ImageGatherBiasLodAMD = 5009,
+    FragmentMaskAMD = 5010,
+    StencilExportEXT = 5013,
+    ImageReadWriteLodAMD = 5015,
+    Int64ImageEXT = 5016,
+    ShaderClockKHR = 5055,
+    ShaderEnqueueAMDX = 5067,
+    QuadControlKHR = 5087,
+    BFloat16TypeKHR = 5116,
+    BFloat16DotProductKHR = 5117,
+    BFloat16CooperativeMatrixKHR = 5118,
+    SampleMaskOverrideCoverageNV = 5249,
+    GeometryShaderPassthroughNV = 5251,
+    ShaderViewportIndexLayerEXT = 5254,
+    ShaderViewportIndexLayerNV = 5254,
+    ShaderViewportMaskNV = 5255,
+    ShaderStereoViewNV = 5259,
+    PerViewAttributesNV = 5260,
+    FragmentFullyCoveredEXT = 5265,
+    MeshShadingNV = 5266,
+    ImageFootprintNV = 5282,
+    MeshShadingEXT = 5283,
+    FragmentBarycentricKHR = 5284,
+    FragmentBarycentricNV = 5284,
+    ComputeDerivativeGroupQuadsKHR = 5288,
+    ComputeDerivativeGroupQuadsNV = 5288,
+    FragmentDensityEXT = 5291,
+    ShadingRateNV = 5291,
+    GroupNonUniformPartitionedNV = 5297,
+    ShaderNonUniform = 5301,
+    ShaderNonUniformEXT = 5301,
+    RuntimeDescriptorArray = 5302,
+    RuntimeDescriptorArrayEXT = 5302,
+    InputAttachmentArrayDynamicIndexing = 5303,
+    InputAttachmentArrayDynamicIndexingEXT = 5303,
+    UniformTexelBufferArrayDynamicIndexing = 5304,
+    UniformTexelBufferArrayDynamicIndexingEXT = 5304,
+    StorageTexelBufferArrayDynamicIndexing = 5305,
+    StorageTexelBufferArrayDynamicIndexingEXT = 5305,
+    UniformBufferArrayNonUniformIndexing = 5306,
+    UniformBufferArrayNonUniformIndexingEXT = 5306,
+    SampledImageArrayNonUniformIndexing = 5307,
+    SampledImageArrayNonUniformIndexingEXT = 5307,
+    StorageBufferArrayNonUniformIndexing = 5308,
+    StorageBufferArrayNonUniformIndexingEXT = 5308,
+    StorageImageArrayNonUniformIndexing = 5309,
+    StorageImageArrayNonUniformIndexingEXT = 5309,
+    InputAttachmentArrayNonUniformIndexing = 5310,
+    InputAttachmentArrayNonUniformIndexingEXT = 5310,
+    UniformTexelBufferArrayNonUniformIndexing = 5311,
+    UniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+    StorageTexelBufferArrayNonUniformIndexing = 5312,
+    StorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+    RayTracingPositionFetchKHR = 5336,
+    RayTracingNV = 5340,
+    RayTracingMotionBlurNV = 5341,
+    VulkanMemoryModel = 5345,
+    VulkanMemoryModelKHR = 5345,
+    VulkanMemoryModelDeviceScope = 5346,
+    VulkanMemoryModelDeviceScopeKHR = 5346,
+    PhysicalStorageBufferAddresses = 5347,
+    PhysicalStorageBufferAddressesEXT = 5347,
+    ComputeDerivativeGroupLinearKHR = 5350,
+    ComputeDerivativeGroupLinearNV = 5350,
+    RayTracingProvisionalKHR = 5353,
+    CooperativeMatrixNV = 5357,
+    FragmentShaderSampleInterlockEXT = 5363,
+    FragmentShaderShadingRateInterlockEXT = 5372,
+    ShaderSMBuiltinsNV = 5373,
+    FragmentShaderPixelInterlockEXT = 5378,
+    DemoteToHelperInvocation = 5379,
+    DemoteToHelperInvocationEXT = 5379,
+    DisplacementMicromapNV = 5380,
+    RayTracingOpacityMicromapEXT = 5381,
+    ShaderInvocationReorderNV = 5383,
+    BindlessTextureNV = 5390,
+    RayQueryPositionFetchKHR = 5391,
+    CooperativeVectorNV = 5394,
+    AtomicFloat16VectorNV = 5404,
+    RayTracingDisplacementMicromapNV = 5409,
+    RawAccessChainsNV = 5414,
+    RayTracingSpheresGeometryNV = 5418,
+    RayTracingLinearSweptSpheresGeometryNV = 5419,
+    CooperativeMatrixReductionsNV = 5430,
+    CooperativeMatrixConversionsNV = 5431,
+    CooperativeMatrixPerElementOperationsNV = 5432,
+    CooperativeMatrixTensorAddressingNV = 5433,
+    CooperativeMatrixBlockLoadsNV = 5434,
+    CooperativeVectorTrainingNV = 5435,
+    RayTracingClusterAccelerationStructureNV = 5437,
+    TensorAddressingNV = 5439,
+    SubgroupShuffleINTEL = 5568,
+    SubgroupBufferBlockIOINTEL = 5569,
+    SubgroupImageBlockIOINTEL = 5570,
+    SubgroupImageMediaBlockIOINTEL = 5579,
+    RoundToInfinityINTEL = 5582,
+    FloatingPointModeINTEL = 5583,
+    IntegerFunctions2INTEL = 5584,
+    FunctionPointersINTEL = 5603,
+    IndirectReferencesINTEL = 5604,
+    AsmINTEL = 5606,
+    AtomicFloat32MinMaxEXT = 5612,
+    AtomicFloat64MinMaxEXT = 5613,
+    AtomicFloat16MinMaxEXT = 5616,
+    VectorComputeINTEL = 5617,
+    VectorAnyINTEL = 5619,
+    ExpectAssumeKHR = 5629,
+    SubgroupAvcMotionEstimationINTEL = 5696,
+    SubgroupAvcMotionEstimationIntraINTEL = 5697,
+    SubgroupAvcMotionEstimationChromaINTEL = 5698,
+    VariableLengthArrayINTEL = 5817,
+    FunctionFloatControlINTEL = 5821,
+    FPGAMemoryAttributesINTEL = 5824,
+    FPFastMathModeINTEL = 5837,
+    ArbitraryPrecisionIntegersINTEL = 5844,
+    ArbitraryPrecisionFloatingPointINTEL = 5845,
+    UnstructuredLoopControlsINTEL = 5886,
+    FPGALoopControlsINTEL = 5888,
+    KernelAttributesINTEL = 5892,
+    FPGAKernelAttributesINTEL = 5897,
+    FPGAMemoryAccessesINTEL = 5898,
+    FPGAClusterAttributesINTEL = 5904,
+    LoopFuseINTEL = 5906,
+    FPGADSPControlINTEL = 5908,
+    MemoryAccessAliasingINTEL = 5910,
+    FPGAInvocationPipeliningAttributesINTEL = 5916,
+    FPGABufferLocationINTEL = 5920,
+    ArbitraryPrecisionFixedPointINTEL = 5922,
+    USMStorageClassesINTEL = 5935,
+    RuntimeAlignedAttributeINTEL = 5939,
+    IOPipesINTEL = 5943,
+    BlockingPipesINTEL = 5945,
+    FPGARegINTEL = 5948,
+    DotProductInputAll = 6016,
+    DotProductInputAllKHR = 6016,
+    DotProductInput4x8Bit = 6017,
+    DotProductInput4x8BitKHR = 6017,
+    DotProductInput4x8BitPacked = 6018,
+    DotProductInput4x8BitPackedKHR = 6018,
+    DotProduct = 6019,
+    DotProductKHR = 6019,
+    RayCullMaskKHR = 6020,
+    CooperativeMatrixKHR = 6022,
+    ReplicatedCompositesEXT = 6024,
+    BitInstructions = 6025,
+    GroupNonUniformRotateKHR = 6026,
+    FloatControls2 = 6029,
+    AtomicFloat32AddEXT = 6033,
+    AtomicFloat64AddEXT = 6034,
+    LongCompositesINTEL = 6089,
+    OptNoneEXT = 6094,
+    OptNoneINTEL = 6094,
+    AtomicFloat16AddEXT = 6095,
+    DebugInfoModuleINTEL = 6114,
+    BFloat16ConversionINTEL = 6115,
+    SplitBarrierINTEL = 6141,
+    ArithmeticFenceEXT = 6144,
+    FPGAClusterAttributesV2INTEL = 6150,
+    FPGAKernelAttributesv2INTEL = 6161,
+    FPMaxErrorINTEL = 6169,
+    FPGALatencyControlINTEL = 6171,
+    FPGAArgumentInterfacesINTEL = 6174,
+    GlobalVariableHostAccessINTEL = 6187,
+    GlobalVariableFPGADecorationsINTEL = 6189,
+    SubgroupBufferPrefetchINTEL = 6220,
+    Subgroup2DBlockIOINTEL = 6228,
+    Subgroup2DBlockTransformINTEL = 6229,
+    Subgroup2DBlockTransposeINTEL = 6230,
+    SubgroupMatrixMultiplyAccumulateINTEL = 6236,
+    GroupUniformArithmeticKHR = 6400,
+    MaskedGatherScatterINTEL = 6427,
+    CacheControlsINTEL = 6441,
+    RegisterLimitsINTEL = 6460,
+    Max = 0x7fffffff,
+};
+
+enum class RayFlagsShift : unsigned {
+    OpaqueKHR = 0,
+    NoOpaqueKHR = 1,
+    TerminateOnFirstHitKHR = 2,
+    SkipClosestHitShaderKHR = 3,
+    CullBackFacingTrianglesKHR = 4,
+    CullFrontFacingTrianglesKHR = 5,
+    CullOpaqueKHR = 6,
+    CullNoOpaqueKHR = 7,
+    SkipBuiltinPrimitivesNV = 8,
+    SkipTrianglesKHR = 8,
+    SkipAABBsKHR = 9,
+    ForceOpacityMicromap2StateEXT = 10,
+    Max = 0x7fffffff,
+};
+
+enum class RayFlagsMask : unsigned {
+    MaskNone = 0,
+    OpaqueKHR = 0x00000001,
+    NoOpaqueKHR = 0x00000002,
+    TerminateOnFirstHitKHR = 0x00000004,
+    SkipClosestHitShaderKHR = 0x00000008,
+    CullBackFacingTrianglesKHR = 0x00000010,
+    CullFrontFacingTrianglesKHR = 0x00000020,
+    CullOpaqueKHR = 0x00000040,
+    CullNoOpaqueKHR = 0x00000080,
+    SkipBuiltinPrimitivesNV = 0x00000100,
+    SkipTrianglesKHR = 0x00000100,
+    SkipAABBsKHR = 0x00000200,
+    ForceOpacityMicromap2StateEXT = 0x00000400,
+};
+
+enum class RayQueryIntersection : unsigned {
+    RayQueryCandidateIntersectionKHR = 0,
+    RayQueryCommittedIntersectionKHR = 1,
+    Max = 0x7fffffff,
+};
+
+enum class RayQueryCommittedIntersectionType : unsigned {
+    RayQueryCommittedIntersectionNoneKHR = 0,
+    RayQueryCommittedIntersectionTriangleKHR = 1,
+    RayQueryCommittedIntersectionGeneratedKHR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class RayQueryCandidateIntersectionType : unsigned {
+    RayQueryCandidateIntersectionTriangleKHR = 0,
+    RayQueryCandidateIntersectionAABBKHR = 1,
+    Max = 0x7fffffff,
+};
+
+enum class FragmentShadingRateShift : unsigned {
+    Vertical2Pixels = 0,
+    Vertical4Pixels = 1,
+    Horizontal2Pixels = 2,
+    Horizontal4Pixels = 3,
+    Max = 0x7fffffff,
+};
+
+enum class FragmentShadingRateMask : unsigned {
+    MaskNone = 0,
+    Vertical2Pixels = 0x00000001,
+    Vertical4Pixels = 0x00000002,
+    Horizontal2Pixels = 0x00000004,
+    Horizontal4Pixels = 0x00000008,
+};
+
+enum class FPDenormMode : unsigned {
+    Preserve = 0,
+    FlushToZero = 1,
+    Max = 0x7fffffff,
+};
+
+enum class FPOperationMode : unsigned {
+    IEEE = 0,
+    ALT = 1,
+    Max = 0x7fffffff,
+};
+
+enum class QuantizationModes : unsigned {
+    TRN = 0,
+    TRN_ZERO = 1,
+    RND = 2,
+    RND_ZERO = 3,
+    RND_INF = 4,
+    RND_MIN_INF = 5,
+    RND_CONV = 6,
+    RND_CONV_ODD = 7,
+    Max = 0x7fffffff,
+};
+
+enum class OverflowModes : unsigned {
+    WRAP = 0,
+    SAT = 1,
+    SAT_ZERO = 2,
+    SAT_SYM = 3,
+    Max = 0x7fffffff,
+};
+
+enum class PackedVectorFormat : unsigned {
+    PackedVectorFormat4x8Bit = 0,
+    PackedVectorFormat4x8BitKHR = 0,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixOperandsShift : unsigned {
+    MatrixASignedComponentsKHR = 0,
+    MatrixBSignedComponentsKHR = 1,
+    MatrixCSignedComponentsKHR = 2,
+    MatrixResultSignedComponentsKHR = 3,
+    SaturatingAccumulationKHR = 4,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixOperandsMask : unsigned {
+    MaskNone = 0,
+    MatrixASignedComponentsKHR = 0x00000001,
+    MatrixBSignedComponentsKHR = 0x00000002,
+    MatrixCSignedComponentsKHR = 0x00000004,
+    MatrixResultSignedComponentsKHR = 0x00000008,
+    SaturatingAccumulationKHR = 0x00000010,
+};
+
+enum class CooperativeMatrixLayout : unsigned {
+    RowMajorKHR = 0,
+    ColumnMajorKHR = 1,
+    RowBlockedInterleavedARM = 4202,
+    ColumnBlockedInterleavedARM = 4203,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixUse : unsigned {
+    MatrixAKHR = 0,
+    MatrixBKHR = 1,
+    MatrixAccumulatorKHR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixReduceShift : unsigned {
+    Row = 0,
+    Column = 1,
+    CooperativeMatrixReduce2x2 = 2,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixReduceMask : unsigned {
+    MaskNone = 0,
+    Row = 0x00000001,
+    Column = 0x00000002,
+    CooperativeMatrixReduce2x2 = 0x00000004,
+};
+
+enum class TensorClampMode : unsigned {
+    Undefined = 0,
+    Constant = 1,
+    ClampToEdge = 2,
+    Repeat = 3,
+    RepeatMirrored = 4,
+    Max = 0x7fffffff,
+};
+
+enum class TensorAddressingOperandsShift : unsigned {
+    TensorView = 0,
+    DecodeFunc = 1,
+    Max = 0x7fffffff,
+};
+
+enum class TensorAddressingOperandsMask : unsigned {
+    MaskNone = 0,
+    TensorView = 0x00000001,
+    DecodeFunc = 0x00000002,
+};
+
+enum class InitializationModeQualifier : unsigned {
+    InitOnDeviceReprogramINTEL = 0,
+    InitOnDeviceResetINTEL = 1,
+    Max = 0x7fffffff,
+};
+
+enum class HostAccessQualifier : unsigned {
+    NoneINTEL = 0,
+    ReadINTEL = 1,
+    WriteINTEL = 2,
+    ReadWriteINTEL = 3,
+    Max = 0x7fffffff,
+};
+
+enum class LoadCacheControl : unsigned {
+    UncachedINTEL = 0,
+    CachedINTEL = 1,
+    StreamingINTEL = 2,
+    InvalidateAfterReadINTEL = 3,
+    ConstCachedINTEL = 4,
+    Max = 0x7fffffff,
+};
+
+enum class StoreCacheControl : unsigned {
+    UncachedINTEL = 0,
+    WriteThroughINTEL = 1,
+    WriteBackINTEL = 2,
+    StreamingINTEL = 3,
+    Max = 0x7fffffff,
+};
+
+enum class NamedMaximumNumberOfRegisters : unsigned {
+    AutoINTEL = 0,
+    Max = 0x7fffffff,
+};
+
+enum class MatrixMultiplyAccumulateOperandsShift : unsigned {
+    MatrixASignedComponentsINTEL = 0,
+    MatrixBSignedComponentsINTEL = 1,
+    MatrixCBFloat16INTEL = 2,
+    MatrixResultBFloat16INTEL = 3,
+    MatrixAPackedInt8INTEL = 4,
+    MatrixBPackedInt8INTEL = 5,
+    MatrixAPackedInt4INTEL = 6,
+    MatrixBPackedInt4INTEL = 7,
+    MatrixATF32INTEL = 8,
+    MatrixBTF32INTEL = 9,
+    MatrixAPackedFloat16INTEL = 10,
+    MatrixBPackedFloat16INTEL = 11,
+    MatrixAPackedBFloat16INTEL = 12,
+    MatrixBPackedBFloat16INTEL = 13,
+    Max = 0x7fffffff,
+};
+
+enum class MatrixMultiplyAccumulateOperandsMask : unsigned {
+    MaskNone = 0,
+    MatrixASignedComponentsINTEL = 0x00000001,
+    MatrixBSignedComponentsINTEL = 0x00000002,
+    MatrixCBFloat16INTEL = 0x00000004,
+    MatrixResultBFloat16INTEL = 0x00000008,
+    MatrixAPackedInt8INTEL = 0x00000010,
+    MatrixBPackedInt8INTEL = 0x00000020,
+    MatrixAPackedInt4INTEL = 0x00000040,
+    MatrixBPackedInt4INTEL = 0x00000080,
+    MatrixATF32INTEL = 0x00000100,
+    MatrixBTF32INTEL = 0x00000200,
+    MatrixAPackedFloat16INTEL = 0x00000400,
+    MatrixBPackedFloat16INTEL = 0x00000800,
+    MatrixAPackedBFloat16INTEL = 0x00001000,
+    MatrixBPackedBFloat16INTEL = 0x00002000,
+};
+
+enum class RawAccessChainOperandsShift : unsigned {
+    RobustnessPerComponentNV = 0,
+    RobustnessPerElementNV = 1,
+    Max = 0x7fffffff,
+};
+
+enum class RawAccessChainOperandsMask : unsigned {
+    MaskNone = 0,
+    RobustnessPerComponentNV = 0x00000001,
+    RobustnessPerElementNV = 0x00000002,
+};
+
+enum class FPEncoding : unsigned {
+    BFloat16KHR = 0,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeVectorMatrixLayout : unsigned {
+    RowMajorNV = 0,
+    ColumnMajorNV = 1,
+    InferencingOptimalNV = 2,
+    TrainingOptimalNV = 3,
+    Max = 0x7fffffff,
+};
+
+enum class ComponentType : unsigned {
+    Float16NV = 0,
+    Float32NV = 1,
+    Float64NV = 2,
+    SignedInt8NV = 3,
+    SignedInt16NV = 4,
+    SignedInt32NV = 5,
+    SignedInt64NV = 6,
+    UnsignedInt8NV = 7,
+    UnsignedInt16NV = 8,
+    UnsignedInt32NV = 9,
+    UnsignedInt64NV = 10,
+    SignedInt8PackedNV = 1000491000,
+    UnsignedInt8PackedNV = 1000491001,
+    FloatE4M3NV = 1000491002,
+    FloatE5M2NV = 1000491003,
+    Max = 0x7fffffff,
+};
+
+enum class Op : unsigned {
+    OpNop = 0,
+    OpUndef = 1,
+    OpSourceContinued = 2,
+    OpSource = 3,
+    OpSourceExtension = 4,
+    OpName = 5,
+    OpMemberName = 6,
+    OpString = 7,
+    OpLine = 8,
+    OpExtension = 10,
+    OpExtInstImport = 11,
+    OpExtInst = 12,
+    OpMemoryModel = 14,
+    OpEntryPoint = 15,
+    OpExecutionMode = 16,
+    OpCapability = 17,
+    OpTypeVoid = 19,
+    OpTypeBool = 20,
+    OpTypeInt = 21,
+    OpTypeFloat = 22,
+    OpTypeVector = 23,
+    OpTypeMatrix = 24,
+    OpTypeImage = 25,
+    OpTypeSampler = 26,
+    OpTypeSampledImage = 27,
+    OpTypeArray = 28,
+    OpTypeRuntimeArray = 29,
+    OpTypeStruct = 30,
+    OpTypeOpaque = 31,
+    OpTypePointer = 32,
+    OpTypeFunction = 33,
+    OpTypeEvent = 34,
+    OpTypeDeviceEvent = 35,
+    OpTypeReserveId = 36,
+    OpTypeQueue = 37,
+    OpTypePipe = 38,
+    OpTypeForwardPointer = 39,
+    OpConstantTrue = 41,
+    OpConstantFalse = 42,
+    OpConstant = 43,
+    OpConstantComposite = 44,
+    OpConstantSampler = 45,
+    OpConstantNull = 46,
+    OpSpecConstantTrue = 48,
+    OpSpecConstantFalse = 49,
+    OpSpecConstant = 50,
+    OpSpecConstantComposite = 51,
+    OpSpecConstantOp = 52,
+    OpFunction = 54,
+    OpFunctionParameter = 55,
+    OpFunctionEnd = 56,
+    OpFunctionCall = 57,
+    OpVariable = 59,
+    OpImageTexelPointer = 60,
+    OpLoad = 61,
+    OpStore = 62,
+    OpCopyMemory = 63,
+    OpCopyMemorySized = 64,
+    OpAccessChain = 65,
+    OpInBoundsAccessChain = 66,
+    OpPtrAccessChain = 67,
+    OpArrayLength = 68,
+    OpGenericPtrMemSemantics = 69,
+    OpInBoundsPtrAccessChain = 70,
+    OpDecorate = 71,
+    OpMemberDecorate = 72,
+    OpDecorationGroup = 73,
+    OpGroupDecorate = 74,
+    OpGroupMemberDecorate = 75,
+    OpVectorExtractDynamic = 77,
+    OpVectorInsertDynamic = 78,
+    OpVectorShuffle = 79,
+    OpCompositeConstruct = 80,
+    OpCompositeExtract = 81,
+    OpCompositeInsert = 82,
+    OpCopyObject = 83,
+    OpTranspose = 84,
+    OpSampledImage = 86,
+    OpImageSampleImplicitLod = 87,
+    OpImageSampleExplicitLod = 88,
+    OpImageSampleDrefImplicitLod = 89,
+    OpImageSampleDrefExplicitLod = 90,
+    OpImageSampleProjImplicitLod = 91,
+    OpImageSampleProjExplicitLod = 92,
+    OpImageSampleProjDrefImplicitLod = 93,
+    OpImageSampleProjDrefExplicitLod = 94,
+    OpImageFetch = 95,
+    OpImageGather = 96,
+    OpImageDrefGather = 97,
+    OpImageRead = 98,
+    OpImageWrite = 99,
+    OpImage = 100,
+    OpImageQueryFormat = 101,
+    OpImageQueryOrder = 102,
+    OpImageQuerySizeLod = 103,
+    OpImageQuerySize = 104,
+    OpImageQueryLod = 105,
+    OpImageQueryLevels = 106,
+    OpImageQuerySamples = 107,
+    OpConvertFToU = 109,
+    OpConvertFToS = 110,
+    OpConvertSToF = 111,
+    OpConvertUToF = 112,
+    OpUConvert = 113,
+    OpSConvert = 114,
+    OpFConvert = 115,
+    OpQuantizeToF16 = 116,
+    OpConvertPtrToU = 117,
+    OpSatConvertSToU = 118,
+    OpSatConvertUToS = 119,
+    OpConvertUToPtr = 120,
+    OpPtrCastToGeneric = 121,
+    OpGenericCastToPtr = 122,
+    OpGenericCastToPtrExplicit = 123,
+    OpBitcast = 124,
+    OpSNegate = 126,
+    OpFNegate = 127,
+    OpIAdd = 128,
+    OpFAdd = 129,
+    OpISub = 130,
+    OpFSub = 131,
+    OpIMul = 132,
+    OpFMul = 133,
+    OpUDiv = 134,
+    OpSDiv = 135,
+    OpFDiv = 136,
+    OpUMod = 137,
+    OpSRem = 138,
+    OpSMod = 139,
+    OpFRem = 140,
+    OpFMod = 141,
+    OpVectorTimesScalar = 142,
+    OpMatrixTimesScalar = 143,
+    OpVectorTimesMatrix = 144,
+    OpMatrixTimesVector = 145,
+    OpMatrixTimesMatrix = 146,
+    OpOuterProduct = 147,
+    OpDot = 148,
+    OpIAddCarry = 149,
+    OpISubBorrow = 150,
+    OpUMulExtended = 151,
+    OpSMulExtended = 152,
+    OpAny = 154,
+    OpAll = 155,
+    OpIsNan = 156,
+    OpIsInf = 157,
+    OpIsFinite = 158,
+    OpIsNormal = 159,
+    OpSignBitSet = 160,
+    OpLessOrGreater = 161,
+    OpOrdered = 162,
+    OpUnordered = 163,
+    OpLogicalEqual = 164,
+    OpLogicalNotEqual = 165,
+    OpLogicalOr = 166,
+    OpLogicalAnd = 167,
+    OpLogicalNot = 168,
+    OpSelect = 169,
+    OpIEqual = 170,
+    OpINotEqual = 171,
+    OpUGreaterThan = 172,
+    OpSGreaterThan = 173,
+    OpUGreaterThanEqual = 174,
+    OpSGreaterThanEqual = 175,
+    OpULessThan = 176,
+    OpSLessThan = 177,
+    OpULessThanEqual = 178,
+    OpSLessThanEqual = 179,
+    OpFOrdEqual = 180,
+    OpFUnordEqual = 181,
+    OpFOrdNotEqual = 182,
+    OpFUnordNotEqual = 183,
+    OpFOrdLessThan = 184,
+    OpFUnordLessThan = 185,
+    OpFOrdGreaterThan = 186,
+    OpFUnordGreaterThan = 187,
+    OpFOrdLessThanEqual = 188,
+    OpFUnordLessThanEqual = 189,
+    OpFOrdGreaterThanEqual = 190,
+    OpFUnordGreaterThanEqual = 191,
+    OpShiftRightLogical = 194,
+    OpShiftRightArithmetic = 195,
+    OpShiftLeftLogical = 196,
+    OpBitwiseOr = 197,
+    OpBitwiseXor = 198,
+    OpBitwiseAnd = 199,
+    OpNot = 200,
+    OpBitFieldInsert = 201,
+    OpBitFieldSExtract = 202,
+    OpBitFieldUExtract = 203,
+    OpBitReverse = 204,
+    OpBitCount = 205,
+    OpDPdx = 207,
+    OpDPdy = 208,
+    OpFwidth = 209,
+    OpDPdxFine = 210,
+    OpDPdyFine = 211,
+    OpFwidthFine = 212,
+    OpDPdxCoarse = 213,
+    OpDPdyCoarse = 214,
+    OpFwidthCoarse = 215,
+    OpEmitVertex = 218,
+    OpEndPrimitive = 219,
+    OpEmitStreamVertex = 220,
+    OpEndStreamPrimitive = 221,
+    OpControlBarrier = 224,
+    OpMemoryBarrier = 225,
+    OpAtomicLoad = 227,
+    OpAtomicStore = 228,
+    OpAtomicExchange = 229,
+    OpAtomicCompareExchange = 230,
+    OpAtomicCompareExchangeWeak = 231,
+    OpAtomicIIncrement = 232,
+    OpAtomicIDecrement = 233,
+    OpAtomicIAdd = 234,
+    OpAtomicISub = 235,
+    OpAtomicSMin = 236,
+    OpAtomicUMin = 237,
+    OpAtomicSMax = 238,
+    OpAtomicUMax = 239,
+    OpAtomicAnd = 240,
+    OpAtomicOr = 241,
+    OpAtomicXor = 242,
+    OpPhi = 245,
+    OpLoopMerge = 246,
+    OpSelectionMerge = 247,
+    OpLabel = 248,
+    OpBranch = 249,
+    OpBranchConditional = 250,
+    OpSwitch = 251,
+    OpKill = 252,
+    OpReturn = 253,
+    OpReturnValue = 254,
+    OpUnreachable = 255,
+    OpLifetimeStart = 256,
+    OpLifetimeStop = 257,
+    OpGroupAsyncCopy = 259,
+    OpGroupWaitEvents = 260,
+    OpGroupAll = 261,
+    OpGroupAny = 262,
+    OpGroupBroadcast = 263,
+    OpGroupIAdd = 264,
+    OpGroupFAdd = 265,
+    OpGroupFMin = 266,
+    OpGroupUMin = 267,
+    OpGroupSMin = 268,
+    OpGroupFMax = 269,
+    OpGroupUMax = 270,
+    OpGroupSMax = 271,
+    OpReadPipe = 274,
+    OpWritePipe = 275,
+    OpReservedReadPipe = 276,
+    OpReservedWritePipe = 277,
+    OpReserveReadPipePackets = 278,
+    OpReserveWritePipePackets = 279,
+    OpCommitReadPipe = 280,
+    OpCommitWritePipe = 281,
+    OpIsValidReserveId = 282,
+    OpGetNumPipePackets = 283,
+    OpGetMaxPipePackets = 284,
+    OpGroupReserveReadPipePackets = 285,
+    OpGroupReserveWritePipePackets = 286,
+    OpGroupCommitReadPipe = 287,
+    OpGroupCommitWritePipe = 288,
+    OpEnqueueMarker = 291,
+    OpEnqueueKernel = 292,
+    OpGetKernelNDrangeSubGroupCount = 293,
+    OpGetKernelNDrangeMaxSubGroupSize = 294,
+    OpGetKernelWorkGroupSize = 295,
+    OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+    OpRetainEvent = 297,
+    OpReleaseEvent = 298,
+    OpCreateUserEvent = 299,
+    OpIsValidEvent = 300,
+    OpSetUserEventStatus = 301,
+    OpCaptureEventProfilingInfo = 302,
+    OpGetDefaultQueue = 303,
+    OpBuildNDRange = 304,
+    OpImageSparseSampleImplicitLod = 305,
+    OpImageSparseSampleExplicitLod = 306,
+    OpImageSparseSampleDrefImplicitLod = 307,
+    OpImageSparseSampleDrefExplicitLod = 308,
+    OpImageSparseSampleProjImplicitLod = 309,
+    OpImageSparseSampleProjExplicitLod = 310,
+    OpImageSparseSampleProjDrefImplicitLod = 311,
+    OpImageSparseSampleProjDrefExplicitLod = 312,
+    OpImageSparseFetch = 313,
+    OpImageSparseGather = 314,
+    OpImageSparseDrefGather = 315,
+    OpImageSparseTexelsResident = 316,
+    OpNoLine = 317,
+    OpAtomicFlagTestAndSet = 318,
+    OpAtomicFlagClear = 319,
+    OpImageSparseRead = 320,
+    OpSizeOf = 321,
+    OpTypePipeStorage = 322,
+    OpConstantPipeStorage = 323,
+    OpCreatePipeFromPipeStorage = 324,
+    OpGetKernelLocalSizeForSubgroupCount = 325,
+    OpGetKernelMaxNumSubgroups = 326,
+    OpTypeNamedBarrier = 327,
+    OpNamedBarrierInitialize = 328,
+    OpMemoryNamedBarrier = 329,
+    OpModuleProcessed = 330,
+    OpExecutionModeId = 331,
+    OpDecorateId = 332,
+    OpGroupNonUniformElect = 333,
+    OpGroupNonUniformAll = 334,
+    OpGroupNonUniformAny = 335,
+    OpGroupNonUniformAllEqual = 336,
+    OpGroupNonUniformBroadcast = 337,
+    OpGroupNonUniformBroadcastFirst = 338,
+    OpGroupNonUniformBallot = 339,
+    OpGroupNonUniformInverseBallot = 340,
+    OpGroupNonUniformBallotBitExtract = 341,
+    OpGroupNonUniformBallotBitCount = 342,
+    OpGroupNonUniformBallotFindLSB = 343,
+    OpGroupNonUniformBallotFindMSB = 344,
+    OpGroupNonUniformShuffle = 345,
+    OpGroupNonUniformShuffleXor = 346,
+    OpGroupNonUniformShuffleUp = 347,
+    OpGroupNonUniformShuffleDown = 348,
+    OpGroupNonUniformIAdd = 349,
+    OpGroupNonUniformFAdd = 350,
+    OpGroupNonUniformIMul = 351,
+    OpGroupNonUniformFMul = 352,
+    OpGroupNonUniformSMin = 353,
+    OpGroupNonUniformUMin = 354,
+    OpGroupNonUniformFMin = 355,
+    OpGroupNonUniformSMax = 356,
+    OpGroupNonUniformUMax = 357,
+    OpGroupNonUniformFMax = 358,
+    OpGroupNonUniformBitwiseAnd = 359,
+    OpGroupNonUniformBitwiseOr = 360,
+    OpGroupNonUniformBitwiseXor = 361,
+    OpGroupNonUniformLogicalAnd = 362,
+    OpGroupNonUniformLogicalOr = 363,
+    OpGroupNonUniformLogicalXor = 364,
+    OpGroupNonUniformQuadBroadcast = 365,
+    OpGroupNonUniformQuadSwap = 366,
+    OpCopyLogical = 400,
+    OpPtrEqual = 401,
+    OpPtrNotEqual = 402,
+    OpPtrDiff = 403,
+    OpColorAttachmentReadEXT = 4160,
+    OpDepthAttachmentReadEXT = 4161,
+    OpStencilAttachmentReadEXT = 4162,
+    OpTerminateInvocation = 4416,
+    OpTypeUntypedPointerKHR = 4417,
+    OpUntypedVariableKHR = 4418,
+    OpUntypedAccessChainKHR = 4419,
+    OpUntypedInBoundsAccessChainKHR = 4420,
+    OpSubgroupBallotKHR = 4421,
+    OpSubgroupFirstInvocationKHR = 4422,
+    OpUntypedPtrAccessChainKHR = 4423,
+    OpUntypedInBoundsPtrAccessChainKHR = 4424,
+    OpUntypedArrayLengthKHR = 4425,
+    OpUntypedPrefetchKHR = 4426,
+    OpSubgroupAllKHR = 4428,
+    OpSubgroupAnyKHR = 4429,
+    OpSubgroupAllEqualKHR = 4430,
+    OpGroupNonUniformRotateKHR = 4431,
+    OpSubgroupReadInvocationKHR = 4432,
+    OpExtInstWithForwardRefsKHR = 4433,
+    OpTraceRayKHR = 4445,
+    OpExecuteCallableKHR = 4446,
+    OpConvertUToAccelerationStructureKHR = 4447,
+    OpIgnoreIntersectionKHR = 4448,
+    OpTerminateRayKHR = 4449,
+    OpSDot = 4450,
+    OpSDotKHR = 4450,
+    OpUDot = 4451,
+    OpUDotKHR = 4451,
+    OpSUDot = 4452,
+    OpSUDotKHR = 4452,
+    OpSDotAccSat = 4453,
+    OpSDotAccSatKHR = 4453,
+    OpUDotAccSat = 4454,
+    OpUDotAccSatKHR = 4454,
+    OpSUDotAccSat = 4455,
+    OpSUDotAccSatKHR = 4455,
+    OpTypeCooperativeMatrixKHR = 4456,
+    OpCooperativeMatrixLoadKHR = 4457,
+    OpCooperativeMatrixStoreKHR = 4458,
+    OpCooperativeMatrixMulAddKHR = 4459,
+    OpCooperativeMatrixLengthKHR = 4460,
+    OpConstantCompositeReplicateEXT = 4461,
+    OpSpecConstantCompositeReplicateEXT = 4462,
+    OpCompositeConstructReplicateEXT = 4463,
+    OpTypeRayQueryKHR = 4472,
+    OpRayQueryInitializeKHR = 4473,
+    OpRayQueryTerminateKHR = 4474,
+    OpRayQueryGenerateIntersectionKHR = 4475,
+    OpRayQueryConfirmIntersectionKHR = 4476,
+    OpRayQueryProceedKHR = 4477,
+    OpRayQueryGetIntersectionTypeKHR = 4479,
+    OpImageSampleWeightedQCOM = 4480,
+    OpImageBoxFilterQCOM = 4481,
+    OpImageBlockMatchSSDQCOM = 4482,
+    OpImageBlockMatchSADQCOM = 4483,
+    OpImageBlockMatchWindowSSDQCOM = 4500,
+    OpImageBlockMatchWindowSADQCOM = 4501,
+    OpImageBlockMatchGatherSSDQCOM = 4502,
+    OpImageBlockMatchGatherSADQCOM = 4503,
+    OpGroupIAddNonUniformAMD = 5000,
+    OpGroupFAddNonUniformAMD = 5001,
+    OpGroupFMinNonUniformAMD = 5002,
+    OpGroupUMinNonUniformAMD = 5003,
+    OpGroupSMinNonUniformAMD = 5004,
+    OpGroupFMaxNonUniformAMD = 5005,
+    OpGroupUMaxNonUniformAMD = 5006,
+    OpGroupSMaxNonUniformAMD = 5007,
+    OpFragmentMaskFetchAMD = 5011,
+    OpFragmentFetchAMD = 5012,
+    OpReadClockKHR = 5056,
+    OpAllocateNodePayloadsAMDX = 5074,
+    OpEnqueueNodePayloadsAMDX = 5075,
+    OpTypeNodePayloadArrayAMDX = 5076,
+    OpFinishWritingNodePayloadAMDX = 5078,
+    OpNodePayloadArrayLengthAMDX = 5090,
+    OpIsNodePayloadValidAMDX = 5101,
+    OpConstantStringAMDX = 5103,
+    OpSpecConstantStringAMDX = 5104,
+    OpGroupNonUniformQuadAllKHR = 5110,
+    OpGroupNonUniformQuadAnyKHR = 5111,
+    OpHitObjectRecordHitMotionNV = 5249,
+    OpHitObjectRecordHitWithIndexMotionNV = 5250,
+    OpHitObjectRecordMissMotionNV = 5251,
+    OpHitObjectGetWorldToObjectNV = 5252,
+    OpHitObjectGetObjectToWorldNV = 5253,
+    OpHitObjectGetObjectRayDirectionNV = 5254,
+    OpHitObjectGetObjectRayOriginNV = 5255,
+    OpHitObjectTraceRayMotionNV = 5256,
+    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
+    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
+    OpHitObjectRecordEmptyNV = 5259,
+    OpHitObjectTraceRayNV = 5260,
+    OpHitObjectRecordHitNV = 5261,
+    OpHitObjectRecordHitWithIndexNV = 5262,
+    OpHitObjectRecordMissNV = 5263,
+    OpHitObjectExecuteShaderNV = 5264,
+    OpHitObjectGetCurrentTimeNV = 5265,
+    OpHitObjectGetAttributesNV = 5266,
+    OpHitObjectGetHitKindNV = 5267,
+    OpHitObjectGetPrimitiveIndexNV = 5268,
+    OpHitObjectGetGeometryIndexNV = 5269,
+    OpHitObjectGetInstanceIdNV = 5270,
+    OpHitObjectGetInstanceCustomIndexNV = 5271,
+    OpHitObjectGetWorldRayDirectionNV = 5272,
+    OpHitObjectGetWorldRayOriginNV = 5273,
+    OpHitObjectGetRayTMaxNV = 5274,
+    OpHitObjectGetRayTMinNV = 5275,
+    OpHitObjectIsEmptyNV = 5276,
+    OpHitObjectIsHitNV = 5277,
+    OpHitObjectIsMissNV = 5278,
+    OpReorderThreadWithHitObjectNV = 5279,
+    OpReorderThreadWithHintNV = 5280,
+    OpTypeHitObjectNV = 5281,
+    OpImageSampleFootprintNV = 5283,
+    OpTypeCooperativeVectorNV = 5288,
+    OpCooperativeVectorMatrixMulNV = 5289,
+    OpCooperativeVectorOuterProductAccumulateNV = 5290,
+    OpCooperativeVectorReduceSumAccumulateNV = 5291,
+    OpCooperativeVectorMatrixMulAddNV = 5292,
+    OpCooperativeMatrixConvertNV = 5293,
+    OpEmitMeshTasksEXT = 5294,
+    OpSetMeshOutputsEXT = 5295,
+    OpGroupNonUniformPartitionNV = 5296,
+    OpWritePackedPrimitiveIndices4x8NV = 5299,
+    OpFetchMicroTriangleVertexPositionNV = 5300,
+    OpFetchMicroTriangleVertexBarycentricNV = 5301,
+    OpCooperativeVectorLoadNV = 5302,
+    OpCooperativeVectorStoreNV = 5303,
+    OpReportIntersectionKHR = 5334,
+    OpReportIntersectionNV = 5334,
+    OpIgnoreIntersectionNV = 5335,
+    OpTerminateRayNV = 5336,
+    OpTraceNV = 5337,
+    OpTraceMotionNV = 5338,
+    OpTraceRayMotionNV = 5339,
+    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
+    OpTypeAccelerationStructureKHR = 5341,
+    OpTypeAccelerationStructureNV = 5341,
+    OpExecuteCallableNV = 5344,
+    OpRayQueryGetClusterIdNV = 5345,
+    OpHitObjectGetClusterIdNV = 5346,
+    OpTypeCooperativeMatrixNV = 5358,
+    OpCooperativeMatrixLoadNV = 5359,
+    OpCooperativeMatrixStoreNV = 5360,
+    OpCooperativeMatrixMulAddNV = 5361,
+    OpCooperativeMatrixLengthNV = 5362,
+    OpBeginInvocationInterlockEXT = 5364,
+    OpEndInvocationInterlockEXT = 5365,
+    OpCooperativeMatrixReduceNV = 5366,
+    OpCooperativeMatrixLoadTensorNV = 5367,
+    OpCooperativeMatrixStoreTensorNV = 5368,
+    OpCooperativeMatrixPerElementOpNV = 5369,
+    OpTypeTensorLayoutNV = 5370,
+    OpTypeTensorViewNV = 5371,
+    OpCreateTensorLayoutNV = 5372,
+    OpTensorLayoutSetDimensionNV = 5373,
+    OpTensorLayoutSetStrideNV = 5374,
+    OpTensorLayoutSliceNV = 5375,
+    OpTensorLayoutSetClampValueNV = 5376,
+    OpCreateTensorViewNV = 5377,
+    OpTensorViewSetDimensionNV = 5378,
+    OpTensorViewSetStrideNV = 5379,
+    OpDemoteToHelperInvocation = 5380,
+    OpDemoteToHelperInvocationEXT = 5380,
+    OpIsHelperInvocationEXT = 5381,
+    OpTensorViewSetClipNV = 5382,
+    OpTensorLayoutSetBlockSizeNV = 5384,
+    OpCooperativeMatrixTransposeNV = 5390,
+    OpConvertUToImageNV = 5391,
+    OpConvertUToSamplerNV = 5392,
+    OpConvertImageToUNV = 5393,
+    OpConvertSamplerToUNV = 5394,
+    OpConvertUToSampledImageNV = 5395,
+    OpConvertSampledImageToUNV = 5396,
+    OpSamplerImageAddressingModeNV = 5397,
+    OpRawAccessChainNV = 5398,
+    OpRayQueryGetIntersectionSpherePositionNV = 5427,
+    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    OpHitObjectGetSpherePositionNV = 5432,
+    OpHitObjectGetSphereRadiusNV = 5433,
+    OpHitObjectGetLSSPositionsNV = 5434,
+    OpHitObjectGetLSSRadiiNV = 5435,
+    OpHitObjectIsSphereHitNV = 5436,
+    OpHitObjectIsLSSHitNV = 5437,
+    OpRayQueryIsSphereHitNV = 5438,
+    OpRayQueryIsLSSHitNV = 5439,
+    OpSubgroupShuffleINTEL = 5571,
+    OpSubgroupShuffleDownINTEL = 5572,
+    OpSubgroupShuffleUpINTEL = 5573,
+    OpSubgroupShuffleXorINTEL = 5574,
+    OpSubgroupBlockReadINTEL = 5575,
+    OpSubgroupBlockWriteINTEL = 5576,
+    OpSubgroupImageBlockReadINTEL = 5577,
+    OpSubgroupImageBlockWriteINTEL = 5578,
+    OpSubgroupImageMediaBlockReadINTEL = 5580,
+    OpSubgroupImageMediaBlockWriteINTEL = 5581,
+    OpUCountLeadingZerosINTEL = 5585,
+    OpUCountTrailingZerosINTEL = 5586,
+    OpAbsISubINTEL = 5587,
+    OpAbsUSubINTEL = 5588,
+    OpIAddSatINTEL = 5589,
+    OpUAddSatINTEL = 5590,
+    OpIAverageINTEL = 5591,
+    OpUAverageINTEL = 5592,
+    OpIAverageRoundedINTEL = 5593,
+    OpUAverageRoundedINTEL = 5594,
+    OpISubSatINTEL = 5595,
+    OpUSubSatINTEL = 5596,
+    OpIMul32x16INTEL = 5597,
+    OpUMul32x16INTEL = 5598,
+    OpConstantFunctionPointerINTEL = 5600,
+    OpFunctionPointerCallINTEL = 5601,
+    OpAsmTargetINTEL = 5609,
+    OpAsmINTEL = 5610,
+    OpAsmCallINTEL = 5611,
+    OpAtomicFMinEXT = 5614,
+    OpAtomicFMaxEXT = 5615,
+    OpAssumeTrueKHR = 5630,
+    OpExpectKHR = 5631,
+    OpDecorateString = 5632,
+    OpDecorateStringGOOGLE = 5632,
+    OpMemberDecorateString = 5633,
+    OpMemberDecorateStringGOOGLE = 5633,
+    OpVmeImageINTEL = 5699,
+    OpTypeVmeImageINTEL = 5700,
+    OpTypeAvcImePayloadINTEL = 5701,
+    OpTypeAvcRefPayloadINTEL = 5702,
+    OpTypeAvcSicPayloadINTEL = 5703,
+    OpTypeAvcMcePayloadINTEL = 5704,
+    OpTypeAvcMceResultINTEL = 5705,
+    OpTypeAvcImeResultINTEL = 5706,
+    OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
+    OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
+    OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
+    OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
+    OpTypeAvcRefResultINTEL = 5711,
+    OpTypeAvcSicResultINTEL = 5712,
+    OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
+    OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
+    OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
+    OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
+    OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
+    OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
+    OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
+    OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
+    OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
+    OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
+    OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
+    OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
+    OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
+    OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
+    OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
+    OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
+    OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
+    OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
+    OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
+    OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
+    OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
+    OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
+    OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
+    OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
+    OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
+    OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
+    OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
+    OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
+    OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
+    OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
+    OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
+    OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
+    OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
+    OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
+    OpSubgroupAvcImeInitializeINTEL = 5747,
+    OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
+    OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
+    OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
+    OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
+    OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
+    OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
+    OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
+    OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
+    OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
+    OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
+    OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
+    OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
+    OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
+    OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
+    OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
+    OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
+    OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
+    OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
+    OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
+    OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
+    OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
+    OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
+    OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
+    OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
+    OpSubgroupAvcFmeInitializeINTEL = 5781,
+    OpSubgroupAvcBmeInitializeINTEL = 5782,
+    OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
+    OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
+    OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
+    OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
+    OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
+    OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
+    OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
+    OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
+    OpSubgroupAvcSicInitializeINTEL = 5791,
+    OpSubgroupAvcSicConfigureSkcINTEL = 5792,
+    OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
+    OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
+    OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
+    OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
+    OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
+    OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
+    OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
+    OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
+    OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
+    OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
+    OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
+    OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
+    OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
+    OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
+    OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
+    OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
+    OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
+    OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
+    OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
+    OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
+    OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
+    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
+    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
+    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
+    OpVariableLengthArrayINTEL = 5818,
+    OpSaveMemoryINTEL = 5819,
+    OpRestoreMemoryINTEL = 5820,
+    OpArbitraryFloatSinCosPiINTEL = 5840,
+    OpArbitraryFloatCastINTEL = 5841,
+    OpArbitraryFloatCastFromIntINTEL = 5842,
+    OpArbitraryFloatCastToIntINTEL = 5843,
+    OpArbitraryFloatAddINTEL = 5846,
+    OpArbitraryFloatSubINTEL = 5847,
+    OpArbitraryFloatMulINTEL = 5848,
+    OpArbitraryFloatDivINTEL = 5849,
+    OpArbitraryFloatGTINTEL = 5850,
+    OpArbitraryFloatGEINTEL = 5851,
+    OpArbitraryFloatLTINTEL = 5852,
+    OpArbitraryFloatLEINTEL = 5853,
+    OpArbitraryFloatEQINTEL = 5854,
+    OpArbitraryFloatRecipINTEL = 5855,
+    OpArbitraryFloatRSqrtINTEL = 5856,
+    OpArbitraryFloatCbrtINTEL = 5857,
+    OpArbitraryFloatHypotINTEL = 5858,
+    OpArbitraryFloatSqrtINTEL = 5859,
+    OpArbitraryFloatLogINTEL = 5860,
+    OpArbitraryFloatLog2INTEL = 5861,
+    OpArbitraryFloatLog10INTEL = 5862,
+    OpArbitraryFloatLog1pINTEL = 5863,
+    OpArbitraryFloatExpINTEL = 5864,
+    OpArbitraryFloatExp2INTEL = 5865,
+    OpArbitraryFloatExp10INTEL = 5866,
+    OpArbitraryFloatExpm1INTEL = 5867,
+    OpArbitraryFloatSinINTEL = 5868,
+    OpArbitraryFloatCosINTEL = 5869,
+    OpArbitraryFloatSinCosINTEL = 5870,
+    OpArbitraryFloatSinPiINTEL = 5871,
+    OpArbitraryFloatCosPiINTEL = 5872,
+    OpArbitraryFloatASinINTEL = 5873,
+    OpArbitraryFloatASinPiINTEL = 5874,
+    OpArbitraryFloatACosINTEL = 5875,
+    OpArbitraryFloatACosPiINTEL = 5876,
+    OpArbitraryFloatATanINTEL = 5877,
+    OpArbitraryFloatATanPiINTEL = 5878,
+    OpArbitraryFloatATan2INTEL = 5879,
+    OpArbitraryFloatPowINTEL = 5880,
+    OpArbitraryFloatPowRINTEL = 5881,
+    OpArbitraryFloatPowNINTEL = 5882,
+    OpLoopControlINTEL = 5887,
+    OpAliasDomainDeclINTEL = 5911,
+    OpAliasScopeDeclINTEL = 5912,
+    OpAliasScopeListDeclINTEL = 5913,
+    OpFixedSqrtINTEL = 5923,
+    OpFixedRecipINTEL = 5924,
+    OpFixedRsqrtINTEL = 5925,
+    OpFixedSinINTEL = 5926,
+    OpFixedCosINTEL = 5927,
+    OpFixedSinCosINTEL = 5928,
+    OpFixedSinPiINTEL = 5929,
+    OpFixedCosPiINTEL = 5930,
+    OpFixedSinCosPiINTEL = 5931,
+    OpFixedLogINTEL = 5932,
+    OpFixedExpINTEL = 5933,
+    OpPtrCastToCrossWorkgroupINTEL = 5934,
+    OpCrossWorkgroupCastToPtrINTEL = 5938,
+    OpReadPipeBlockingINTEL = 5946,
+    OpWritePipeBlockingINTEL = 5947,
+    OpFPGARegINTEL = 5949,
+    OpRayQueryGetRayTMinKHR = 6016,
+    OpRayQueryGetRayFlagsKHR = 6017,
+    OpRayQueryGetIntersectionTKHR = 6018,
+    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
+    OpRayQueryGetIntersectionInstanceIdKHR = 6020,
+    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
+    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
+    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
+    OpRayQueryGetIntersectionBarycentricsKHR = 6024,
+    OpRayQueryGetIntersectionFrontFaceKHR = 6025,
+    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
+    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
+    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
+    OpRayQueryGetWorldRayDirectionKHR = 6029,
+    OpRayQueryGetWorldRayOriginKHR = 6030,
+    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
+    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
+    OpAtomicFAddEXT = 6035,
+    OpTypeBufferSurfaceINTEL = 6086,
+    OpTypeStructContinuedINTEL = 6090,
+    OpConstantCompositeContinuedINTEL = 6091,
+    OpSpecConstantCompositeContinuedINTEL = 6092,
+    OpCompositeConstructContinuedINTEL = 6096,
+    OpConvertFToBF16INTEL = 6116,
+    OpConvertBF16ToFINTEL = 6117,
+    OpControlBarrierArriveINTEL = 6142,
+    OpControlBarrierWaitINTEL = 6143,
+    OpArithmeticFenceEXT = 6145,
+    OpSubgroupBlockPrefetchINTEL = 6221,
+    OpSubgroup2DBlockLoadINTEL = 6231,
+    OpSubgroup2DBlockLoadTransformINTEL = 6232,
+    OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+    OpSubgroup2DBlockPrefetchINTEL = 6234,
+    OpSubgroup2DBlockStoreINTEL = 6235,
+    OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
+    OpGroupIMulKHR = 6401,
+    OpGroupFMulKHR = 6402,
+    OpGroupBitwiseAndKHR = 6403,
+    OpGroupBitwiseOrKHR = 6404,
+    OpGroupBitwiseXorKHR = 6405,
+    OpGroupLogicalAndKHR = 6406,
+    OpGroupLogicalOrKHR = 6407,
+    OpGroupLogicalXorKHR = 6408,
+    OpMaskedGatherINTEL = 6428,
+    OpMaskedScatterINTEL = 6429,
+    Max = 0x7fffffff,
+};
+
+#ifdef SPV_ENABLE_UTILITY_CODE
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
+    *hasResult = *hasResultType = false;
+    switch (opcode) {
+    default: /* unknown opcode */ break;
+    case Op::OpNop: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUndef: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSourceContinued: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSource: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSourceExtension: *hasResult = false; *hasResultType = false; break;
+    case Op::OpName: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberName: *hasResult = false; *hasResultType = false; break;
+    case Op::OpString: *hasResult = true; *hasResultType = false; break;
+    case Op::OpLine: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExtension: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExtInstImport: *hasResult = true; *hasResultType = false; break;
+    case Op::OpExtInst: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMemoryModel: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEntryPoint: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecutionMode: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCapability: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeVoid: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeBool: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeInt: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeFloat: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeVector: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeImage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeSampler: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeArray: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeStruct: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypePointer: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeFunction: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeEvent: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeQueue: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypePipe: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstant: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantSampler: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantNull: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstant: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunction: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
+    case Op::OpFunctionCall: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVariable: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoad: *hasResult = true; *hasResultType = true; break;
+    case Op::OpStore: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCopyMemory: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArrayLength: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
+    case Op::OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
+    case Op::OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCopyObject: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTranspose: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSampledImage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageFetch: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageRead: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageWrite: *hasResult = false; *hasResultType = false; break;
+    case Op::OpImage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToS: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSToF: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToF: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSNegate: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFNegate: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFSub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSRem: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFRem: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case Op::OpOuterProduct: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAddCarry: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISubBorrow: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMulExtended: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSMulExtended: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsInf: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsFinite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNormal: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSignBitSet: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
+    case Op::OpOrdered: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUnordered: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalNot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSelect: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpINotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpULessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitReverse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdx: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdy: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidth: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdxFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdyFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidthFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEmitVertex: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
+    case Op::OpControlBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicStore: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicISub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPhi: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoopMerge: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLabel: *hasResult = true; *hasResultType = false; break;
+    case Op::OpBranch: *hasResult = false; *hasResultType = false; break;
+    case Op::OpBranchConditional: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSwitch: *hasResult = false; *hasResultType = false; break;
+    case Op::OpKill: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReturn: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReturnValue: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUnreachable: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadPipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRetainEvent: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNoLine: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
+    case Op::OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSizeOf: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
+    case Op::OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
+    case Op::OpDecorateId: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCopyLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrDiff: *hasResult = true; *hasResultType = true; break;
+    case Op::OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedInBoundsAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSUDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeMatrixKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixLoadKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
+    case Op::OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixTransposeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRawAccessChainNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSHitValueNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAsmTargetINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExpectKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDecorateString: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
+    case Op::OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCompositeConstructContinuedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToBF16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadTransformINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadTransposeINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break;
+    }
+}
+inline const char* SourceLanguageToString(SourceLanguage value) {
+    switch (value) {
+    case SourceLanguage::Unknown: return "Unknown";
+    case SourceLanguage::ESSL: return "ESSL";
+    case SourceLanguage::GLSL: return "GLSL";
+    case SourceLanguage::OpenCL_C: return "OpenCL_C";
+    case SourceLanguage::OpenCL_CPP: return "OpenCL_CPP";
+    case SourceLanguage::HLSL: return "HLSL";
+    case SourceLanguage::CPP_for_OpenCL: return "CPP_for_OpenCL";
+    case SourceLanguage::SYCL: return "SYCL";
+    case SourceLanguage::HERO_C: return "HERO_C";
+    case SourceLanguage::NZSL: return "NZSL";
+    case SourceLanguage::WGSL: return "WGSL";
+    case SourceLanguage::Slang: return "Slang";
+    case SourceLanguage::Zig: return "Zig";
+    case SourceLanguage::Rust: return "Rust";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ExecutionModelToString(ExecutionModel value) {
+    switch (value) {
+    case ExecutionModel::Vertex: return "Vertex";
+    case ExecutionModel::TessellationControl: return "TessellationControl";
+    case ExecutionModel::TessellationEvaluation: return "TessellationEvaluation";
+    case ExecutionModel::Geometry: return "Geometry";
+    case ExecutionModel::Fragment: return "Fragment";
+    case ExecutionModel::GLCompute: return "GLCompute";
+    case ExecutionModel::Kernel: return "Kernel";
+    case ExecutionModel::TaskNV: return "TaskNV";
+    case ExecutionModel::MeshNV: return "MeshNV";
+    case ExecutionModel::RayGenerationKHR: return "RayGenerationKHR";
+    case ExecutionModel::IntersectionKHR: return "IntersectionKHR";
+    case ExecutionModel::AnyHitKHR: return "AnyHitKHR";
+    case ExecutionModel::ClosestHitKHR: return "ClosestHitKHR";
+    case ExecutionModel::MissKHR: return "MissKHR";
+    case ExecutionModel::CallableKHR: return "CallableKHR";
+    case ExecutionModel::TaskEXT: return "TaskEXT";
+    case ExecutionModel::MeshEXT: return "MeshEXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* AddressingModelToString(AddressingModel value) {
+    switch (value) {
+    case AddressingModel::Logical: return "Logical";
+    case AddressingModel::Physical32: return "Physical32";
+    case AddressingModel::Physical64: return "Physical64";
+    case AddressingModel::PhysicalStorageBuffer64: return "PhysicalStorageBuffer64";
+    default: return "Unknown";
+    }
+}
+
+inline const char* MemoryModelToString(MemoryModel value) {
+    switch (value) {
+    case MemoryModel::Simple: return "Simple";
+    case MemoryModel::GLSL450: return "GLSL450";
+    case MemoryModel::OpenCL: return "OpenCL";
+    case MemoryModel::Vulkan: return "Vulkan";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ExecutionModeToString(ExecutionMode value) {
+    switch (value) {
+    case ExecutionMode::Invocations: return "Invocations";
+    case ExecutionMode::SpacingEqual: return "SpacingEqual";
+    case ExecutionMode::SpacingFractionalEven: return "SpacingFractionalEven";
+    case ExecutionMode::SpacingFractionalOdd: return "SpacingFractionalOdd";
+    case ExecutionMode::VertexOrderCw: return "VertexOrderCw";
+    case ExecutionMode::VertexOrderCcw: return "VertexOrderCcw";
+    case ExecutionMode::PixelCenterInteger: return "PixelCenterInteger";
+    case ExecutionMode::OriginUpperLeft: return "OriginUpperLeft";
+    case ExecutionMode::OriginLowerLeft: return "OriginLowerLeft";
+    case ExecutionMode::EarlyFragmentTests: return "EarlyFragmentTests";
+    case ExecutionMode::PointMode: return "PointMode";
+    case ExecutionMode::Xfb: return "Xfb";
+    case ExecutionMode::DepthReplacing: return "DepthReplacing";
+    case ExecutionMode::DepthGreater: return "DepthGreater";
+    case ExecutionMode::DepthLess: return "DepthLess";
+    case ExecutionMode::DepthUnchanged: return "DepthUnchanged";
+    case ExecutionMode::LocalSize: return "LocalSize";
+    case ExecutionMode::LocalSizeHint: return "LocalSizeHint";
+    case ExecutionMode::InputPoints: return "InputPoints";
+    case ExecutionMode::InputLines: return "InputLines";
+    case ExecutionMode::InputLinesAdjacency: return "InputLinesAdjacency";
+    case ExecutionMode::Triangles: return "Triangles";
+    case ExecutionMode::InputTrianglesAdjacency: return "InputTrianglesAdjacency";
+    case ExecutionMode::Quads: return "Quads";
+    case ExecutionMode::Isolines: return "Isolines";
+    case ExecutionMode::OutputVertices: return "OutputVertices";
+    case ExecutionMode::OutputPoints: return "OutputPoints";
+    case ExecutionMode::OutputLineStrip: return "OutputLineStrip";
+    case ExecutionMode::OutputTriangleStrip: return "OutputTriangleStrip";
+    case ExecutionMode::VecTypeHint: return "VecTypeHint";
+    case ExecutionMode::ContractionOff: return "ContractionOff";
+    case ExecutionMode::Initializer: return "Initializer";
+    case ExecutionMode::Finalizer: return "Finalizer";
+    case ExecutionMode::SubgroupSize: return "SubgroupSize";
+    case ExecutionMode::SubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
+    case ExecutionMode::SubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
+    case ExecutionMode::LocalSizeId: return "LocalSizeId";
+    case ExecutionMode::LocalSizeHintId: return "LocalSizeHintId";
+    case ExecutionMode::NonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
+    case ExecutionMode::NonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
+    case ExecutionMode::NonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
+    case ExecutionMode::SubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR";
+    case ExecutionMode::PostDepthCoverage: return "PostDepthCoverage";
+    case ExecutionMode::DenormPreserve: return "DenormPreserve";
+    case ExecutionMode::DenormFlushToZero: return "DenormFlushToZero";
+    case ExecutionMode::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+    case ExecutionMode::RoundingModeRTE: return "RoundingModeRTE";
+    case ExecutionMode::RoundingModeRTZ: return "RoundingModeRTZ";
+    case ExecutionMode::EarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
+    case ExecutionMode::StencilRefReplacingEXT: return "StencilRefReplacingEXT";
+    case ExecutionMode::CoalescingAMDX: return "CoalescingAMDX";
+    case ExecutionMode::IsApiEntryAMDX: return "IsApiEntryAMDX";
+    case ExecutionMode::MaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX";
+    case ExecutionMode::StaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX";
+    case ExecutionMode::ShaderIndexAMDX: return "ShaderIndexAMDX";
+    case ExecutionMode::MaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX";
+    case ExecutionMode::StencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD";
+    case ExecutionMode::StencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD";
+    case ExecutionMode::StencilRefLessFrontAMD: return "StencilRefLessFrontAMD";
+    case ExecutionMode::StencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD";
+    case ExecutionMode::StencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
+    case ExecutionMode::StencilRefLessBackAMD: return "StencilRefLessBackAMD";
+    case ExecutionMode::QuadDerivativesKHR: return "QuadDerivativesKHR";
+    case ExecutionMode::RequireFullQuadsKHR: return "RequireFullQuadsKHR";
+    case ExecutionMode::SharesInputWithAMDX: return "SharesInputWithAMDX";
+    case ExecutionMode::OutputLinesEXT: return "OutputLinesEXT";
+    case ExecutionMode::OutputPrimitivesEXT: return "OutputPrimitivesEXT";
+    case ExecutionMode::DerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR";
+    case ExecutionMode::DerivativeGroupLinearKHR: return "DerivativeGroupLinearKHR";
+    case ExecutionMode::OutputTrianglesEXT: return "OutputTrianglesEXT";
+    case ExecutionMode::PixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT";
+    case ExecutionMode::PixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT";
+    case ExecutionMode::SampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT";
+    case ExecutionMode::SampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT";
+    case ExecutionMode::ShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT";
+    case ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
+    case ExecutionMode::SharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL";
+    case ExecutionMode::RoundingModeRTPINTEL: return "RoundingModeRTPINTEL";
+    case ExecutionMode::RoundingModeRTNINTEL: return "RoundingModeRTNINTEL";
+    case ExecutionMode::FloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL";
+    case ExecutionMode::FloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL";
+    case ExecutionMode::MaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL";
+    case ExecutionMode::MaxWorkDimINTEL: return "MaxWorkDimINTEL";
+    case ExecutionMode::NoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
+    case ExecutionMode::NumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
+    case ExecutionMode::SchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL";
+    case ExecutionMode::MaximallyReconvergesKHR: return "MaximallyReconvergesKHR";
+    case ExecutionMode::FPFastMathDefault: return "FPFastMathDefault";
+    case ExecutionMode::StreamingInterfaceINTEL: return "StreamingInterfaceINTEL";
+    case ExecutionMode::RegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL";
+    case ExecutionMode::NamedBarrierCountINTEL: return "NamedBarrierCountINTEL";
+    case ExecutionMode::MaximumRegistersINTEL: return "MaximumRegistersINTEL";
+    case ExecutionMode::MaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL";
+    case ExecutionMode::NamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* StorageClassToString(StorageClass value) {
+    switch (value) {
+    case StorageClass::UniformConstant: return "UniformConstant";
+    case StorageClass::Input: return "Input";
+    case StorageClass::Uniform: return "Uniform";
+    case StorageClass::Output: return "Output";
+    case StorageClass::Workgroup: return "Workgroup";
+    case StorageClass::CrossWorkgroup: return "CrossWorkgroup";
+    case StorageClass::Private: return "Private";
+    case StorageClass::Function: return "Function";
+    case StorageClass::Generic: return "Generic";
+    case StorageClass::PushConstant: return "PushConstant";
+    case StorageClass::AtomicCounter: return "AtomicCounter";
+    case StorageClass::Image: return "Image";
+    case StorageClass::StorageBuffer: return "StorageBuffer";
+    case StorageClass::TileImageEXT: return "TileImageEXT";
+    case StorageClass::NodePayloadAMDX: return "NodePayloadAMDX";
+    case StorageClass::CallableDataKHR: return "CallableDataKHR";
+    case StorageClass::IncomingCallableDataKHR: return "IncomingCallableDataKHR";
+    case StorageClass::RayPayloadKHR: return "RayPayloadKHR";
+    case StorageClass::HitAttributeKHR: return "HitAttributeKHR";
+    case StorageClass::IncomingRayPayloadKHR: return "IncomingRayPayloadKHR";
+    case StorageClass::ShaderRecordBufferKHR: return "ShaderRecordBufferKHR";
+    case StorageClass::PhysicalStorageBuffer: return "PhysicalStorageBuffer";
+    case StorageClass::HitObjectAttributeNV: return "HitObjectAttributeNV";
+    case StorageClass::TaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
+    case StorageClass::CodeSectionINTEL: return "CodeSectionINTEL";
+    case StorageClass::DeviceOnlyINTEL: return "DeviceOnlyINTEL";
+    case StorageClass::HostOnlyINTEL: return "HostOnlyINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* DimToString(Dim value) {
+    switch (value) {
+    case Dim::Dim1D: return "1D";
+    case Dim::Dim2D: return "2D";
+    case Dim::Dim3D: return "3D";
+    case Dim::Cube: return "Cube";
+    case Dim::Rect: return "Rect";
+    case Dim::Buffer: return "Buffer";
+    case Dim::SubpassData: return "SubpassData";
+    case Dim::TileImageDataEXT: return "TileImageDataEXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) {
+    switch (value) {
+    case SamplerAddressingMode::None: return "None";
+    case SamplerAddressingMode::ClampToEdge: return "ClampToEdge";
+    case SamplerAddressingMode::Clamp: return "Clamp";
+    case SamplerAddressingMode::Repeat: return "Repeat";
+    case SamplerAddressingMode::RepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
+inline const char* SamplerFilterModeToString(SamplerFilterMode value) {
+    switch (value) {
+    case SamplerFilterMode::Nearest: return "Nearest";
+    case SamplerFilterMode::Linear: return "Linear";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageFormatToString(ImageFormat value) {
+    switch (value) {
+    case ImageFormat::Unknown: return "Unknown";
+    case ImageFormat::Rgba32f: return "Rgba32f";
+    case ImageFormat::Rgba16f: return "Rgba16f";
+    case ImageFormat::R32f: return "R32f";
+    case ImageFormat::Rgba8: return "Rgba8";
+    case ImageFormat::Rgba8Snorm: return "Rgba8Snorm";
+    case ImageFormat::Rg32f: return "Rg32f";
+    case ImageFormat::Rg16f: return "Rg16f";
+    case ImageFormat::R11fG11fB10f: return "R11fG11fB10f";
+    case ImageFormat::R16f: return "R16f";
+    case ImageFormat::Rgba16: return "Rgba16";
+    case ImageFormat::Rgb10A2: return "Rgb10A2";
+    case ImageFormat::Rg16: return "Rg16";
+    case ImageFormat::Rg8: return "Rg8";
+    case ImageFormat::R16: return "R16";
+    case ImageFormat::R8: return "R8";
+    case ImageFormat::Rgba16Snorm: return "Rgba16Snorm";
+    case ImageFormat::Rg16Snorm: return "Rg16Snorm";
+    case ImageFormat::Rg8Snorm: return "Rg8Snorm";
+    case ImageFormat::R16Snorm: return "R16Snorm";
+    case ImageFormat::R8Snorm: return "R8Snorm";
+    case ImageFormat::Rgba32i: return "Rgba32i";
+    case ImageFormat::Rgba16i: return "Rgba16i";
+    case ImageFormat::Rgba8i: return "Rgba8i";
+    case ImageFormat::R32i: return "R32i";
+    case ImageFormat::Rg32i: return "Rg32i";
+    case ImageFormat::Rg16i: return "Rg16i";
+    case ImageFormat::Rg8i: return "Rg8i";
+    case ImageFormat::R16i: return "R16i";
+    case ImageFormat::R8i: return "R8i";
+    case ImageFormat::Rgba32ui: return "Rgba32ui";
+    case ImageFormat::Rgba16ui: return "Rgba16ui";
+    case ImageFormat::Rgba8ui: return "Rgba8ui";
+    case ImageFormat::R32ui: return "R32ui";
+    case ImageFormat::Rgb10a2ui: return "Rgb10a2ui";
+    case ImageFormat::Rg32ui: return "Rg32ui";
+    case ImageFormat::Rg16ui: return "Rg16ui";
+    case ImageFormat::Rg8ui: return "Rg8ui";
+    case ImageFormat::R16ui: return "R16ui";
+    case ImageFormat::R8ui: return "R8ui";
+    case ImageFormat::R64ui: return "R64ui";
+    case ImageFormat::R64i: return "R64i";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageChannelOrderToString(ImageChannelOrder value) {
+    switch (value) {
+    case ImageChannelOrder::R: return "R";
+    case ImageChannelOrder::A: return "A";
+    case ImageChannelOrder::RG: return "RG";
+    case ImageChannelOrder::RA: return "RA";
+    case ImageChannelOrder::RGB: return "RGB";
+    case ImageChannelOrder::RGBA: return "RGBA";
+    case ImageChannelOrder::BGRA: return "BGRA";
+    case ImageChannelOrder::ARGB: return "ARGB";
+    case ImageChannelOrder::Intensity: return "Intensity";
+    case ImageChannelOrder::Luminance: return "Luminance";
+    case ImageChannelOrder::Rx: return "Rx";
+    case ImageChannelOrder::RGx: return "RGx";
+    case ImageChannelOrder::RGBx: return "RGBx";
+    case ImageChannelOrder::Depth: return "Depth";
+    case ImageChannelOrder::DepthStencil: return "DepthStencil";
+    case ImageChannelOrder::sRGB: return "sRGB";
+    case ImageChannelOrder::sRGBx: return "sRGBx";
+    case ImageChannelOrder::sRGBA: return "sRGBA";
+    case ImageChannelOrder::sBGRA: return "sBGRA";
+    case ImageChannelOrder::ABGR: return "ABGR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) {
+    switch (value) {
+    case ImageChannelDataType::SnormInt8: return "SnormInt8";
+    case ImageChannelDataType::SnormInt16: return "SnormInt16";
+    case ImageChannelDataType::UnormInt8: return "UnormInt8";
+    case ImageChannelDataType::UnormInt16: return "UnormInt16";
+    case ImageChannelDataType::UnormShort565: return "UnormShort565";
+    case ImageChannelDataType::UnormShort555: return "UnormShort555";
+    case ImageChannelDataType::UnormInt101010: return "UnormInt101010";
+    case ImageChannelDataType::SignedInt8: return "SignedInt8";
+    case ImageChannelDataType::SignedInt16: return "SignedInt16";
+    case ImageChannelDataType::SignedInt32: return "SignedInt32";
+    case ImageChannelDataType::UnsignedInt8: return "UnsignedInt8";
+    case ImageChannelDataType::UnsignedInt16: return "UnsignedInt16";
+    case ImageChannelDataType::UnsignedInt32: return "UnsignedInt32";
+    case ImageChannelDataType::HalfFloat: return "HalfFloat";
+    case ImageChannelDataType::Float: return "Float";
+    case ImageChannelDataType::UnormInt24: return "UnormInt24";
+    case ImageChannelDataType::UnormInt101010_2: return "UnormInt101010_2";
+    case ImageChannelDataType::UnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT";
+    case ImageChannelDataType::UnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT";
+    case ImageChannelDataType::UnormInt2_101010EXT: return "UnormInt2_101010EXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPRoundingModeToString(FPRoundingMode value) {
+    switch (value) {
+    case FPRoundingMode::RTE: return "RTE";
+    case FPRoundingMode::RTZ: return "RTZ";
+    case FPRoundingMode::RTP: return "RTP";
+    case FPRoundingMode::RTN: return "RTN";
+    default: return "Unknown";
+    }
+}
+
+inline const char* LinkageTypeToString(LinkageType value) {
+    switch (value) {
+    case LinkageType::Export: return "Export";
+    case LinkageType::Import: return "Import";
+    case LinkageType::LinkOnceODR: return "LinkOnceODR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* AccessQualifierToString(AccessQualifier value) {
+    switch (value) {
+    case AccessQualifier::ReadOnly: return "ReadOnly";
+    case AccessQualifier::WriteOnly: return "WriteOnly";
+    case AccessQualifier::ReadWrite: return "ReadWrite";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) {
+    switch (value) {
+    case FunctionParameterAttribute::Zext: return "Zext";
+    case FunctionParameterAttribute::Sext: return "Sext";
+    case FunctionParameterAttribute::ByVal: return "ByVal";
+    case FunctionParameterAttribute::Sret: return "Sret";
+    case FunctionParameterAttribute::NoAlias: return "NoAlias";
+    case FunctionParameterAttribute::NoCapture: return "NoCapture";
+    case FunctionParameterAttribute::NoWrite: return "NoWrite";
+    case FunctionParameterAttribute::NoReadWrite: return "NoReadWrite";
+    case FunctionParameterAttribute::RuntimeAlignedINTEL: return "RuntimeAlignedINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* DecorationToString(Decoration value) {
+    switch (value) {
+    case Decoration::RelaxedPrecision: return "RelaxedPrecision";
+    case Decoration::SpecId: return "SpecId";
+    case Decoration::Block: return "Block";
+    case Decoration::BufferBlock: return "BufferBlock";
+    case Decoration::RowMajor: return "RowMajor";
+    case Decoration::ColMajor: return "ColMajor";
+    case Decoration::ArrayStride: return "ArrayStride";
+    case Decoration::MatrixStride: return "MatrixStride";
+    case Decoration::GLSLShared: return "GLSLShared";
+    case Decoration::GLSLPacked: return "GLSLPacked";
+    case Decoration::CPacked: return "CPacked";
+    case Decoration::BuiltIn: return "BuiltIn";
+    case Decoration::NoPerspective: return "NoPerspective";
+    case Decoration::Flat: return "Flat";
+    case Decoration::Patch: return "Patch";
+    case Decoration::Centroid: return "Centroid";
+    case Decoration::Sample: return "Sample";
+    case Decoration::Invariant: return "Invariant";
+    case Decoration::Restrict: return "Restrict";
+    case Decoration::Aliased: return "Aliased";
+    case Decoration::Volatile: return "Volatile";
+    case Decoration::Constant: return "Constant";
+    case Decoration::Coherent: return "Coherent";
+    case Decoration::NonWritable: return "NonWritable";
+    case Decoration::NonReadable: return "NonReadable";
+    case Decoration::Uniform: return "Uniform";
+    case Decoration::UniformId: return "UniformId";
+    case Decoration::SaturatedConversion: return "SaturatedConversion";
+    case Decoration::Stream: return "Stream";
+    case Decoration::Location: return "Location";
+    case Decoration::Component: return "Component";
+    case Decoration::Index: return "Index";
+    case Decoration::Binding: return "Binding";
+    case Decoration::DescriptorSet: return "DescriptorSet";
+    case Decoration::Offset: return "Offset";
+    case Decoration::XfbBuffer: return "XfbBuffer";
+    case Decoration::XfbStride: return "XfbStride";
+    case Decoration::FuncParamAttr: return "FuncParamAttr";
+    case Decoration::FPRoundingMode: return "FPRoundingMode";
+    case Decoration::FPFastMathMode: return "FPFastMathMode";
+    case Decoration::LinkageAttributes: return "LinkageAttributes";
+    case Decoration::NoContraction: return "NoContraction";
+    case Decoration::InputAttachmentIndex: return "InputAttachmentIndex";
+    case Decoration::Alignment: return "Alignment";
+    case Decoration::MaxByteOffset: return "MaxByteOffset";
+    case Decoration::AlignmentId: return "AlignmentId";
+    case Decoration::MaxByteOffsetId: return "MaxByteOffsetId";
+    case Decoration::NoSignedWrap: return "NoSignedWrap";
+    case Decoration::NoUnsignedWrap: return "NoUnsignedWrap";
+    case Decoration::WeightTextureQCOM: return "WeightTextureQCOM";
+    case Decoration::BlockMatchTextureQCOM: return "BlockMatchTextureQCOM";
+    case Decoration::BlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM";
+    case Decoration::ExplicitInterpAMD: return "ExplicitInterpAMD";
+    case Decoration::NodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX";
+    case Decoration::NodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX";
+    case Decoration::TrackFinishWritingAMDX: return "TrackFinishWritingAMDX";
+    case Decoration::PayloadNodeNameAMDX: return "PayloadNodeNameAMDX";
+    case Decoration::PayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX";
+    case Decoration::PayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX";
+    case Decoration::PayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX";
+    case Decoration::PayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX";
+    case Decoration::OverrideCoverageNV: return "OverrideCoverageNV";
+    case Decoration::PassthroughNV: return "PassthroughNV";
+    case Decoration::ViewportRelativeNV: return "ViewportRelativeNV";
+    case Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
+    case Decoration::PerPrimitiveEXT: return "PerPrimitiveEXT";
+    case Decoration::PerViewNV: return "PerViewNV";
+    case Decoration::PerTaskNV: return "PerTaskNV";
+    case Decoration::PerVertexKHR: return "PerVertexKHR";
+    case Decoration::NonUniform: return "NonUniform";
+    case Decoration::RestrictPointer: return "RestrictPointer";
+    case Decoration::AliasedPointer: return "AliasedPointer";
+    case Decoration::HitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV";
+    case Decoration::BindlessSamplerNV: return "BindlessSamplerNV";
+    case Decoration::BindlessImageNV: return "BindlessImageNV";
+    case Decoration::BoundSamplerNV: return "BoundSamplerNV";
+    case Decoration::BoundImageNV: return "BoundImageNV";
+    case Decoration::SIMTCallINTEL: return "SIMTCallINTEL";
+    case Decoration::ReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL";
+    case Decoration::ClobberINTEL: return "ClobberINTEL";
+    case Decoration::SideEffectsINTEL: return "SideEffectsINTEL";
+    case Decoration::VectorComputeVariableINTEL: return "VectorComputeVariableINTEL";
+    case Decoration::FuncParamIOKindINTEL: return "FuncParamIOKindINTEL";
+    case Decoration::VectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL";
+    case Decoration::StackCallINTEL: return "StackCallINTEL";
+    case Decoration::GlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL";
+    case Decoration::CounterBuffer: return "CounterBuffer";
+    case Decoration::HlslSemanticGOOGLE: return "HlslSemanticGOOGLE";
+    case Decoration::UserTypeGOOGLE: return "UserTypeGOOGLE";
+    case Decoration::FunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL";
+    case Decoration::FunctionDenormModeINTEL: return "FunctionDenormModeINTEL";
+    case Decoration::RegisterINTEL: return "RegisterINTEL";
+    case Decoration::MemoryINTEL: return "MemoryINTEL";
+    case Decoration::NumbanksINTEL: return "NumbanksINTEL";
+    case Decoration::BankwidthINTEL: return "BankwidthINTEL";
+    case Decoration::MaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL";
+    case Decoration::SinglepumpINTEL: return "SinglepumpINTEL";
+    case Decoration::DoublepumpINTEL: return "DoublepumpINTEL";
+    case Decoration::MaxReplicatesINTEL: return "MaxReplicatesINTEL";
+    case Decoration::SimpleDualPortINTEL: return "SimpleDualPortINTEL";
+    case Decoration::MergeINTEL: return "MergeINTEL";
+    case Decoration::BankBitsINTEL: return "BankBitsINTEL";
+    case Decoration::ForcePow2DepthINTEL: return "ForcePow2DepthINTEL";
+    case Decoration::StridesizeINTEL: return "StridesizeINTEL";
+    case Decoration::WordsizeINTEL: return "WordsizeINTEL";
+    case Decoration::TrueDualPortINTEL: return "TrueDualPortINTEL";
+    case Decoration::BurstCoalesceINTEL: return "BurstCoalesceINTEL";
+    case Decoration::CacheSizeINTEL: return "CacheSizeINTEL";
+    case Decoration::DontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL";
+    case Decoration::PrefetchINTEL: return "PrefetchINTEL";
+    case Decoration::StallEnableINTEL: return "StallEnableINTEL";
+    case Decoration::FuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL";
+    case Decoration::MathOpDSPModeINTEL: return "MathOpDSPModeINTEL";
+    case Decoration::AliasScopeINTEL: return "AliasScopeINTEL";
+    case Decoration::NoAliasINTEL: return "NoAliasINTEL";
+    case Decoration::InitiationIntervalINTEL: return "InitiationIntervalINTEL";
+    case Decoration::MaxConcurrencyINTEL: return "MaxConcurrencyINTEL";
+    case Decoration::PipelineEnableINTEL: return "PipelineEnableINTEL";
+    case Decoration::BufferLocationINTEL: return "BufferLocationINTEL";
+    case Decoration::IOPipeStorageINTEL: return "IOPipeStorageINTEL";
+    case Decoration::FunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL";
+    case Decoration::SingleElementVectorINTEL: return "SingleElementVectorINTEL";
+    case Decoration::VectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL";
+    case Decoration::MediaBlockIOINTEL: return "MediaBlockIOINTEL";
+    case Decoration::StallFreeINTEL: return "StallFreeINTEL";
+    case Decoration::FPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL";
+    case Decoration::LatencyControlLabelINTEL: return "LatencyControlLabelINTEL";
+    case Decoration::LatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL";
+    case Decoration::ConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL";
+    case Decoration::RegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL";
+    case Decoration::MMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL";
+    case Decoration::MMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL";
+    case Decoration::MMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL";
+    case Decoration::MMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL";
+    case Decoration::MMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL";
+    case Decoration::MMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL";
+    case Decoration::StableKernelArgumentINTEL: return "StableKernelArgumentINTEL";
+    case Decoration::HostAccessINTEL: return "HostAccessINTEL";
+    case Decoration::InitModeINTEL: return "InitModeINTEL";
+    case Decoration::ImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL";
+    case Decoration::CacheControlLoadINTEL: return "CacheControlLoadINTEL";
+    case Decoration::CacheControlStoreINTEL: return "CacheControlStoreINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* BuiltInToString(BuiltIn value) {
+    switch (value) {
+    case BuiltIn::Position: return "Position";
+    case BuiltIn::PointSize: return "PointSize";
+    case BuiltIn::ClipDistance: return "ClipDistance";
+    case BuiltIn::CullDistance: return "CullDistance";
+    case BuiltIn::VertexId: return "VertexId";
+    case BuiltIn::InstanceId: return "InstanceId";
+    case BuiltIn::PrimitiveId: return "PrimitiveId";
+    case BuiltIn::InvocationId: return "InvocationId";
+    case BuiltIn::Layer: return "Layer";
+    case BuiltIn::ViewportIndex: return "ViewportIndex";
+    case BuiltIn::TessLevelOuter: return "TessLevelOuter";
+    case BuiltIn::TessLevelInner: return "TessLevelInner";
+    case BuiltIn::TessCoord: return "TessCoord";
+    case BuiltIn::PatchVertices: return "PatchVertices";
+    case BuiltIn::FragCoord: return "FragCoord";
+    case BuiltIn::PointCoord: return "PointCoord";
+    case BuiltIn::FrontFacing: return "FrontFacing";
+    case BuiltIn::SampleId: return "SampleId";
+    case BuiltIn::SamplePosition: return "SamplePosition";
+    case BuiltIn::SampleMask: return "SampleMask";
+    case BuiltIn::FragDepth: return "FragDepth";
+    case BuiltIn::HelperInvocation: return "HelperInvocation";
+    case BuiltIn::NumWorkgroups: return "NumWorkgroups";
+    case BuiltIn::WorkgroupSize: return "WorkgroupSize";
+    case BuiltIn::WorkgroupId: return "WorkgroupId";
+    case BuiltIn::LocalInvocationId: return "LocalInvocationId";
+    case BuiltIn::GlobalInvocationId: return "GlobalInvocationId";
+    case BuiltIn::LocalInvocationIndex: return "LocalInvocationIndex";
+    case BuiltIn::WorkDim: return "WorkDim";
+    case BuiltIn::GlobalSize: return "GlobalSize";
+    case BuiltIn::EnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize";
+    case BuiltIn::GlobalOffset: return "GlobalOffset";
+    case BuiltIn::GlobalLinearId: return "GlobalLinearId";
+    case BuiltIn::SubgroupSize: return "SubgroupSize";
+    case BuiltIn::SubgroupMaxSize: return "SubgroupMaxSize";
+    case BuiltIn::NumSubgroups: return "NumSubgroups";
+    case BuiltIn::NumEnqueuedSubgroups: return "NumEnqueuedSubgroups";
+    case BuiltIn::SubgroupId: return "SubgroupId";
+    case BuiltIn::SubgroupLocalInvocationId: return "SubgroupLocalInvocationId";
+    case BuiltIn::VertexIndex: return "VertexIndex";
+    case BuiltIn::InstanceIndex: return "InstanceIndex";
+    case BuiltIn::CoreIDARM: return "CoreIDARM";
+    case BuiltIn::CoreCountARM: return "CoreCountARM";
+    case BuiltIn::CoreMaxIDARM: return "CoreMaxIDARM";
+    case BuiltIn::WarpIDARM: return "WarpIDARM";
+    case BuiltIn::WarpMaxIDARM: return "WarpMaxIDARM";
+    case BuiltIn::SubgroupEqMask: return "SubgroupEqMask";
+    case BuiltIn::SubgroupGeMask: return "SubgroupGeMask";
+    case BuiltIn::SubgroupGtMask: return "SubgroupGtMask";
+    case BuiltIn::SubgroupLeMask: return "SubgroupLeMask";
+    case BuiltIn::SubgroupLtMask: return "SubgroupLtMask";
+    case BuiltIn::BaseVertex: return "BaseVertex";
+    case BuiltIn::BaseInstance: return "BaseInstance";
+    case BuiltIn::DrawIndex: return "DrawIndex";
+    case BuiltIn::PrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR";
+    case BuiltIn::DeviceIndex: return "DeviceIndex";
+    case BuiltIn::ViewIndex: return "ViewIndex";
+    case BuiltIn::ShadingRateKHR: return "ShadingRateKHR";
+    case BuiltIn::BaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD";
+    case BuiltIn::BaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD";
+    case BuiltIn::BaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD";
+    case BuiltIn::BaryCoordSmoothAMD: return "BaryCoordSmoothAMD";
+    case BuiltIn::BaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD";
+    case BuiltIn::BaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD";
+    case BuiltIn::BaryCoordPullModelAMD: return "BaryCoordPullModelAMD";
+    case BuiltIn::FragStencilRefEXT: return "FragStencilRefEXT";
+    case BuiltIn::RemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX";
+    case BuiltIn::ShaderIndexAMDX: return "ShaderIndexAMDX";
+    case BuiltIn::ViewportMaskNV: return "ViewportMaskNV";
+    case BuiltIn::SecondaryPositionNV: return "SecondaryPositionNV";
+    case BuiltIn::SecondaryViewportMaskNV: return "SecondaryViewportMaskNV";
+    case BuiltIn::PositionPerViewNV: return "PositionPerViewNV";
+    case BuiltIn::ViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
+    case BuiltIn::FullyCoveredEXT: return "FullyCoveredEXT";
+    case BuiltIn::TaskCountNV: return "TaskCountNV";
+    case BuiltIn::PrimitiveCountNV: return "PrimitiveCountNV";
+    case BuiltIn::PrimitiveIndicesNV: return "PrimitiveIndicesNV";
+    case BuiltIn::ClipDistancePerViewNV: return "ClipDistancePerViewNV";
+    case BuiltIn::CullDistancePerViewNV: return "CullDistancePerViewNV";
+    case BuiltIn::LayerPerViewNV: return "LayerPerViewNV";
+    case BuiltIn::MeshViewCountNV: return "MeshViewCountNV";
+    case BuiltIn::MeshViewIndicesNV: return "MeshViewIndicesNV";
+    case BuiltIn::BaryCoordKHR: return "BaryCoordKHR";
+    case BuiltIn::BaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR";
+    case BuiltIn::FragSizeEXT: return "FragSizeEXT";
+    case BuiltIn::FragInvocationCountEXT: return "FragInvocationCountEXT";
+    case BuiltIn::PrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT";
+    case BuiltIn::PrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
+    case BuiltIn::PrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
+    case BuiltIn::CullPrimitiveEXT: return "CullPrimitiveEXT";
+    case BuiltIn::LaunchIdKHR: return "LaunchIdKHR";
+    case BuiltIn::LaunchSizeKHR: return "LaunchSizeKHR";
+    case BuiltIn::WorldRayOriginKHR: return "WorldRayOriginKHR";
+    case BuiltIn::WorldRayDirectionKHR: return "WorldRayDirectionKHR";
+    case BuiltIn::ObjectRayOriginKHR: return "ObjectRayOriginKHR";
+    case BuiltIn::ObjectRayDirectionKHR: return "ObjectRayDirectionKHR";
+    case BuiltIn::RayTminKHR: return "RayTminKHR";
+    case BuiltIn::RayTmaxKHR: return "RayTmaxKHR";
+    case BuiltIn::InstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
+    case BuiltIn::ObjectToWorldKHR: return "ObjectToWorldKHR";
+    case BuiltIn::WorldToObjectKHR: return "WorldToObjectKHR";
+    case BuiltIn::HitTNV: return "HitTNV";
+    case BuiltIn::HitKindKHR: return "HitKindKHR";
+    case BuiltIn::CurrentRayTimeNV: return "CurrentRayTimeNV";
+    case BuiltIn::HitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
+    case BuiltIn::HitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
+    case BuiltIn::HitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
+    case BuiltIn::IncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
+    case BuiltIn::RayGeometryIndexKHR: return "RayGeometryIndexKHR";
+    case BuiltIn::HitIsSphereNV: return "HitIsSphereNV";
+    case BuiltIn::HitIsLSSNV: return "HitIsLSSNV";
+    case BuiltIn::HitSpherePositionNV: return "HitSpherePositionNV";
+    case BuiltIn::WarpsPerSMNV: return "WarpsPerSMNV";
+    case BuiltIn::SMCountNV: return "SMCountNV";
+    case BuiltIn::WarpIDNV: return "WarpIDNV";
+    case BuiltIn::SMIDNV: return "SMIDNV";
+    case BuiltIn::HitLSSPositionsNV: return "HitLSSPositionsNV";
+    case BuiltIn::HitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
+    case BuiltIn::HitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
+    case BuiltIn::HitSphereRadiusNV: return "HitSphereRadiusNV";
+    case BuiltIn::HitLSSRadiiNV: return "HitLSSRadiiNV";
+    case BuiltIn::ClusterIDNV: return "ClusterIDNV";
+    case BuiltIn::CullMaskKHR: return "CullMaskKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ScopeToString(Scope value) {
+    switch (value) {
+    case Scope::CrossDevice: return "CrossDevice";
+    case Scope::Device: return "Device";
+    case Scope::Workgroup: return "Workgroup";
+    case Scope::Subgroup: return "Subgroup";
+    case Scope::Invocation: return "Invocation";
+    case Scope::QueueFamily: return "QueueFamily";
+    case Scope::ShaderCallKHR: return "ShaderCallKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* GroupOperationToString(GroupOperation value) {
+    switch (value) {
+    case GroupOperation::Reduce: return "Reduce";
+    case GroupOperation::InclusiveScan: return "InclusiveScan";
+    case GroupOperation::ExclusiveScan: return "ExclusiveScan";
+    case GroupOperation::ClusteredReduce: return "ClusteredReduce";
+    case GroupOperation::PartitionedReduceNV: return "PartitionedReduceNV";
+    case GroupOperation::PartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV";
+    case GroupOperation::PartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) {
+    switch (value) {
+    case KernelEnqueueFlags::NoWait: return "NoWait";
+    case KernelEnqueueFlags::WaitKernel: return "WaitKernel";
+    case KernelEnqueueFlags::WaitWorkGroup: return "WaitWorkGroup";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CapabilityToString(Capability value) {
+    switch (value) {
+    case Capability::Matrix: return "Matrix";
+    case Capability::Shader: return "Shader";
+    case Capability::Geometry: return "Geometry";
+    case Capability::Tessellation: return "Tessellation";
+    case Capability::Addresses: return "Addresses";
+    case Capability::Linkage: return "Linkage";
+    case Capability::Kernel: return "Kernel";
+    case Capability::Vector16: return "Vector16";
+    case Capability::Float16Buffer: return "Float16Buffer";
+    case Capability::Float16: return "Float16";
+    case Capability::Float64: return "Float64";
+    case Capability::Int64: return "Int64";
+    case Capability::Int64Atomics: return "Int64Atomics";
+    case Capability::ImageBasic: return "ImageBasic";
+    case Capability::ImageReadWrite: return "ImageReadWrite";
+    case Capability::ImageMipmap: return "ImageMipmap";
+    case Capability::Pipes: return "Pipes";
+    case Capability::Groups: return "Groups";
+    case Capability::DeviceEnqueue: return "DeviceEnqueue";
+    case Capability::LiteralSampler: return "LiteralSampler";
+    case Capability::AtomicStorage: return "AtomicStorage";
+    case Capability::Int16: return "Int16";
+    case Capability::TessellationPointSize: return "TessellationPointSize";
+    case Capability::GeometryPointSize: return "GeometryPointSize";
+    case Capability::ImageGatherExtended: return "ImageGatherExtended";
+    case Capability::StorageImageMultisample: return "StorageImageMultisample";
+    case Capability::UniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing";
+    case Capability::SampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing";
+    case Capability::StorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing";
+    case Capability::StorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing";
+    case Capability::ClipDistance: return "ClipDistance";
+    case Capability::CullDistance: return "CullDistance";
+    case Capability::ImageCubeArray: return "ImageCubeArray";
+    case Capability::SampleRateShading: return "SampleRateShading";
+    case Capability::ImageRect: return "ImageRect";
+    case Capability::SampledRect: return "SampledRect";
+    case Capability::GenericPointer: return "GenericPointer";
+    case Capability::Int8: return "Int8";
+    case Capability::InputAttachment: return "InputAttachment";
+    case Capability::SparseResidency: return "SparseResidency";
+    case Capability::MinLod: return "MinLod";
+    case Capability::Sampled1D: return "Sampled1D";
+    case Capability::Image1D: return "Image1D";
+    case Capability::SampledCubeArray: return "SampledCubeArray";
+    case Capability::SampledBuffer: return "SampledBuffer";
+    case Capability::ImageBuffer: return "ImageBuffer";
+    case Capability::ImageMSArray: return "ImageMSArray";
+    case Capability::StorageImageExtendedFormats: return "StorageImageExtendedFormats";
+    case Capability::ImageQuery: return "ImageQuery";
+    case Capability::DerivativeControl: return "DerivativeControl";
+    case Capability::InterpolationFunction: return "InterpolationFunction";
+    case Capability::TransformFeedback: return "TransformFeedback";
+    case Capability::GeometryStreams: return "GeometryStreams";
+    case Capability::StorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat";
+    case Capability::StorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat";
+    case Capability::MultiViewport: return "MultiViewport";
+    case Capability::SubgroupDispatch: return "SubgroupDispatch";
+    case Capability::NamedBarrier: return "NamedBarrier";
+    case Capability::PipeStorage: return "PipeStorage";
+    case Capability::GroupNonUniform: return "GroupNonUniform";
+    case Capability::GroupNonUniformVote: return "GroupNonUniformVote";
+    case Capability::GroupNonUniformArithmetic: return "GroupNonUniformArithmetic";
+    case Capability::GroupNonUniformBallot: return "GroupNonUniformBallot";
+    case Capability::GroupNonUniformShuffle: return "GroupNonUniformShuffle";
+    case Capability::GroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative";
+    case Capability::GroupNonUniformClustered: return "GroupNonUniformClustered";
+    case Capability::GroupNonUniformQuad: return "GroupNonUniformQuad";
+    case Capability::ShaderLayer: return "ShaderLayer";
+    case Capability::ShaderViewportIndex: return "ShaderViewportIndex";
+    case Capability::UniformDecoration: return "UniformDecoration";
+    case Capability::CoreBuiltinsARM: return "CoreBuiltinsARM";
+    case Capability::TileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT";
+    case Capability::TileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT";
+    case Capability::TileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT";
+    case Capability::CooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM";
+    case Capability::FragmentShadingRateKHR: return "FragmentShadingRateKHR";
+    case Capability::SubgroupBallotKHR: return "SubgroupBallotKHR";
+    case Capability::DrawParameters: return "DrawParameters";
+    case Capability::WorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR";
+    case Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR";
+    case Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR";
+    case Capability::SubgroupVoteKHR: return "SubgroupVoteKHR";
+    case Capability::StorageBuffer16BitAccess: return "StorageBuffer16BitAccess";
+    case Capability::StorageUniform16: return "StorageUniform16";
+    case Capability::StoragePushConstant16: return "StoragePushConstant16";
+    case Capability::StorageInputOutput16: return "StorageInputOutput16";
+    case Capability::DeviceGroup: return "DeviceGroup";
+    case Capability::MultiView: return "MultiView";
+    case Capability::VariablePointersStorageBuffer: return "VariablePointersStorageBuffer";
+    case Capability::VariablePointers: return "VariablePointers";
+    case Capability::AtomicStorageOps: return "AtomicStorageOps";
+    case Capability::SampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage";
+    case Capability::StorageBuffer8BitAccess: return "StorageBuffer8BitAccess";
+    case Capability::UniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess";
+    case Capability::StoragePushConstant8: return "StoragePushConstant8";
+    case Capability::DenormPreserve: return "DenormPreserve";
+    case Capability::DenormFlushToZero: return "DenormFlushToZero";
+    case Capability::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+    case Capability::RoundingModeRTE: return "RoundingModeRTE";
+    case Capability::RoundingModeRTZ: return "RoundingModeRTZ";
+    case Capability::RayQueryProvisionalKHR: return "RayQueryProvisionalKHR";
+    case Capability::RayQueryKHR: return "RayQueryKHR";
+    case Capability::UntypedPointersKHR: return "UntypedPointersKHR";
+    case Capability::RayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
+    case Capability::RayTracingKHR: return "RayTracingKHR";
+    case Capability::TextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
+    case Capability::TextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
+    case Capability::TextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
+    case Capability::TextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
+    case Capability::Float16ImageAMD: return "Float16ImageAMD";
+    case Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
+    case Capability::FragmentMaskAMD: return "FragmentMaskAMD";
+    case Capability::StencilExportEXT: return "StencilExportEXT";
+    case Capability::ImageReadWriteLodAMD: return "ImageReadWriteLodAMD";
+    case Capability::Int64ImageEXT: return "Int64ImageEXT";
+    case Capability::ShaderClockKHR: return "ShaderClockKHR";
+    case Capability::ShaderEnqueueAMDX: return "ShaderEnqueueAMDX";
+    case Capability::QuadControlKHR: return "QuadControlKHR";
+    case Capability::BFloat16TypeKHR: return "BFloat16TypeKHR";
+    case Capability::BFloat16DotProductKHR: return "BFloat16DotProductKHR";
+    case Capability::BFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR";
+    case Capability::SampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV";
+    case Capability::GeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
+    case Capability::ShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT";
+    case Capability::ShaderViewportMaskNV: return "ShaderViewportMaskNV";
+    case Capability::ShaderStereoViewNV: return "ShaderStereoViewNV";
+    case Capability::PerViewAttributesNV: return "PerViewAttributesNV";
+    case Capability::FragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
+    case Capability::MeshShadingNV: return "MeshShadingNV";
+    case Capability::ImageFootprintNV: return "ImageFootprintNV";
+    case Capability::MeshShadingEXT: return "MeshShadingEXT";
+    case Capability::FragmentBarycentricKHR: return "FragmentBarycentricKHR";
+    case Capability::ComputeDerivativeGroupQuadsKHR: return "ComputeDerivativeGroupQuadsKHR";
+    case Capability::FragmentDensityEXT: return "FragmentDensityEXT";
+    case Capability::GroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV";
+    case Capability::ShaderNonUniform: return "ShaderNonUniform";
+    case Capability::RuntimeDescriptorArray: return "RuntimeDescriptorArray";
+    case Capability::InputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing";
+    case Capability::UniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing";
+    case Capability::StorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing";
+    case Capability::UniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing";
+    case Capability::SampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing";
+    case Capability::StorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing";
+    case Capability::StorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing";
+    case Capability::InputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing";
+    case Capability::UniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing";
+    case Capability::StorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing";
+    case Capability::RayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
+    case Capability::RayTracingNV: return "RayTracingNV";
+    case Capability::RayTracingMotionBlurNV: return "RayTracingMotionBlurNV";
+    case Capability::VulkanMemoryModel: return "VulkanMemoryModel";
+    case Capability::VulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope";
+    case Capability::PhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses";
+    case Capability::ComputeDerivativeGroupLinearKHR: return "ComputeDerivativeGroupLinearKHR";
+    case Capability::RayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
+    case Capability::CooperativeMatrixNV: return "CooperativeMatrixNV";
+    case Capability::FragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT";
+    case Capability::FragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT";
+    case Capability::ShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV";
+    case Capability::FragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT";
+    case Capability::DemoteToHelperInvocation: return "DemoteToHelperInvocation";
+    case Capability::DisplacementMicromapNV: return "DisplacementMicromapNV";
+    case Capability::RayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT";
+    case Capability::ShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
+    case Capability::BindlessTextureNV: return "BindlessTextureNV";
+    case Capability::RayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
+    case Capability::CooperativeVectorNV: return "CooperativeVectorNV";
+    case Capability::AtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
+    case Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
+    case Capability::RawAccessChainsNV: return "RawAccessChainsNV";
+    case Capability::RayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV";
+    case Capability::RayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case Capability::CooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
+    case Capability::CooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
+    case Capability::CooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
+    case Capability::CooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
+    case Capability::CooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
+    case Capability::CooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
+    case Capability::RayTracingClusterAccelerationStructureNV: return "RayTracingClusterAccelerationStructureNV";
+    case Capability::TensorAddressingNV: return "TensorAddressingNV";
+    case Capability::SubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
+    case Capability::SubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
+    case Capability::SubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL";
+    case Capability::SubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL";
+    case Capability::RoundToInfinityINTEL: return "RoundToInfinityINTEL";
+    case Capability::FloatingPointModeINTEL: return "FloatingPointModeINTEL";
+    case Capability::IntegerFunctions2INTEL: return "IntegerFunctions2INTEL";
+    case Capability::FunctionPointersINTEL: return "FunctionPointersINTEL";
+    case Capability::IndirectReferencesINTEL: return "IndirectReferencesINTEL";
+    case Capability::AsmINTEL: return "AsmINTEL";
+    case Capability::AtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT";
+    case Capability::AtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT";
+    case Capability::AtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT";
+    case Capability::VectorComputeINTEL: return "VectorComputeINTEL";
+    case Capability::VectorAnyINTEL: return "VectorAnyINTEL";
+    case Capability::ExpectAssumeKHR: return "ExpectAssumeKHR";
+    case Capability::SubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL";
+    case Capability::SubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL";
+    case Capability::SubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL";
+    case Capability::VariableLengthArrayINTEL: return "VariableLengthArrayINTEL";
+    case Capability::FunctionFloatControlINTEL: return "FunctionFloatControlINTEL";
+    case Capability::FPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL";
+    case Capability::FPFastMathModeINTEL: return "FPFastMathModeINTEL";
+    case Capability::ArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL";
+    case Capability::ArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL";
+    case Capability::UnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL";
+    case Capability::FPGALoopControlsINTEL: return "FPGALoopControlsINTEL";
+    case Capability::KernelAttributesINTEL: return "KernelAttributesINTEL";
+    case Capability::FPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL";
+    case Capability::FPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL";
+    case Capability::FPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL";
+    case Capability::LoopFuseINTEL: return "LoopFuseINTEL";
+    case Capability::FPGADSPControlINTEL: return "FPGADSPControlINTEL";
+    case Capability::MemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL";
+    case Capability::FPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL";
+    case Capability::FPGABufferLocationINTEL: return "FPGABufferLocationINTEL";
+    case Capability::ArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL";
+    case Capability::USMStorageClassesINTEL: return "USMStorageClassesINTEL";
+    case Capability::RuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL";
+    case Capability::IOPipesINTEL: return "IOPipesINTEL";
+    case Capability::BlockingPipesINTEL: return "BlockingPipesINTEL";
+    case Capability::FPGARegINTEL: return "FPGARegINTEL";
+    case Capability::DotProductInputAll: return "DotProductInputAll";
+    case Capability::DotProductInput4x8Bit: return "DotProductInput4x8Bit";
+    case Capability::DotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked";
+    case Capability::DotProduct: return "DotProduct";
+    case Capability::RayCullMaskKHR: return "RayCullMaskKHR";
+    case Capability::CooperativeMatrixKHR: return "CooperativeMatrixKHR";
+    case Capability::ReplicatedCompositesEXT: return "ReplicatedCompositesEXT";
+    case Capability::BitInstructions: return "BitInstructions";
+    case Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR";
+    case Capability::FloatControls2: return "FloatControls2";
+    case Capability::AtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
+    case Capability::AtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
+    case Capability::LongCompositesINTEL: return "LongCompositesINTEL";
+    case Capability::OptNoneEXT: return "OptNoneEXT";
+    case Capability::AtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
+    case Capability::DebugInfoModuleINTEL: return "DebugInfoModuleINTEL";
+    case Capability::BFloat16ConversionINTEL: return "BFloat16ConversionINTEL";
+    case Capability::SplitBarrierINTEL: return "SplitBarrierINTEL";
+    case Capability::ArithmeticFenceEXT: return "ArithmeticFenceEXT";
+    case Capability::FPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL";
+    case Capability::FPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL";
+    case Capability::FPMaxErrorINTEL: return "FPMaxErrorINTEL";
+    case Capability::FPGALatencyControlINTEL: return "FPGALatencyControlINTEL";
+    case Capability::FPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL";
+    case Capability::GlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL";
+    case Capability::GlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL";
+    case Capability::SubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL";
+    case Capability::Subgroup2DBlockIOINTEL: return "Subgroup2DBlockIOINTEL";
+    case Capability::Subgroup2DBlockTransformINTEL: return "Subgroup2DBlockTransformINTEL";
+    case Capability::Subgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL";
+    case Capability::SubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL";
+    case Capability::GroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
+    case Capability::MaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
+    case Capability::CacheControlsINTEL: return "CacheControlsINTEL";
+    case Capability::RegisterLimitsINTEL: return "RegisterLimitsINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryIntersectionToString(RayQueryIntersection value) {
+    switch (value) {
+    case RayQueryIntersection::RayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR";
+    case RayQueryIntersection::RayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) {
+    switch (value) {
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR";
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR";
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) {
+    switch (value) {
+    case RayQueryCandidateIntersectionType::RayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR";
+    case RayQueryCandidateIntersectionType::RayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPDenormModeToString(FPDenormMode value) {
+    switch (value) {
+    case FPDenormMode::Preserve: return "Preserve";
+    case FPDenormMode::FlushToZero: return "FlushToZero";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPOperationModeToString(FPOperationMode value) {
+    switch (value) {
+    case FPOperationMode::IEEE: return "IEEE";
+    case FPOperationMode::ALT: return "ALT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* QuantizationModesToString(QuantizationModes value) {
+    switch (value) {
+    case QuantizationModes::TRN: return "TRN";
+    case QuantizationModes::TRN_ZERO: return "TRN_ZERO";
+    case QuantizationModes::RND: return "RND";
+    case QuantizationModes::RND_ZERO: return "RND_ZERO";
+    case QuantizationModes::RND_INF: return "RND_INF";
+    case QuantizationModes::RND_MIN_INF: return "RND_MIN_INF";
+    case QuantizationModes::RND_CONV: return "RND_CONV";
+    case QuantizationModes::RND_CONV_ODD: return "RND_CONV_ODD";
+    default: return "Unknown";
+    }
+}
+
+inline const char* OverflowModesToString(OverflowModes value) {
+    switch (value) {
+    case OverflowModes::WRAP: return "WRAP";
+    case OverflowModes::SAT: return "SAT";
+    case OverflowModes::SAT_ZERO: return "SAT_ZERO";
+    case OverflowModes::SAT_SYM: return "SAT_SYM";
+    default: return "Unknown";
+    }
+}
+
+inline const char* PackedVectorFormatToString(PackedVectorFormat value) {
+    switch (value) {
+    case PackedVectorFormat::PackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) {
+    switch (value) {
+    case CooperativeMatrixLayout::RowMajorKHR: return "RowMajorKHR";
+    case CooperativeMatrixLayout::ColumnMajorKHR: return "ColumnMajorKHR";
+    case CooperativeMatrixLayout::RowBlockedInterleavedARM: return "RowBlockedInterleavedARM";
+    case CooperativeMatrixLayout::ColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) {
+    switch (value) {
+    case CooperativeMatrixUse::MatrixAKHR: return "MatrixAKHR";
+    case CooperativeMatrixUse::MatrixBKHR: return "MatrixBKHR";
+    case CooperativeMatrixUse::MatrixAccumulatorKHR: return "MatrixAccumulatorKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* TensorClampModeToString(TensorClampMode value) {
+    switch (value) {
+    case TensorClampMode::Undefined: return "Undefined";
+    case TensorClampMode::Constant: return "Constant";
+    case TensorClampMode::ClampToEdge: return "ClampToEdge";
+    case TensorClampMode::Repeat: return "Repeat";
+    case TensorClampMode::RepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
+inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) {
+    switch (value) {
+    case InitializationModeQualifier::InitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL";
+    case InitializationModeQualifier::InitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* HostAccessQualifierToString(HostAccessQualifier value) {
+    switch (value) {
+    case HostAccessQualifier::NoneINTEL: return "NoneINTEL";
+    case HostAccessQualifier::ReadINTEL: return "ReadINTEL";
+    case HostAccessQualifier::WriteINTEL: return "WriteINTEL";
+    case HostAccessQualifier::ReadWriteINTEL: return "ReadWriteINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* LoadCacheControlToString(LoadCacheControl value) {
+    switch (value) {
+    case LoadCacheControl::UncachedINTEL: return "UncachedINTEL";
+    case LoadCacheControl::CachedINTEL: return "CachedINTEL";
+    case LoadCacheControl::StreamingINTEL: return "StreamingINTEL";
+    case LoadCacheControl::InvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL";
+    case LoadCacheControl::ConstCachedINTEL: return "ConstCachedINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* StoreCacheControlToString(StoreCacheControl value) {
+    switch (value) {
+    case StoreCacheControl::UncachedINTEL: return "UncachedINTEL";
+    case StoreCacheControl::WriteThroughINTEL: return "WriteThroughINTEL";
+    case StoreCacheControl::WriteBackINTEL: return "WriteBackINTEL";
+    case StoreCacheControl::StreamingINTEL: return "StreamingINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) {
+    switch (value) {
+    case NamedMaximumNumberOfRegisters::AutoINTEL: return "AutoINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPEncodingToString(FPEncoding value) {
+    switch (value) {
+    case FPEncoding::BFloat16KHR: return "BFloat16KHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) {
+    switch (value) {
+    case CooperativeVectorMatrixLayout::RowMajorNV: return "RowMajorNV";
+    case CooperativeVectorMatrixLayout::ColumnMajorNV: return "ColumnMajorNV";
+    case CooperativeVectorMatrixLayout::InferencingOptimalNV: return "InferencingOptimalNV";
+    case CooperativeVectorMatrixLayout::TrainingOptimalNV: return "TrainingOptimalNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ComponentTypeToString(ComponentType value) {
+    switch (value) {
+    case ComponentType::Float16NV: return "Float16NV";
+    case ComponentType::Float32NV: return "Float32NV";
+    case ComponentType::Float64NV: return "Float64NV";
+    case ComponentType::SignedInt8NV: return "SignedInt8NV";
+    case ComponentType::SignedInt16NV: return "SignedInt16NV";
+    case ComponentType::SignedInt32NV: return "SignedInt32NV";
+    case ComponentType::SignedInt64NV: return "SignedInt64NV";
+    case ComponentType::UnsignedInt8NV: return "UnsignedInt8NV";
+    case ComponentType::UnsignedInt16NV: return "UnsignedInt16NV";
+    case ComponentType::UnsignedInt32NV: return "UnsignedInt32NV";
+    case ComponentType::UnsignedInt64NV: return "UnsignedInt64NV";
+    case ComponentType::SignedInt8PackedNV: return "SignedInt8PackedNV";
+    case ComponentType::UnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
+    case ComponentType::FloatE4M3NV: return "FloatE4M3NV";
+    case ComponentType::FloatE5M2NV: return "FloatE5M2NV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* OpToString(Op value) {
+    switch (value) {
+    case Op::OpNop: return "OpNop";
+    case Op::OpUndef: return "OpUndef";
+    case Op::OpSourceContinued: return "OpSourceContinued";
+    case Op::OpSource: return "OpSource";
+    case Op::OpSourceExtension: return "OpSourceExtension";
+    case Op::OpName: return "OpName";
+    case Op::OpMemberName: return "OpMemberName";
+    case Op::OpString: return "OpString";
+    case Op::OpLine: return "OpLine";
+    case Op::OpExtension: return "OpExtension";
+    case Op::OpExtInstImport: return "OpExtInstImport";
+    case Op::OpExtInst: return "OpExtInst";
+    case Op::OpMemoryModel: return "OpMemoryModel";
+    case Op::OpEntryPoint: return "OpEntryPoint";
+    case Op::OpExecutionMode: return "OpExecutionMode";
+    case Op::OpCapability: return "OpCapability";
+    case Op::OpTypeVoid: return "OpTypeVoid";
+    case Op::OpTypeBool: return "OpTypeBool";
+    case Op::OpTypeInt: return "OpTypeInt";
+    case Op::OpTypeFloat: return "OpTypeFloat";
+    case Op::OpTypeVector: return "OpTypeVector";
+    case Op::OpTypeMatrix: return "OpTypeMatrix";
+    case Op::OpTypeImage: return "OpTypeImage";
+    case Op::OpTypeSampler: return "OpTypeSampler";
+    case Op::OpTypeSampledImage: return "OpTypeSampledImage";
+    case Op::OpTypeArray: return "OpTypeArray";
+    case Op::OpTypeRuntimeArray: return "OpTypeRuntimeArray";
+    case Op::OpTypeStruct: return "OpTypeStruct";
+    case Op::OpTypeOpaque: return "OpTypeOpaque";
+    case Op::OpTypePointer: return "OpTypePointer";
+    case Op::OpTypeFunction: return "OpTypeFunction";
+    case Op::OpTypeEvent: return "OpTypeEvent";
+    case Op::OpTypeDeviceEvent: return "OpTypeDeviceEvent";
+    case Op::OpTypeReserveId: return "OpTypeReserveId";
+    case Op::OpTypeQueue: return "OpTypeQueue";
+    case Op::OpTypePipe: return "OpTypePipe";
+    case Op::OpTypeForwardPointer: return "OpTypeForwardPointer";
+    case Op::OpConstantTrue: return "OpConstantTrue";
+    case Op::OpConstantFalse: return "OpConstantFalse";
+    case Op::OpConstant: return "OpConstant";
+    case Op::OpConstantComposite: return "OpConstantComposite";
+    case Op::OpConstantSampler: return "OpConstantSampler";
+    case Op::OpConstantNull: return "OpConstantNull";
+    case Op::OpSpecConstantTrue: return "OpSpecConstantTrue";
+    case Op::OpSpecConstantFalse: return "OpSpecConstantFalse";
+    case Op::OpSpecConstant: return "OpSpecConstant";
+    case Op::OpSpecConstantComposite: return "OpSpecConstantComposite";
+    case Op::OpSpecConstantOp: return "OpSpecConstantOp";
+    case Op::OpFunction: return "OpFunction";
+    case Op::OpFunctionParameter: return "OpFunctionParameter";
+    case Op::OpFunctionEnd: return "OpFunctionEnd";
+    case Op::OpFunctionCall: return "OpFunctionCall";
+    case Op::OpVariable: return "OpVariable";
+    case Op::OpImageTexelPointer: return "OpImageTexelPointer";
+    case Op::OpLoad: return "OpLoad";
+    case Op::OpStore: return "OpStore";
+    case Op::OpCopyMemory: return "OpCopyMemory";
+    case Op::OpCopyMemorySized: return "OpCopyMemorySized";
+    case Op::OpAccessChain: return "OpAccessChain";
+    case Op::OpInBoundsAccessChain: return "OpInBoundsAccessChain";
+    case Op::OpPtrAccessChain: return "OpPtrAccessChain";
+    case Op::OpArrayLength: return "OpArrayLength";
+    case Op::OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics";
+    case Op::OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain";
+    case Op::OpDecorate: return "OpDecorate";
+    case Op::OpMemberDecorate: return "OpMemberDecorate";
+    case Op::OpDecorationGroup: return "OpDecorationGroup";
+    case Op::OpGroupDecorate: return "OpGroupDecorate";
+    case Op::OpGroupMemberDecorate: return "OpGroupMemberDecorate";
+    case Op::OpVectorExtractDynamic: return "OpVectorExtractDynamic";
+    case Op::OpVectorInsertDynamic: return "OpVectorInsertDynamic";
+    case Op::OpVectorShuffle: return "OpVectorShuffle";
+    case Op::OpCompositeConstruct: return "OpCompositeConstruct";
+    case Op::OpCompositeExtract: return "OpCompositeExtract";
+    case Op::OpCompositeInsert: return "OpCompositeInsert";
+    case Op::OpCopyObject: return "OpCopyObject";
+    case Op::OpTranspose: return "OpTranspose";
+    case Op::OpSampledImage: return "OpSampledImage";
+    case Op::OpImageSampleImplicitLod: return "OpImageSampleImplicitLod";
+    case Op::OpImageSampleExplicitLod: return "OpImageSampleExplicitLod";
+    case Op::OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod";
+    case Op::OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod";
+    case Op::OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod";
+    case Op::OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod";
+    case Op::OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod";
+    case Op::OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod";
+    case Op::OpImageFetch: return "OpImageFetch";
+    case Op::OpImageGather: return "OpImageGather";
+    case Op::OpImageDrefGather: return "OpImageDrefGather";
+    case Op::OpImageRead: return "OpImageRead";
+    case Op::OpImageWrite: return "OpImageWrite";
+    case Op::OpImage: return "OpImage";
+    case Op::OpImageQueryFormat: return "OpImageQueryFormat";
+    case Op::OpImageQueryOrder: return "OpImageQueryOrder";
+    case Op::OpImageQuerySizeLod: return "OpImageQuerySizeLod";
+    case Op::OpImageQuerySize: return "OpImageQuerySize";
+    case Op::OpImageQueryLod: return "OpImageQueryLod";
+    case Op::OpImageQueryLevels: return "OpImageQueryLevels";
+    case Op::OpImageQuerySamples: return "OpImageQuerySamples";
+    case Op::OpConvertFToU: return "OpConvertFToU";
+    case Op::OpConvertFToS: return "OpConvertFToS";
+    case Op::OpConvertSToF: return "OpConvertSToF";
+    case Op::OpConvertUToF: return "OpConvertUToF";
+    case Op::OpUConvert: return "OpUConvert";
+    case Op::OpSConvert: return "OpSConvert";
+    case Op::OpFConvert: return "OpFConvert";
+    case Op::OpQuantizeToF16: return "OpQuantizeToF16";
+    case Op::OpConvertPtrToU: return "OpConvertPtrToU";
+    case Op::OpSatConvertSToU: return "OpSatConvertSToU";
+    case Op::OpSatConvertUToS: return "OpSatConvertUToS";
+    case Op::OpConvertUToPtr: return "OpConvertUToPtr";
+    case Op::OpPtrCastToGeneric: return "OpPtrCastToGeneric";
+    case Op::OpGenericCastToPtr: return "OpGenericCastToPtr";
+    case Op::OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit";
+    case Op::OpBitcast: return "OpBitcast";
+    case Op::OpSNegate: return "OpSNegate";
+    case Op::OpFNegate: return "OpFNegate";
+    case Op::OpIAdd: return "OpIAdd";
+    case Op::OpFAdd: return "OpFAdd";
+    case Op::OpISub: return "OpISub";
+    case Op::OpFSub: return "OpFSub";
+    case Op::OpIMul: return "OpIMul";
+    case Op::OpFMul: return "OpFMul";
+    case Op::OpUDiv: return "OpUDiv";
+    case Op::OpSDiv: return "OpSDiv";
+    case Op::OpFDiv: return "OpFDiv";
+    case Op::OpUMod: return "OpUMod";
+    case Op::OpSRem: return "OpSRem";
+    case Op::OpSMod: return "OpSMod";
+    case Op::OpFRem: return "OpFRem";
+    case Op::OpFMod: return "OpFMod";
+    case Op::OpVectorTimesScalar: return "OpVectorTimesScalar";
+    case Op::OpMatrixTimesScalar: return "OpMatrixTimesScalar";
+    case Op::OpVectorTimesMatrix: return "OpVectorTimesMatrix";
+    case Op::OpMatrixTimesVector: return "OpMatrixTimesVector";
+    case Op::OpMatrixTimesMatrix: return "OpMatrixTimesMatrix";
+    case Op::OpOuterProduct: return "OpOuterProduct";
+    case Op::OpDot: return "OpDot";
+    case Op::OpIAddCarry: return "OpIAddCarry";
+    case Op::OpISubBorrow: return "OpISubBorrow";
+    case Op::OpUMulExtended: return "OpUMulExtended";
+    case Op::OpSMulExtended: return "OpSMulExtended";
+    case Op::OpAny: return "OpAny";
+    case Op::OpAll: return "OpAll";
+    case Op::OpIsNan: return "OpIsNan";
+    case Op::OpIsInf: return "OpIsInf";
+    case Op::OpIsFinite: return "OpIsFinite";
+    case Op::OpIsNormal: return "OpIsNormal";
+    case Op::OpSignBitSet: return "OpSignBitSet";
+    case Op::OpLessOrGreater: return "OpLessOrGreater";
+    case Op::OpOrdered: return "OpOrdered";
+    case Op::OpUnordered: return "OpUnordered";
+    case Op::OpLogicalEqual: return "OpLogicalEqual";
+    case Op::OpLogicalNotEqual: return "OpLogicalNotEqual";
+    case Op::OpLogicalOr: return "OpLogicalOr";
+    case Op::OpLogicalAnd: return "OpLogicalAnd";
+    case Op::OpLogicalNot: return "OpLogicalNot";
+    case Op::OpSelect: return "OpSelect";
+    case Op::OpIEqual: return "OpIEqual";
+    case Op::OpINotEqual: return "OpINotEqual";
+    case Op::OpUGreaterThan: return "OpUGreaterThan";
+    case Op::OpSGreaterThan: return "OpSGreaterThan";
+    case Op::OpUGreaterThanEqual: return "OpUGreaterThanEqual";
+    case Op::OpSGreaterThanEqual: return "OpSGreaterThanEqual";
+    case Op::OpULessThan: return "OpULessThan";
+    case Op::OpSLessThan: return "OpSLessThan";
+    case Op::OpULessThanEqual: return "OpULessThanEqual";
+    case Op::OpSLessThanEqual: return "OpSLessThanEqual";
+    case Op::OpFOrdEqual: return "OpFOrdEqual";
+    case Op::OpFUnordEqual: return "OpFUnordEqual";
+    case Op::OpFOrdNotEqual: return "OpFOrdNotEqual";
+    case Op::OpFUnordNotEqual: return "OpFUnordNotEqual";
+    case Op::OpFOrdLessThan: return "OpFOrdLessThan";
+    case Op::OpFUnordLessThan: return "OpFUnordLessThan";
+    case Op::OpFOrdGreaterThan: return "OpFOrdGreaterThan";
+    case Op::OpFUnordGreaterThan: return "OpFUnordGreaterThan";
+    case Op::OpFOrdLessThanEqual: return "OpFOrdLessThanEqual";
+    case Op::OpFUnordLessThanEqual: return "OpFUnordLessThanEqual";
+    case Op::OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual";
+    case Op::OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual";
+    case Op::OpShiftRightLogical: return "OpShiftRightLogical";
+    case Op::OpShiftRightArithmetic: return "OpShiftRightArithmetic";
+    case Op::OpShiftLeftLogical: return "OpShiftLeftLogical";
+    case Op::OpBitwiseOr: return "OpBitwiseOr";
+    case Op::OpBitwiseXor: return "OpBitwiseXor";
+    case Op::OpBitwiseAnd: return "OpBitwiseAnd";
+    case Op::OpNot: return "OpNot";
+    case Op::OpBitFieldInsert: return "OpBitFieldInsert";
+    case Op::OpBitFieldSExtract: return "OpBitFieldSExtract";
+    case Op::OpBitFieldUExtract: return "OpBitFieldUExtract";
+    case Op::OpBitReverse: return "OpBitReverse";
+    case Op::OpBitCount: return "OpBitCount";
+    case Op::OpDPdx: return "OpDPdx";
+    case Op::OpDPdy: return "OpDPdy";
+    case Op::OpFwidth: return "OpFwidth";
+    case Op::OpDPdxFine: return "OpDPdxFine";
+    case Op::OpDPdyFine: return "OpDPdyFine";
+    case Op::OpFwidthFine: return "OpFwidthFine";
+    case Op::OpDPdxCoarse: return "OpDPdxCoarse";
+    case Op::OpDPdyCoarse: return "OpDPdyCoarse";
+    case Op::OpFwidthCoarse: return "OpFwidthCoarse";
+    case Op::OpEmitVertex: return "OpEmitVertex";
+    case Op::OpEndPrimitive: return "OpEndPrimitive";
+    case Op::OpEmitStreamVertex: return "OpEmitStreamVertex";
+    case Op::OpEndStreamPrimitive: return "OpEndStreamPrimitive";
+    case Op::OpControlBarrier: return "OpControlBarrier";
+    case Op::OpMemoryBarrier: return "OpMemoryBarrier";
+    case Op::OpAtomicLoad: return "OpAtomicLoad";
+    case Op::OpAtomicStore: return "OpAtomicStore";
+    case Op::OpAtomicExchange: return "OpAtomicExchange";
+    case Op::OpAtomicCompareExchange: return "OpAtomicCompareExchange";
+    case Op::OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak";
+    case Op::OpAtomicIIncrement: return "OpAtomicIIncrement";
+    case Op::OpAtomicIDecrement: return "OpAtomicIDecrement";
+    case Op::OpAtomicIAdd: return "OpAtomicIAdd";
+    case Op::OpAtomicISub: return "OpAtomicISub";
+    case Op::OpAtomicSMin: return "OpAtomicSMin";
+    case Op::OpAtomicUMin: return "OpAtomicUMin";
+    case Op::OpAtomicSMax: return "OpAtomicSMax";
+    case Op::OpAtomicUMax: return "OpAtomicUMax";
+    case Op::OpAtomicAnd: return "OpAtomicAnd";
+    case Op::OpAtomicOr: return "OpAtomicOr";
+    case Op::OpAtomicXor: return "OpAtomicXor";
+    case Op::OpPhi: return "OpPhi";
+    case Op::OpLoopMerge: return "OpLoopMerge";
+    case Op::OpSelectionMerge: return "OpSelectionMerge";
+    case Op::OpLabel: return "OpLabel";
+    case Op::OpBranch: return "OpBranch";
+    case Op::OpBranchConditional: return "OpBranchConditional";
+    case Op::OpSwitch: return "OpSwitch";
+    case Op::OpKill: return "OpKill";
+    case Op::OpReturn: return "OpReturn";
+    case Op::OpReturnValue: return "OpReturnValue";
+    case Op::OpUnreachable: return "OpUnreachable";
+    case Op::OpLifetimeStart: return "OpLifetimeStart";
+    case Op::OpLifetimeStop: return "OpLifetimeStop";
+    case Op::OpGroupAsyncCopy: return "OpGroupAsyncCopy";
+    case Op::OpGroupWaitEvents: return "OpGroupWaitEvents";
+    case Op::OpGroupAll: return "OpGroupAll";
+    case Op::OpGroupAny: return "OpGroupAny";
+    case Op::OpGroupBroadcast: return "OpGroupBroadcast";
+    case Op::OpGroupIAdd: return "OpGroupIAdd";
+    case Op::OpGroupFAdd: return "OpGroupFAdd";
+    case Op::OpGroupFMin: return "OpGroupFMin";
+    case Op::OpGroupUMin: return "OpGroupUMin";
+    case Op::OpGroupSMin: return "OpGroupSMin";
+    case Op::OpGroupFMax: return "OpGroupFMax";
+    case Op::OpGroupUMax: return "OpGroupUMax";
+    case Op::OpGroupSMax: return "OpGroupSMax";
+    case Op::OpReadPipe: return "OpReadPipe";
+    case Op::OpWritePipe: return "OpWritePipe";
+    case Op::OpReservedReadPipe: return "OpReservedReadPipe";
+    case Op::OpReservedWritePipe: return "OpReservedWritePipe";
+    case Op::OpReserveReadPipePackets: return "OpReserveReadPipePackets";
+    case Op::OpReserveWritePipePackets: return "OpReserveWritePipePackets";
+    case Op::OpCommitReadPipe: return "OpCommitReadPipe";
+    case Op::OpCommitWritePipe: return "OpCommitWritePipe";
+    case Op::OpIsValidReserveId: return "OpIsValidReserveId";
+    case Op::OpGetNumPipePackets: return "OpGetNumPipePackets";
+    case Op::OpGetMaxPipePackets: return "OpGetMaxPipePackets";
+    case Op::OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets";
+    case Op::OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets";
+    case Op::OpGroupCommitReadPipe: return "OpGroupCommitReadPipe";
+    case Op::OpGroupCommitWritePipe: return "OpGroupCommitWritePipe";
+    case Op::OpEnqueueMarker: return "OpEnqueueMarker";
+    case Op::OpEnqueueKernel: return "OpEnqueueKernel";
+    case Op::OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount";
+    case Op::OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize";
+    case Op::OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize";
+    case Op::OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple";
+    case Op::OpRetainEvent: return "OpRetainEvent";
+    case Op::OpReleaseEvent: return "OpReleaseEvent";
+    case Op::OpCreateUserEvent: return "OpCreateUserEvent";
+    case Op::OpIsValidEvent: return "OpIsValidEvent";
+    case Op::OpSetUserEventStatus: return "OpSetUserEventStatus";
+    case Op::OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo";
+    case Op::OpGetDefaultQueue: return "OpGetDefaultQueue";
+    case Op::OpBuildNDRange: return "OpBuildNDRange";
+    case Op::OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod";
+    case Op::OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod";
+    case Op::OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod";
+    case Op::OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod";
+    case Op::OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod";
+    case Op::OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod";
+    case Op::OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod";
+    case Op::OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod";
+    case Op::OpImageSparseFetch: return "OpImageSparseFetch";
+    case Op::OpImageSparseGather: return "OpImageSparseGather";
+    case Op::OpImageSparseDrefGather: return "OpImageSparseDrefGather";
+    case Op::OpImageSparseTexelsResident: return "OpImageSparseTexelsResident";
+    case Op::OpNoLine: return "OpNoLine";
+    case Op::OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet";
+    case Op::OpAtomicFlagClear: return "OpAtomicFlagClear";
+    case Op::OpImageSparseRead: return "OpImageSparseRead";
+    case Op::OpSizeOf: return "OpSizeOf";
+    case Op::OpTypePipeStorage: return "OpTypePipeStorage";
+    case Op::OpConstantPipeStorage: return "OpConstantPipeStorage";
+    case Op::OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage";
+    case Op::OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount";
+    case Op::OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups";
+    case Op::OpTypeNamedBarrier: return "OpTypeNamedBarrier";
+    case Op::OpNamedBarrierInitialize: return "OpNamedBarrierInitialize";
+    case Op::OpMemoryNamedBarrier: return "OpMemoryNamedBarrier";
+    case Op::OpModuleProcessed: return "OpModuleProcessed";
+    case Op::OpExecutionModeId: return "OpExecutionModeId";
+    case Op::OpDecorateId: return "OpDecorateId";
+    case Op::OpGroupNonUniformElect: return "OpGroupNonUniformElect";
+    case Op::OpGroupNonUniformAll: return "OpGroupNonUniformAll";
+    case Op::OpGroupNonUniformAny: return "OpGroupNonUniformAny";
+    case Op::OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual";
+    case Op::OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast";
+    case Op::OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst";
+    case Op::OpGroupNonUniformBallot: return "OpGroupNonUniformBallot";
+    case Op::OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot";
+    case Op::OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract";
+    case Op::OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount";
+    case Op::OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB";
+    case Op::OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB";
+    case Op::OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle";
+    case Op::OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor";
+    case Op::OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp";
+    case Op::OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown";
+    case Op::OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd";
+    case Op::OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd";
+    case Op::OpGroupNonUniformIMul: return "OpGroupNonUniformIMul";
+    case Op::OpGroupNonUniformFMul: return "OpGroupNonUniformFMul";
+    case Op::OpGroupNonUniformSMin: return "OpGroupNonUniformSMin";
+    case Op::OpGroupNonUniformUMin: return "OpGroupNonUniformUMin";
+    case Op::OpGroupNonUniformFMin: return "OpGroupNonUniformFMin";
+    case Op::OpGroupNonUniformSMax: return "OpGroupNonUniformSMax";
+    case Op::OpGroupNonUniformUMax: return "OpGroupNonUniformUMax";
+    case Op::OpGroupNonUniformFMax: return "OpGroupNonUniformFMax";
+    case Op::OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd";
+    case Op::OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr";
+    case Op::OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor";
+    case Op::OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd";
+    case Op::OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr";
+    case Op::OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor";
+    case Op::OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast";
+    case Op::OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap";
+    case Op::OpCopyLogical: return "OpCopyLogical";
+    case Op::OpPtrEqual: return "OpPtrEqual";
+    case Op::OpPtrNotEqual: return "OpPtrNotEqual";
+    case Op::OpPtrDiff: return "OpPtrDiff";
+    case Op::OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
+    case Op::OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
+    case Op::OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
+    case Op::OpTerminateInvocation: return "OpTerminateInvocation";
+    case Op::OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR";
+    case Op::OpUntypedVariableKHR: return "OpUntypedVariableKHR";
+    case Op::OpUntypedAccessChainKHR: return "OpUntypedAccessChainKHR";
+    case Op::OpUntypedInBoundsAccessChainKHR: return "OpUntypedInBoundsAccessChainKHR";
+    case Op::OpSubgroupBallotKHR: return "OpSubgroupBallotKHR";
+    case Op::OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR";
+    case Op::OpUntypedPtrAccessChainKHR: return "OpUntypedPtrAccessChainKHR";
+    case Op::OpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR";
+    case Op::OpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR";
+    case Op::OpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR";
+    case Op::OpSubgroupAllKHR: return "OpSubgroupAllKHR";
+    case Op::OpSubgroupAnyKHR: return "OpSubgroupAnyKHR";
+    case Op::OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR";
+    case Op::OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
+    case Op::OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR";
+    case Op::OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR";
+    case Op::OpTraceRayKHR: return "OpTraceRayKHR";
+    case Op::OpExecuteCallableKHR: return "OpExecuteCallableKHR";
+    case Op::OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
+    case Op::OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR";
+    case Op::OpTerminateRayKHR: return "OpTerminateRayKHR";
+    case Op::OpSDot: return "OpSDot";
+    case Op::OpUDot: return "OpUDot";
+    case Op::OpSUDot: return "OpSUDot";
+    case Op::OpSDotAccSat: return "OpSDotAccSat";
+    case Op::OpUDotAccSat: return "OpUDotAccSat";
+    case Op::OpSUDotAccSat: return "OpSUDotAccSat";
+    case Op::OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR";
+    case Op::OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR";
+    case Op::OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR";
+    case Op::OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR";
+    case Op::OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR";
+    case Op::OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
+    case Op::OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
+    case Op::OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
+    case Op::OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
+    case Op::OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
+    case Op::OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR";
+    case Op::OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR";
+    case Op::OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR";
+    case Op::OpRayQueryProceedKHR: return "OpRayQueryProceedKHR";
+    case Op::OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR";
+    case Op::OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM";
+    case Op::OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
+    case Op::OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
+    case Op::OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
+    case Op::OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
+    case Op::OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
+    case Op::OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
+    case Op::OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
+    case Op::OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD";
+    case Op::OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD";
+    case Op::OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD";
+    case Op::OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD";
+    case Op::OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD";
+    case Op::OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD";
+    case Op::OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD";
+    case Op::OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD";
+    case Op::OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD";
+    case Op::OpFragmentFetchAMD: return "OpFragmentFetchAMD";
+    case Op::OpReadClockKHR: return "OpReadClockKHR";
+    case Op::OpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX";
+    case Op::OpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX";
+    case Op::OpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX";
+    case Op::OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX";
+    case Op::OpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX";
+    case Op::OpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX";
+    case Op::OpConstantStringAMDX: return "OpConstantStringAMDX";
+    case Op::OpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX";
+    case Op::OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
+    case Op::OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
+    case Op::OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
+    case Op::OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
+    case Op::OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV";
+    case Op::OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV";
+    case Op::OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV";
+    case Op::OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV";
+    case Op::OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV";
+    case Op::OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV";
+    case Op::OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
+    case Op::OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
+    case Op::OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV";
+    case Op::OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV";
+    case Op::OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV";
+    case Op::OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV";
+    case Op::OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV";
+    case Op::OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV";
+    case Op::OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV";
+    case Op::OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV";
+    case Op::OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV";
+    case Op::OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV";
+    case Op::OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV";
+    case Op::OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV";
+    case Op::OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV";
+    case Op::OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV";
+    case Op::OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV";
+    case Op::OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV";
+    case Op::OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV";
+    case Op::OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV";
+    case Op::OpHitObjectIsHitNV: return "OpHitObjectIsHitNV";
+    case Op::OpHitObjectIsMissNV: return "OpHitObjectIsMissNV";
+    case Op::OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV";
+    case Op::OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
+    case Op::OpTypeHitObjectNV: return "OpTypeHitObjectNV";
+    case Op::OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
+    case Op::OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
+    case Op::OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
+    case Op::OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
+    case Op::OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
+    case Op::OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
+    case Op::OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
+    case Op::OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
+    case Op::OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
+    case Op::OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
+    case Op::OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
+    case Op::OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
+    case Op::OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
+    case Op::OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
+    case Op::OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
+    case Op::OpReportIntersectionKHR: return "OpReportIntersectionKHR";
+    case Op::OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
+    case Op::OpTerminateRayNV: return "OpTerminateRayNV";
+    case Op::OpTraceNV: return "OpTraceNV";
+    case Op::OpTraceMotionNV: return "OpTraceMotionNV";
+    case Op::OpTraceRayMotionNV: return "OpTraceRayMotionNV";
+    case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
+    case Op::OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
+    case Op::OpExecuteCallableNV: return "OpExecuteCallableNV";
+    case Op::OpRayQueryGetClusterIdNV: return "OpRayQueryGetClusterIdNV";
+    case Op::OpHitObjectGetClusterIdNV: return "OpHitObjectGetClusterIdNV";
+    case Op::OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
+    case Op::OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
+    case Op::OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
+    case Op::OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV";
+    case Op::OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
+    case Op::OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
+    case Op::OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
+    case Op::OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
+    case Op::OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
+    case Op::OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
+    case Op::OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
+    case Op::OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
+    case Op::OpTypeTensorViewNV: return "OpTypeTensorViewNV";
+    case Op::OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
+    case Op::OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
+    case Op::OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
+    case Op::OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
+    case Op::OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
+    case Op::OpCreateTensorViewNV: return "OpCreateTensorViewNV";
+    case Op::OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
+    case Op::OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
+    case Op::OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation";
+    case Op::OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
+    case Op::OpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
+    case Op::OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
+    case Op::OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
+    case Op::OpConvertUToImageNV: return "OpConvertUToImageNV";
+    case Op::OpConvertUToSamplerNV: return "OpConvertUToSamplerNV";
+    case Op::OpConvertImageToUNV: return "OpConvertImageToUNV";
+    case Op::OpConvertSamplerToUNV: return "OpConvertSamplerToUNV";
+    case Op::OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV";
+    case Op::OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV";
+    case Op::OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV";
+    case Op::OpRawAccessChainNV: return "OpRawAccessChainNV";
+    case Op::OpRayQueryGetIntersectionSpherePositionNV: return "OpRayQueryGetIntersectionSpherePositionNV";
+    case Op::OpRayQueryGetIntersectionSphereRadiusNV: return "OpRayQueryGetIntersectionSphereRadiusNV";
+    case Op::OpRayQueryGetIntersectionLSSPositionsNV: return "OpRayQueryGetIntersectionLSSPositionsNV";
+    case Op::OpRayQueryGetIntersectionLSSRadiiNV: return "OpRayQueryGetIntersectionLSSRadiiNV";
+    case Op::OpRayQueryGetIntersectionLSSHitValueNV: return "OpRayQueryGetIntersectionLSSHitValueNV";
+    case Op::OpHitObjectGetSpherePositionNV: return "OpHitObjectGetSpherePositionNV";
+    case Op::OpHitObjectGetSphereRadiusNV: return "OpHitObjectGetSphereRadiusNV";
+    case Op::OpHitObjectGetLSSPositionsNV: return "OpHitObjectGetLSSPositionsNV";
+    case Op::OpHitObjectGetLSSRadiiNV: return "OpHitObjectGetLSSRadiiNV";
+    case Op::OpHitObjectIsSphereHitNV: return "OpHitObjectIsSphereHitNV";
+    case Op::OpHitObjectIsLSSHitNV: return "OpHitObjectIsLSSHitNV";
+    case Op::OpRayQueryIsSphereHitNV: return "OpRayQueryIsSphereHitNV";
+    case Op::OpRayQueryIsLSSHitNV: return "OpRayQueryIsLSSHitNV";
+    case Op::OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL";
+    case Op::OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL";
+    case Op::OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL";
+    case Op::OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL";
+    case Op::OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL";
+    case Op::OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL";
+    case Op::OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL";
+    case Op::OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL";
+    case Op::OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL";
+    case Op::OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL";
+    case Op::OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL";
+    case Op::OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL";
+    case Op::OpAbsISubINTEL: return "OpAbsISubINTEL";
+    case Op::OpAbsUSubINTEL: return "OpAbsUSubINTEL";
+    case Op::OpIAddSatINTEL: return "OpIAddSatINTEL";
+    case Op::OpUAddSatINTEL: return "OpUAddSatINTEL";
+    case Op::OpIAverageINTEL: return "OpIAverageINTEL";
+    case Op::OpUAverageINTEL: return "OpUAverageINTEL";
+    case Op::OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL";
+    case Op::OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL";
+    case Op::OpISubSatINTEL: return "OpISubSatINTEL";
+    case Op::OpUSubSatINTEL: return "OpUSubSatINTEL";
+    case Op::OpIMul32x16INTEL: return "OpIMul32x16INTEL";
+    case Op::OpUMul32x16INTEL: return "OpUMul32x16INTEL";
+    case Op::OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL";
+    case Op::OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL";
+    case Op::OpAsmTargetINTEL: return "OpAsmTargetINTEL";
+    case Op::OpAsmINTEL: return "OpAsmINTEL";
+    case Op::OpAsmCallINTEL: return "OpAsmCallINTEL";
+    case Op::OpAtomicFMinEXT: return "OpAtomicFMinEXT";
+    case Op::OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
+    case Op::OpAssumeTrueKHR: return "OpAssumeTrueKHR";
+    case Op::OpExpectKHR: return "OpExpectKHR";
+    case Op::OpDecorateString: return "OpDecorateString";
+    case Op::OpMemberDecorateString: return "OpMemberDecorateString";
+    case Op::OpVmeImageINTEL: return "OpVmeImageINTEL";
+    case Op::OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL";
+    case Op::OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL";
+    case Op::OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL";
+    case Op::OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL";
+    case Op::OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL";
+    case Op::OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL";
+    case Op::OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL";
+    case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL";
+    case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL";
+    case Op::OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL";
+    case Op::OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL";
+    case Op::OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL";
+    case Op::OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL";
+    case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL";
+    case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL";
+    case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL";
+    case Op::OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL";
+    case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL";
+    case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL";
+    case Op::OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL";
+    case Op::OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL";
+    case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL";
+    case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL";
+    case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL";
+    case Op::OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL";
+    case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL";
+    case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL";
+    case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL";
+    case Op::OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL";
+    case Op::OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL";
+    case Op::OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL";
+    case Op::OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL";
+    case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL";
+    case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL";
+    case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL";
+    case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL";
+    case Op::OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL";
+    case Op::OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL";
+    case Op::OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL";
+    case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL";
+    case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL";
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL";
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL";
+    case Op::OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL";
+    case Op::OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL";
+    case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL";
+    case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL";
+    case Op::OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL";
+    case Op::OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL";
+    case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL";
+    case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL";
+    case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL";
+    case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL";
+    case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL";
+    case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL";
+    case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL";
+    case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL";
+    case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL";
+    case Op::OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL";
+    case Op::OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL";
+    case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL";
+    case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL";
+    case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL";
+    case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL";
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL";
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL";
+    case Op::OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL";
+    case Op::OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL";
+    case Op::OpSaveMemoryINTEL: return "OpSaveMemoryINTEL";
+    case Op::OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL";
+    case Op::OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL";
+    case Op::OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL";
+    case Op::OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL";
+    case Op::OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL";
+    case Op::OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL";
+    case Op::OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL";
+    case Op::OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL";
+    case Op::OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL";
+    case Op::OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL";
+    case Op::OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL";
+    case Op::OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL";
+    case Op::OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL";
+    case Op::OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL";
+    case Op::OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL";
+    case Op::OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL";
+    case Op::OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL";
+    case Op::OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL";
+    case Op::OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL";
+    case Op::OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL";
+    case Op::OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL";
+    case Op::OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL";
+    case Op::OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL";
+    case Op::OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL";
+    case Op::OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL";
+    case Op::OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL";
+    case Op::OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL";
+    case Op::OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL";
+    case Op::OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL";
+    case Op::OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL";
+    case Op::OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL";
+    case Op::OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL";
+    case Op::OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL";
+    case Op::OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL";
+    case Op::OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL";
+    case Op::OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL";
+    case Op::OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL";
+    case Op::OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL";
+    case Op::OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL";
+    case Op::OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL";
+    case Op::OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL";
+    case Op::OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL";
+    case Op::OpLoopControlINTEL: return "OpLoopControlINTEL";
+    case Op::OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL";
+    case Op::OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL";
+    case Op::OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL";
+    case Op::OpFixedSqrtINTEL: return "OpFixedSqrtINTEL";
+    case Op::OpFixedRecipINTEL: return "OpFixedRecipINTEL";
+    case Op::OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL";
+    case Op::OpFixedSinINTEL: return "OpFixedSinINTEL";
+    case Op::OpFixedCosINTEL: return "OpFixedCosINTEL";
+    case Op::OpFixedSinCosINTEL: return "OpFixedSinCosINTEL";
+    case Op::OpFixedSinPiINTEL: return "OpFixedSinPiINTEL";
+    case Op::OpFixedCosPiINTEL: return "OpFixedCosPiINTEL";
+    case Op::OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL";
+    case Op::OpFixedLogINTEL: return "OpFixedLogINTEL";
+    case Op::OpFixedExpINTEL: return "OpFixedExpINTEL";
+    case Op::OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL";
+    case Op::OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL";
+    case Op::OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL";
+    case Op::OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL";
+    case Op::OpFPGARegINTEL: return "OpFPGARegINTEL";
+    case Op::OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR";
+    case Op::OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR";
+    case Op::OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR";
+    case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
+    case Op::OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR";
+    case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
+    case Op::OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR";
+    case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
+    case Op::OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR";
+    case Op::OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR";
+    case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
+    case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
+    case Op::OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR";
+    case Op::OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR";
+    case Op::OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR";
+    case Op::OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR";
+    case Op::OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR";
+    case Op::OpAtomicFAddEXT: return "OpAtomicFAddEXT";
+    case Op::OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL";
+    case Op::OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL";
+    case Op::OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL";
+    case Op::OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL";
+    case Op::OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL";
+    case Op::OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL";
+    case Op::OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL";
+    case Op::OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL";
+    case Op::OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL";
+    case Op::OpArithmeticFenceEXT: return "OpArithmeticFenceEXT";
+    case Op::OpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL";
+    case Op::OpSubgroup2DBlockLoadINTEL: return "OpSubgroup2DBlockLoadINTEL";
+    case Op::OpSubgroup2DBlockLoadTransformINTEL: return "OpSubgroup2DBlockLoadTransformINTEL";
+    case Op::OpSubgroup2DBlockLoadTransposeINTEL: return "OpSubgroup2DBlockLoadTransposeINTEL";
+    case Op::OpSubgroup2DBlockPrefetchINTEL: return "OpSubgroup2DBlockPrefetchINTEL";
+    case Op::OpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL";
+    case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL";
+    case Op::OpGroupIMulKHR: return "OpGroupIMulKHR";
+    case Op::OpGroupFMulKHR: return "OpGroupFMulKHR";
+    case Op::OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";
+    case Op::OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR";
+    case Op::OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR";
+    case Op::OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR";
+    case Op::OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR";
+    case Op::OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR";
+    case Op::OpMaskedGatherINTEL: return "OpMaskedGatherINTEL";
+    case Op::OpMaskedScatterINTEL: return "OpMaskedScatterINTEL";
+    default: return "Unknown";
+    }
+}
+
+#endif /* SPV_ENABLE_UTILITY_CODE */
+
+// Overload bitwise operators for mask bit combining
+
+constexpr ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
+constexpr FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
+constexpr FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
+constexpr FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
+constexpr FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
+constexpr SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
+constexpr SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
+constexpr SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
+constexpr LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
+constexpr LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
+constexpr LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
+constexpr FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
+constexpr FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
+constexpr FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
+constexpr MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
+constexpr MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
+constexpr MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
+constexpr MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
+constexpr MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
+constexpr MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
+constexpr MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
+constexpr MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
+constexpr KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
+constexpr KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
+constexpr KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
+constexpr KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
+constexpr RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
+constexpr RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
+constexpr RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
+constexpr RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
+constexpr FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
+constexpr FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
+constexpr FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
+constexpr FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
+constexpr CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); }
+constexpr CooperativeMatrixReduceMask operator|(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) | unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator&(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) & unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator^(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) ^ unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator~(CooperativeMatrixReduceMask a) { return CooperativeMatrixReduceMask(~unsigned(a)); }
+constexpr TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator|(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator&(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator^(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator~(MatrixMultiplyAccumulateOperandsMask a) { return MatrixMultiplyAccumulateOperandsMask(~unsigned(a)); }
+constexpr RawAccessChainOperandsMask operator|(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator&(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator^(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator~(RawAccessChainOperandsMask a) { return RawAccessChainOperandsMask(~unsigned(a)); }
+
+}  // end namespace spv
+
+#endif  // #ifndef spirv_HPP
+

SPIRV/spvIR.h

@@ -47,7 +47,7 @@
 #ifndef spvIR_H
 #define spvIR_H
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 #include <algorithm>
 #include <cassert>
@@ -67,7 +67,7 @@ class Module;
 const Id NoResult = 0;
 const Id NoType = 0;
 
-const Decoration NoPrecision = DecorationMax;
+const Decoration NoPrecision = Decoration::Max;
 
 #ifdef __GNUC__
 #   define POTENTIALLY_UNUSED __attribute__((unused))
@@ -77,15 +77,19 @@ const Decoration NoPrecision = DecorationMax;
 
 POTENTIALLY_UNUSED
 const MemorySemanticsMask MemorySemanticsAllMemory =
-                (MemorySemanticsMask)(MemorySemanticsUniformMemoryMask |
-                                      MemorySemanticsWorkgroupMemoryMask |
-                                      MemorySemanticsAtomicCounterMemoryMask |
-                                      MemorySemanticsImageMemoryMask);
+                (MemorySemanticsMask)(MemorySemanticsMask::UniformMemory |
+                                      MemorySemanticsMask::WorkgroupMemory |
+                                      MemorySemanticsMask::AtomicCounterMemory | 
+                                      MemorySemanticsMask::ImageMemory);
 
 struct IdImmediate {
     bool isId;      // true if word is an Id, false if word is an immediate
     unsigned word;
     IdImmediate(bool i, unsigned w) : isId(i), word(w) {}
+    IdImmediate(bool i, spv::MemoryAccessMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::TensorAddressingOperandsMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::ImageOperandsMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::CooperativeMatrixOperandsMask w) : isId(i), word((unsigned)w) {}
 };
 
 //
@@ -119,6 +123,67 @@ public:
         operands.push_back(immediate);
         idOperand.push_back(false);
     }
+
+    void addImmediateOperand(spv::StorageClass immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::ExecutionMode immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::ExecutionModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Decoration immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::LinkageType immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::MemoryAccessMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Capability immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::AddressingModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::MemoryModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::FPEncoding immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::SourceLanguage immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Dim immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::FunctionControlMask immediate){
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::SelectionControlMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::LoopControlMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
     void setImmediateOperand(unsigned idx, unsigned int immediate) {
         assert(!idOperand[idx]);
         operands[idx] = immediate;
@@ -178,7 +243,7 @@ public:
         wordCount += (unsigned int)operands.size();
 
         // Write out the beginning of the instruction
-        out.push_back(((wordCount) << WordCountShift) | opCode);
+        out.push_back(((wordCount) << WordCountShift) | (unsigned)opCode);
         if (typeId)
             out.push_back(typeId);
         if (resultId)
@@ -190,10 +255,10 @@ public:
     }
 
     const char *getNameString() const {
-        if (opCode == OpString) {
+        if (opCode == Op::OpString) {
             return (const char *)&operands[0];
         } else {
-            assert(opCode == OpName);
+            assert(opCode == Op::OpName);
             return (const char *)&operands[1];
         }
     }
@@ -266,8 +331,8 @@ public:
         if (instructions.size() < 2) return nullptr;
         const Instruction* nextToLast = (instructions.cend() - 2)->get();
         switch (nextToLast->getOpCode()) {
-            case OpSelectionMerge:
-            case OpLoopMerge:
+            case Op::OpSelectionMerge:
+            case Op::OpLoopMerge:
                 return nextToLast;
             default:
                 return nullptr;
@@ -284,7 +349,7 @@ public:
         assert(instructions.size() > 0);
         instructions.resize(1);
         successors.clear();
-        addInstruction(std::unique_ptr<Instruction>(new Instruction(OpUnreachable)));
+        addInstruction(std::unique_ptr<Instruction>(new Instruction(Op::OpUnreachable)));
     }
     // Change this block into a canonical dead continue target branching to the
     // given header ID.  Delete instructions as necessary.  A canonical dead continue
@@ -298,7 +363,7 @@ public:
         successors.clear();
         // Add OpBranch back to the header.
         assert(header != nullptr);
-        Instruction* branch = new Instruction(OpBranch);
+        Instruction* branch = new Instruction(Op::OpBranch);
         branch->addIdOperand(header->getId());
         addInstruction(std::unique_ptr<Instruction>(branch));
         successors.push_back(header);
@@ -307,14 +372,14 @@ public:
     bool isTerminated() const
     {
         switch (instructions.back()->getOpCode()) {
-        case OpBranch:
-        case OpBranchConditional:
-        case OpSwitch:
-        case OpKill:
-        case OpTerminateInvocation:
-        case OpReturn:
-        case OpReturnValue:
-        case OpUnreachable:
+        case Op::OpBranch:
+        case Op::OpBranchConditional:
+        case Op::OpSwitch:
+        case Op::OpKill:
+        case Op::OpTerminateInvocation:
+        case Op::OpReturn:
+        case Op::OpReturnValue:
+        case Op::OpUnreachable:
             return true;
         default:
             return false;
@@ -411,14 +476,14 @@ public:
     Id getFuncTypeId() const { return functionInstruction.getIdOperand(1); }
     void setReturnPrecision(Decoration precision)
     {
-        if (precision == DecorationRelaxedPrecision)
+        if (precision == Decoration::RelaxedPrecision)
             reducedPrecisionReturn = true;
     }
     Decoration getReturnPrecision() const
-        { return reducedPrecisionReturn ? DecorationRelaxedPrecision : NoPrecision; }
+        { return reducedPrecisionReturn ? Decoration::RelaxedPrecision : NoPrecision; }
 
     void setDebugLineInfo(Id fileName, int line, int column) {
-        lineInstruction = std::unique_ptr<Instruction>{new Instruction(OpLine)};
+        lineInstruction = std::unique_ptr<Instruction>{new Instruction(Op::OpLine)};
         lineInstruction->reserveOperands(3);
         lineInstruction->addIdOperand(fileName);
         lineInstruction->addImmediateOperand(line);
@@ -431,13 +496,13 @@ public:
 
     void addParamPrecision(unsigned param, Decoration precision)
     {
-        if (precision == DecorationRelaxedPrecision)
+        if (precision == Decoration::RelaxedPrecision)
             reducedPrecisionParams.insert(param);
     }
     Decoration getParamPrecision(unsigned param) const
     {
         return reducedPrecisionParams.find(param) != reducedPrecisionParams.end() ?
-            DecorationRelaxedPrecision : NoPrecision;
+            Decoration::RelaxedPrecision : NoPrecision;
     }
 
     void dump(std::vector<unsigned int>& out) const
@@ -456,7 +521,7 @@ public:
 
         // Blocks
         inReadableOrder(blocks[0], [&out](const Block* b, ReachReason, Block*) { b->dump(out); });
-        Instruction end(0, 0, OpFunctionEnd);
+        Instruction end(0, 0, Op::OpFunctionEnd);
         end.dump(out);
     }
 
@@ -509,7 +574,7 @@ public:
     }
     StorageClass getStorageClass(Id typeId) const
     {
-        assert(idToInstruction[typeId]->getOpCode() == spv::OpTypePointer);
+        assert(idToInstruction[typeId]->getOpCode() == spv::Op::OpTypePointer);
         return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0);
     }
 
@@ -538,13 +603,13 @@ protected:
 // - all the OpFunctionParameter instructions
 __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, LinkageType linkage, const std::string& name, Module& parent)
     : parent(parent), lineInstruction(nullptr),
-      functionInstruction(id, resultType, OpFunction), implicitThis(false),
+      functionInstruction(id, resultType, Op::OpFunction), implicitThis(false),
       reducedPrecisionReturn(false),
       linkType(linkage)
 {
     // OpFunction
     functionInstruction.reserveOperands(2);
-    functionInstruction.addImmediateOperand(FunctionControlMaskNone);
+    functionInstruction.addImmediateOperand(FunctionControlMask::MaskNone);
     functionInstruction.addIdOperand(functionType);
     parent.mapInstruction(&functionInstruction);
     parent.addFunction(this);
@@ -553,13 +618,13 @@ __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParam
     Instruction* typeInst = parent.getInstruction(functionType);
     int numParams = typeInst->getNumOperands() - 1;
     for (int p = 0; p < numParams; ++p) {
-        Instruction* param = new Instruction(firstParamId + p, typeInst->getIdOperand(p + 1), OpFunctionParameter);
+        Instruction* param = new Instruction(firstParamId + p, typeInst->getIdOperand(p + 1), Op::OpFunctionParameter);
         parent.mapInstruction(param);
         parameterInstructions.push_back(param);
     }
 
     // If importing/exporting, save the function name (without the mangled parameters) for the linkage decoration
-    if (linkType != LinkageTypeMax) {
+    if (linkType != LinkageType::Max) {
         exportName = name.substr(0, name.find_first_of('('));
     }
 }
@@ -573,7 +638,7 @@ __inline void Function::addLocalVariable(std::unique_ptr<Instruction> inst)
 
 __inline Block::Block(Id id, Function& parent) : parent(parent), unreachable(false)
 {
-    instructions.push_back(std::unique_ptr<Instruction>(new Instruction(id, NoType, OpLabel)));
+    instructions.push_back(std::unique_ptr<Instruction>(new Instruction(id, NoType, Op::OpLabel)));
     instructions.back()->setBlock(this);
     parent.getParent().mapInstruction(instructions.back().get());
 }

SPIRV/spvUtil.h

@@ -0,0 +1,88 @@
+//
+// Copyright (C) 2025 Jan Kelemen
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//    Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+//
+//    Redistributions in binary form must reproduce the above
+//    copyright notice, this list of conditions and the following
+//    disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+//    contributors may be used to endorse or promote products derived
+//    from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+#pragma once
+#ifndef spvUtil_H
+#define spvUtil_H
+
+#include <cstdint>
+#include <type_traits>
+
+#include "spirv.hpp11"
+
+namespace spv {
+__inline uint32_t operator&(uint32_t value, spv::MemoryAccessMask mask) { return value & (unsigned)mask; }
+
+__inline bool operator==(uint32_t word, spv::FPEncoding encoding) { return word == (unsigned)encoding; }
+__inline bool operator!=(uint32_t word, spv::FPEncoding encoding) { return !(word == encoding); }
+
+__inline bool operator==(uint32_t word, spv::Decoration decoration) { return word == (unsigned)decoration; }
+__inline bool operator!=(uint32_t word, spv::Decoration decoration) { return !(word == decoration); }
+
+__inline bool operator==(uint32_t word, spv::Op op) { return word == (unsigned)op; }
+__inline bool operator!=(uint32_t word, spv::Op op) { return !(word == op); }
+
+__inline bool operator==(uint32_t word, spv::StorageClass storage) { return word == (unsigned)storage; }
+__inline bool operator!=(uint32_t word, spv::StorageClass storage) { return !(word == storage); }
+
+__inline bool anySet(spv::MemoryAccessMask value, spv::MemoryAccessMask mask)
+{
+    return (value & mask) != spv::MemoryAccessMask::MaskNone;
+}
+
+__inline bool anySet(spv::ImageOperandsMask value, spv::ImageOperandsMask mask)
+{
+    return (value & mask) != spv::ImageOperandsMask::MaskNone;
+}
+
+__inline bool anySet(spv::MemorySemanticsMask value, spv::MemorySemanticsMask mask)
+{
+    return (value & mask) != spv::MemorySemanticsMask::MaskNone;
+}
+
+__inline void addMask(uint32_t& word, spv::TensorAddressingOperandsMask mask) { word |= (unsigned)mask; }
+
+__inline void addMask(spv::CooperativeMatrixOperandsMask& word, spv::CooperativeMatrixOperandsMask mask)
+{
+    word = word | mask;
+}
+
+template<typename Enum, typename To = std::underlying_type_t<Enum>>
+__inline To enumCast(Enum value)
+{
+    return static_cast<To>(value);
+}
+}
+
+#endif // spvUtil_H

license-checker.cfg

@@ -37,7 +37,7 @@
                     "SPIRV/GLSL.*.h",
                     "SPIRV/NonSemanticDebugPrintf.h",
                     "SPIRV/NonSemanticShaderDebugInfo100.h",
-                    "SPIRV/spirv.hpp"
+                    "SPIRV/spirv.hpp11"
                 ]
             }
         ]