//
// Copyright (C) 2014-2015 LunarG, Inc.
// Copyright (C) 2022-2025 Arm Limited.
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
//
// 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.

//
// 1) Programmatically fill in instruction/operand information.
//    This can be used for disassembly, printing documentation, etc.
//
// 2) Print documentation from this parameterization.
//

#include "doc.h"
#include "spvUtil.h"

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <mutex>

namespace spv {
    extern "C" {
        // Include C-based headers that don't have a namespace
        #include "GLSL.ext.KHR.h"
        #include "GLSL.ext.EXT.h"
        #include "GLSL.ext.AMD.h"
        #include "GLSL.ext.NV.h"
        #include "GLSL.ext.ARM.h"
        #include "GLSL.ext.QCOM.h"
    }
}

namespace spv {

//
// Whole set of functions that translate enumerants to their text strings for
// the specification (or their sanitized versions for auto-generating the
// spirv headers.
//
// Also, for masks the ceilings are declared next to these, to help keep them in sync.
// Ceilings should be
//  - one more than the maximum value an enumerant takes on, for non-mask enumerants
//    (for non-sparse enums, this is the number of enumerants)
//  - the number of bits consumed by the set of masks
//    (for non-sparse mask enums, this is the number of enumerants)
//

const char* SourceString(int source)
{
    switch (source) {
    case 0:  return "Unknown";
    case 1:  return "ESSL";
    case 2:  return "GLSL";
    case 3:  return "OpenCL_C";
    case 4:  return "OpenCL_CPP";
    case 5:  return "HLSL";

    default: return "Bad";
    }
}

const char* ExecutionModelString(int model)
{
    switch (model) {
    case 0:  return "Vertex";
    case 1:  return "TessellationControl";
    case 2:  return "TessellationEvaluation";
    case 3:  return "Geometry";
    case 4:  return "Fragment";
    case 5:  return "GLCompute";
    case 6:  return "Kernel";
    case (int)ExecutionModel::TaskNV: return "TaskNV";
    case (int)ExecutionModel::MeshNV: return "MeshNV";
    case (int)ExecutionModel::TaskEXT: return "TaskEXT";
    case (int)ExecutionModel::MeshEXT: return "MeshEXT";

    default: return "Bad";

    case (int)ExecutionModel::RayGenerationKHR: return "RayGenerationKHR";
    case (int)ExecutionModel::IntersectionKHR:  return "IntersectionKHR";
    case (int)ExecutionModel::AnyHitKHR:        return "AnyHitKHR";
    case (int)ExecutionModel::ClosestHitKHR:    return "ClosestHitKHR";
    case (int)ExecutionModel::MissKHR:          return "MissKHR";
    case (int)ExecutionModel::CallableKHR:      return "CallableKHR";
    }
}

const char* AddressingString(int addr)
{
    switch (addr) {
    case 0:  return "Logical";
    case 1:  return "Physical32";
    case 2:  return "Physical64";

    case (int)AddressingModel::PhysicalStorageBuffer64EXT: return "PhysicalStorageBuffer64EXT";

    default: return "Bad";
    }
}

const char* MemoryString(int mem)
{
    switch (mem) {
    case (int)MemoryModel::Simple:     return "Simple";
    case (int)MemoryModel::GLSL450:    return "GLSL450";
    case (int)MemoryModel::OpenCL:     return "OpenCL";
    case (int)MemoryModel::VulkanKHR:  return "VulkanKHR";

    default: return "Bad";
    }
}

const int ExecutionModeCeiling = 40;

const char* ExecutionModeString(int mode)
{
    switch (mode) {
    case 0:  return "Invocations";
    case 1:  return "SpacingEqual";
    case 2:  return "SpacingFractionalEven";
    case 3:  return "SpacingFractionalOdd";
    case 4:  return "VertexOrderCw";
    case 5:  return "VertexOrderCcw";
    case 6:  return "PixelCenterInteger";
    case 7:  return "OriginUpperLeft";
    case 8:  return "OriginLowerLeft";
    case 9:  return "EarlyFragmentTests";
    case 10: return "PointMode";
    case 11: return "Xfb";
    case 12: return "DepthReplacing";
    case 13: return "Bad";
    case 14: return "DepthGreater";
    case 15: return "DepthLess";
    case 16: return "DepthUnchanged";
    case 17: return "LocalSize";
    case 18: return "LocalSizeHint";
    case 19: return "InputPoints";
    case 20: return "InputLines";
    case 21: return "InputLinesAdjacency";
    case 22: return "Triangles";
    case 23: return "InputTrianglesAdjacency";
    case 24: return "Quads";
    case 25: return "Isolines";
    case 26: return "OutputVertices";
    case 27: return "OutputPoints";
    case 28: return "OutputLineStrip";
    case 29: return "OutputTriangleStrip";
    case 30: return "VecTypeHint";
    case 31: return "ContractionOff";
    case 32: return "Bad";

    case (int)ExecutionMode::Initializer:                   return "Initializer";
    case (int)ExecutionMode::Finalizer:                     return "Finalizer";
    case (int)ExecutionMode::SubgroupSize:                  return "SubgroupSize";
    case (int)ExecutionMode::SubgroupsPerWorkgroup:         return "SubgroupsPerWorkgroup";
    case (int)ExecutionMode::SubgroupsPerWorkgroupId:       return "SubgroupsPerWorkgroupId";
    case (int)ExecutionMode::LocalSizeId:                   return "LocalSizeId";
    case (int)ExecutionMode::LocalSizeHintId:               return "LocalSizeHintId";

    case (int)ExecutionMode::PostDepthCoverage:             return "PostDepthCoverage";
    case (int)ExecutionMode::DenormPreserve:                return "DenormPreserve";
    case (int)ExecutionMode::DenormFlushToZero:             return "DenormFlushToZero";
    case (int)ExecutionMode::SignedZeroInfNanPreserve:      return "SignedZeroInfNanPreserve";
    case (int)ExecutionMode::RoundingModeRTE:               return "RoundingModeRTE";
    case (int)ExecutionMode::RoundingModeRTZ:               return "RoundingModeRTZ";

    case (int)ExecutionMode::NonCoherentTileAttachmentReadQCOM: return "NonCoherentTileAttachmentReadQCOM";
    case (int)ExecutionMode::TileShadingRateQCOM:               return "TileShadingRateQCOM";

    case (int)ExecutionMode::EarlyAndLateFragmentTestsAMD:  return "EarlyAndLateFragmentTestsAMD";
    case (int)ExecutionMode::StencilRefUnchangedFrontAMD:   return "StencilRefUnchangedFrontAMD";
    case (int)ExecutionMode::StencilRefLessFrontAMD:        return "StencilRefLessFrontAMD";
    case (int)ExecutionMode::StencilRefGreaterBackAMD:      return "StencilRefGreaterBackAMD";
    case (int)ExecutionMode::StencilRefReplacingEXT:        return "StencilRefReplacingEXT";
    case (int)ExecutionMode::SubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
    case (int)ExecutionMode::MaximallyReconvergesKHR:       return "MaximallyReconverges";

    case (int)ExecutionMode::OutputLinesNV:                 return "OutputLinesNV";
    case (int)ExecutionMode::OutputPrimitivesNV:            return "OutputPrimitivesNV";
    case (int)ExecutionMode::OutputTrianglesNV:             return "OutputTrianglesNV";

    // DerivativeGroupQuadsKHR is an alias of DerivativeGroupQuadsNV
    case (int)ExecutionMode::DerivativeGroupQuadsKHR:       return "DerivativeGroupQuadsKHR";
    // DerivativeGroupLinearKHR is an alias of DerivativeGroupLinearNV
    case (int)ExecutionMode::DerivativeGroupLinearKHR:      return "DerivativeGroupLinearKHR";

    case (int)ExecutionMode::PixelInterlockOrderedEXT:         return "PixelInterlockOrderedEXT";
    case (int)ExecutionMode::PixelInterlockUnorderedEXT:       return "PixelInterlockUnorderedEXT";
    case (int)ExecutionMode::SampleInterlockOrderedEXT:        return "SampleInterlockOrderedEXT";
    case (int)ExecutionMode::SampleInterlockUnorderedEXT:      return "SampleInterlockUnorderedEXT";
    case (int)ExecutionMode::ShadingRateInterlockOrderedEXT:   return "ShadingRateInterlockOrderedEXT";
    case (int)ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";

    case (int)ExecutionMode::MaxWorkgroupSizeINTEL:    return "MaxWorkgroupSizeINTEL";
    case (int)ExecutionMode::MaxWorkDimINTEL:          return "MaxWorkDimINTEL";
    case (int)ExecutionMode::NoGlobalOffsetINTEL:      return "NoGlobalOffsetINTEL";
    case (int)ExecutionMode::NumSIMDWorkitemsINTEL:    return "NumSIMDWorkitemsINTEL";

    case (int)ExecutionMode::RequireFullQuadsKHR:      return "RequireFullQuadsKHR";
    case (int)ExecutionMode::QuadDerivativesKHR:       return "QuadDerivativesKHR";

    case (int)ExecutionMode::NonCoherentColorAttachmentReadEXT:        return "NonCoherentColorAttachmentReadEXT";
    case (int)ExecutionMode::NonCoherentDepthAttachmentReadEXT:        return "NonCoherentDepthAttachmentReadEXT";
    case (int)ExecutionMode::NonCoherentStencilAttachmentReadEXT:      return "NonCoherentStencilAttachmentReadEXT";

    case (int)ExecutionMode::Shader64BitIndexingEXT:                   return "Shader64BitIndexingEXT";

    case (int)ExecutionMode::OpacityMicromapIdKHR:                     return "OpacityMicromapIdKHR";

    case ExecutionModeCeiling:
    default: return "Bad";
    }
}

const char* StorageClassString(int StorageClass)
{
    switch (StorageClass) {
    case 0:  return "UniformConstant";
    case 1:  return "Input";
    case 2:  return "Uniform";
    case 3:  return "Output";
    case 4:  return "Workgroup";
    case 5:  return "CrossWorkgroup";
    case 6:  return "Private";
    case 7:  return "Function";
    case 8:  return "Generic";
    case 9:  return "PushConstant";
    case 10: return "AtomicCounter";
    case 11: return "Image";
    case 12: return "StorageBuffer";

    case (int)StorageClass::TileAttachmentQCOM:       return "TileAttachmentQCOM";
    case (int)StorageClass::RayPayloadKHR:            return "RayPayloadKHR";
    case (int)StorageClass::HitAttributeKHR:          return "HitAttributeKHR";
    case (int)StorageClass::IncomingRayPayloadKHR:    return "IncomingRayPayloadKHR";
    case (int)StorageClass::ShaderRecordBufferKHR:    return "ShaderRecordBufferKHR";
    case (int)StorageClass::CallableDataKHR:          return "CallableDataKHR";
    case (int)StorageClass::IncomingCallableDataKHR:  return "IncomingCallableDataKHR";

    case (int)StorageClass::PhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
    case (int)StorageClass::TaskPayloadWorkgroupEXT:  return "TaskPayloadWorkgroupEXT";
    case (int)StorageClass::HitObjectAttributeNV:     return "HitObjectAttributeNV";
    case (int)StorageClass::TileImageEXT:             return "TileImageEXT";
    case (int)StorageClass::HitObjectAttributeEXT:    return "HitObjectAttributeEXT";
    default: return "Bad";
    }
}

const int DecorationCeiling = 45;

const char* DecorationString(int decoration)
{
    switch (decoration) {
    case 0:  return "RelaxedPrecision";
    case 1:  return "SpecId";
    case 2:  return "Block";
    case 3:  return "BufferBlock";
    case 4:  return "RowMajor";
    case 5:  return "ColMajor";
    case 6:  return "ArrayStride";
    case 7:  return "MatrixStride";
    case 8:  return "GLSLShared";
    case 9:  return "GLSLPacked";
    case 10: return "CPacked";
    case 11: return "BuiltIn";
    case 12: return "Bad";
    case 13: return "NoPerspective";
    case 14: return "Flat";
    case 15: return "Patch";
    case 16: return "Centroid";
    case 17: return "Sample";
    case 18: return "Invariant";
    case 19: return "Restrict";
    case 20: return "Aliased";
    case 21: return "Volatile";
    case 22: return "Constant";
    case 23: return "Coherent";
    case 24: return "NonWritable";
    case 25: return "NonReadable";
    case 26: return "Uniform";
    case 27: return "Bad";
    case 28: return "SaturatedConversion";
    case 29: return "Stream";
    case 30: return "Location";
    case 31: return "Component";
    case 32: return "Index";
    case 33: return "Binding";
    case 34: return "DescriptorSet";
    case 35: return "Offset";
    case 36: return "XfbBuffer";
    case 37: return "XfbStride";
    case 38: return "FuncParamAttr";
    case 39: return "FP Rounding Mode";
    case 40: return "FP Fast Math Mode";
    case 41: return "Linkage Attributes";
    case 42: return "NoContraction";
    case 43: return "InputAttachmentIndex";
    case 44: return "Alignment";

    case DecorationCeiling:
    default:  return "Bad";

    case (int)Decoration::WeightTextureQCOM:           return "DecorationWeightTextureQCOM";
    case (int)Decoration::BlockMatchTextureQCOM:       return "DecorationBlockMatchTextureQCOM";
    case (int)Decoration::BlockMatchSamplerQCOM:       return "DecorationBlockMatchSamplerQCOM";
    case (int)Decoration::ExplicitInterpAMD:           return "ExplicitInterpAMD";
    case (int)Decoration::OverrideCoverageNV:          return "OverrideCoverageNV";
    case (int)Decoration::PassthroughNV:               return "PassthroughNV";
    case (int)Decoration::ViewportRelativeNV:          return "ViewportRelativeNV";
    case (int)Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
    case (int)Decoration::PerPrimitiveNV:              return "PerPrimitiveNV";
    case (int)Decoration::PerViewNV:                   return "PerViewNV";
    case (int)Decoration::PerTaskNV:                   return "PerTaskNV";

    case (int)Decoration::PerVertexKHR:                return "PerVertexKHR";

    case (int)Decoration::NonUniformEXT:           return "DecorationNonUniformEXT";
    case (int)Decoration::HlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
    case (int)Decoration::HlslSemanticGOOGLE:      return "DecorationHlslSemanticGOOGLE";
    case (int)Decoration::RestrictPointerEXT:      return "DecorationRestrictPointerEXT";
    case (int)Decoration::AliasedPointerEXT:       return "DecorationAliasedPointerEXT";

    case (int)Decoration::HitObjectShaderRecordBufferNV:  return "DecorationHitObjectShaderRecordBufferNV";
    case (int)Decoration::HitObjectShaderRecordBufferEXT:  return "DecorationHitObjectShaderRecordBufferEXT";

    case (int)Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "DecorationSaturatedToLargestFloat8NormalConversionEXT";

    case (int)Decoration::BankNV:                        return "BankNV";
    case (int)Decoration::MemberOffsetNV:                return "MemberOffsetNV";

    case (int)Decoration::ArrayStrideIdEXT:        return "ArrayStrideIdEXT";
    case (int)Decoration::OffsetIdEXT:             return "OffsetIdEXT";
    case (int)Decoration::UTFEncodedKHR:           return "UTFEncodedKHR";
    }
}

const char* BuiltInString(int builtIn)
{
    switch (builtIn) {
    case 0:  return "Position";
    case 1:  return "PointSize";
    case 2:  return "Bad";
    case 3:  return "ClipDistance";
    case 4:  return "CullDistance";
    case 5:  return "VertexId";
    case 6:  return "InstanceId";
    case 7:  return "PrimitiveId";
    case 8:  return "InvocationId";
    case 9:  return "Layer";
    case 10: return "ViewportIndex";
    case 11: return "TessLevelOuter";
    case 12: return "TessLevelInner";
    case 13: return "TessCoord";
    case 14: return "PatchVertices";
    case 15: return "FragCoord";
    case 16: return "PointCoord";
    case 17: return "FrontFacing";
    case 18: return "SampleId";
    case 19: return "SamplePosition";
    case 20: return "SampleMask";
    case 21: return "Bad";
    case 22: return "FragDepth";
    case 23: return "HelperInvocation";
    case 24: return "NumWorkgroups";
    case 25: return "WorkgroupSize";
    case 26: return "WorkgroupId";
    case 27: return "LocalInvocationId";
    case 28: return "GlobalInvocationId";
    case 29: return "LocalInvocationIndex";
    case 30: return "WorkDim";
    case 31: return "GlobalSize";
    case 32: return "EnqueuedWorkgroupSize";
    case 33: return "GlobalOffset";
    case 34: return "GlobalLinearId";
    case 35: return "Bad";
    case 36: return "SubgroupSize";
    case 37: return "SubgroupMaxSize";
    case 38: return "NumSubgroups";
    case 39: return "NumEnqueuedSubgroups";
    case 40: return "SubgroupId";
    case 41: return "SubgroupLocalInvocationId";
    case 42: return "VertexIndex";                 // TBD: put next to VertexId?
    case 43: return "InstanceIndex";               // TBD: put next to InstanceId?

    case 4416: return "SubgroupEqMaskKHR";
    case 4417: return "SubgroupGeMaskKHR";
    case 4418: return "SubgroupGtMaskKHR";
    case 4419: return "SubgroupLeMaskKHR";
    case 4420: return "SubgroupLtMaskKHR";
    case 4438: return "DeviceIndex";
    case 4440: return "ViewIndex";
    case 4424: return "BaseVertex";
    case 4425: return "BaseInstance";
    case 4426: return "DrawIndex";
    case 4432: return "PrimitiveShadingRateKHR";
    case 4444: return "ShadingRateKHR";
    case 5014: return "FragStencilRefEXT";

    case (int)BuiltIn::TileOffsetQCOM:     return "TileOffsetQCOM";
    case (int)BuiltIn::TileDimensionQCOM:  return "TileDimensionQCOM";
    case (int)BuiltIn::TileApronSizeQCOM:  return "TileApronSizeQCOM";

    case 4992: return "BaryCoordNoPerspAMD";
    case 4993: return "BaryCoordNoPerspCentroidAMD";
    case 4994: return "BaryCoordNoPerspSampleAMD";
    case 4995: return "BaryCoordSmoothAMD";
    case 4996: return "BaryCoordSmoothCentroidAMD";
    case 4997: return "BaryCoordSmoothSampleAMD";
    case 4998: return "BaryCoordPullModelAMD";
    case (int)BuiltIn::LaunchIdKHR:                 return "LaunchIdKHR";
    case (int)BuiltIn::LaunchSizeKHR:               return "LaunchSizeKHR";
    case (int)BuiltIn::WorldRayOriginKHR:           return "WorldRayOriginKHR";
    case (int)BuiltIn::WorldRayDirectionKHR:        return "WorldRayDirectionKHR";
    case (int)BuiltIn::ObjectRayOriginKHR:          return "ObjectRayOriginKHR";
    case (int)BuiltIn::ObjectRayDirectionKHR:       return "ObjectRayDirectionKHR";
    case (int)BuiltIn::RayTminKHR:                  return "RayTminKHR";
    case (int)BuiltIn::RayTmaxKHR:                  return "RayTmaxKHR";
    case (int)BuiltIn::CullMaskKHR:                 return "CullMaskKHR";
    case (int)BuiltIn::HitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
    case (int)BuiltIn::HitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
    case (int)BuiltIn::HitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
    case (int)BuiltIn::HitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
    case (int)BuiltIn::HitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
    case (int)BuiltIn::HitIsSphereNV:               return "HitIsSphereNV";
    case (int)BuiltIn::HitIsLSSNV:                  return "HitIsLSSNV";
    case (int)BuiltIn::HitSpherePositionNV:         return "HitSpherePositionNV";
    case (int)BuiltIn::HitSphereRadiusNV:           return "HitSphereRadiusNV";
    case (int)BuiltIn::HitLSSPositionsNV:           return "HitLSSPositionsNV";
    case (int)BuiltIn::HitLSSRadiiNV:               return "HitLLSSRadiiNV";
    case (int)BuiltIn::InstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
    case (int)BuiltIn::RayGeometryIndexKHR:         return "RayGeometryIndexKHR";
    case (int)BuiltIn::ObjectToWorldKHR:            return "ObjectToWorldKHR";
    case (int)BuiltIn::WorldToObjectKHR:            return "WorldToObjectKHR";
    case (int)BuiltIn::HitTNV:                      return "HitTNV";
    case (int)BuiltIn::HitKindKHR:                  return "HitKindKHR";
    case (int)BuiltIn::IncomingRayFlagsKHR:         return "IncomingRayFlagsKHR";
    case (int)BuiltIn::ViewportMaskNV:              return "ViewportMaskNV";
    case (int)BuiltIn::SecondaryPositionNV:         return "SecondaryPositionNV";
    case (int)BuiltIn::SecondaryViewportMaskNV:     return "SecondaryViewportMaskNV";
    case (int)BuiltIn::PositionPerViewNV:           return "PositionPerViewNV";
    case (int)BuiltIn::ViewportMaskPerViewNV:       return "ViewportMaskPerViewNV";
//    case (int)BuiltIn::FragmentSizeNV:             return "FragmentSizeNV";        // superseded by BuiltInFragSizeEXT
//    case (int)BuiltIn::InvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
    case (int)BuiltIn::BaryCoordKHR:                return "BaryCoordKHR";
    case (int)BuiltIn::BaryCoordNoPerspKHR:         return "BaryCoordNoPerspKHR";
    case (int)BuiltIn::ClusterIDNV:                 return "ClusterIDNV";

    case (int)BuiltIn::FragSizeEXT:                 return "FragSizeEXT";
    case (int)BuiltIn::FragInvocationCountEXT:      return "FragInvocationCountEXT";

    case 5264: return "FullyCoveredEXT";

    case (int)BuiltIn::TaskCountNV:           return "TaskCountNV";
    case (int)BuiltIn::PrimitiveCountNV:      return "PrimitiveCountNV";
    case (int)BuiltIn::PrimitiveIndicesNV:    return "PrimitiveIndicesNV";
    case (int)BuiltIn::ClipDistancePerViewNV: return "ClipDistancePerViewNV";
    case (int)BuiltIn::CullDistancePerViewNV: return "CullDistancePerViewNV";
    case (int)BuiltIn::LayerPerViewNV:        return "LayerPerViewNV";
    case (int)BuiltIn::MeshViewCountNV:       return "MeshViewCountNV";
    case (int)BuiltIn::MeshViewIndicesNV:     return "MeshViewIndicesNV";
    case (int)BuiltIn::WarpsPerSMNV:           return "WarpsPerSMNV";
    case (int)BuiltIn::SMCountNV:              return "SMCountNV";
    case (int)BuiltIn::WarpIDNV:               return "WarpIDNV";
    case (int)BuiltIn::SMIDNV:                 return "SMIDNV";
    case (int)BuiltIn::CurrentRayTimeNV:       return "CurrentRayTimeNV";
    case (int)BuiltIn::PrimitivePointIndicesEXT:        return "PrimitivePointIndicesEXT";
    case (int)BuiltIn::PrimitiveLineIndicesEXT:         return "PrimitiveLineIndicesEXT";
    case (int)BuiltIn::PrimitiveTriangleIndicesEXT:     return "PrimitiveTriangleIndicesEXT";
    case (int)BuiltIn::CullPrimitiveEXT:                return "CullPrimitiveEXT";
    case (int)BuiltIn::CoreCountARM:           return "CoreCountARM";
    case (int)BuiltIn::CoreIDARM:              return "CoreIDARM";
    case (int)BuiltIn::CoreMaxIDARM:           return "CoreMaxIDARM";
    case (int)BuiltIn::WarpIDARM:              return "WarpIDARM";
    case (int)BuiltIn::WarpMaxIDARM:           return "BuiltInWarpMaxIDARM";
    case (int)BuiltIn::SamplerHeapEXT:         return "SamplerHeapEXT";
    case (int)BuiltIn::ResourceHeapEXT:        return "ResourceHeapEXT";

    default: return "Bad";
    }
}

const char* DimensionString(int dim)
{
    switch (dim) {
    case 0:  return "1D";
    case 1:  return "2D";
    case 2:  return "3D";
    case 3:  return "Cube";
    case 4:  return "Rect";
    case 5:  return "Buffer";
    case 6:  return "SubpassData";
    case (int)Dim::TileImageDataEXT:  return "TileImageDataEXT";

    default: return "Bad";
    }
}

const char* SamplerAddressingModeString(int mode)
{
    switch (mode) {
    case 0:  return "None";
    case 1:  return "ClampToEdge";
    case 2:  return "Clamp";
    case 3:  return "Repeat";
    case 4:  return "RepeatMirrored";

    default: return "Bad";
    }
}

const char* SamplerFilterModeString(int mode)
{
    switch (mode) {
    case 0: return "Nearest";
    case 1: return "Linear";

    default: return "Bad";
    }
}

const char* ImageFormatString(int format)
{
    switch (format) {
    case  0: return "Unknown";

    // ES/Desktop float
    case  1: return "Rgba32f";
    case  2: return "Rgba16f";
    case  3: return "R32f";
    case  4: return "Rgba8";
    case  5: return "Rgba8Snorm";

    // Desktop float
    case  6: return "Rg32f";
    case  7: return "Rg16f";
    case  8: return "R11fG11fB10f";
    case  9: return "R16f";
    case 10: return "Rgba16";
    case 11: return "Rgb10A2";
    case 12: return "Rg16";
    case 13: return "Rg8";
    case 14: return "R16";
    case 15: return "R8";
    case 16: return "Rgba16Snorm";
    case 17: return "Rg16Snorm";
    case 18: return "Rg8Snorm";
    case 19: return "R16Snorm";
    case 20: return "R8Snorm";

    // ES/Desktop int
    case 21: return "Rgba32i";
    case 22: return "Rgba16i";
    case 23: return "Rgba8i";
    case 24: return "R32i";

    // Desktop int
    case 25: return "Rg32i";
    case 26: return "Rg16i";
    case 27: return "Rg8i";
    case 28: return "R16i";
    case 29: return "R8i";

    // ES/Desktop uint
    case 30: return "Rgba32ui";
    case 31: return "Rgba16ui";
    case 32: return "Rgba8ui";
    case 33: return "R32ui";

    // Desktop uint
    case 34: return "Rgb10a2ui";
    case 35: return "Rg32ui";
    case 36: return "Rg16ui";
    case 37: return "Rg8ui";
    case 38: return "R16ui";
    case 39: return "R8ui";
    case 40: return "R64ui";
    case 41: return "R64i";

    default:
        return "Bad";
    }
}

const char* ImageChannelOrderString(int format)
{
    switch (format) {
    case 0:  return "R";
    case 1:  return "A";
    case 2:  return "RG";
    case 3:  return "RA";
    case 4:  return "RGB";
    case 5:  return "RGBA";
    case 6:  return "BGRA";
    case 7:  return "ARGB";
    case 8:  return "Intensity";
    case 9:  return "Luminance";
    case 10: return "Rx";
    case 11: return "RGx";
    case 12: return "RGBx";
    case 13: return "Depth";
    case 14: return "DepthStencil";
    case 15: return "sRGB";
    case 16: return "sRGBx";
    case 17: return "sRGBA";
    case 18: return "sBGRA";

    default:
        return "Bad";
    }
}

const char* ImageChannelDataTypeString(int type)
{
    switch (type)
    {
    case 0: return "SnormInt8";
    case 1: return "SnormInt16";
    case 2: return "UnormInt8";
    case 3: return "UnormInt16";
    case 4: return "UnormShort565";
    case 5: return "UnormShort555";
    case 6: return "UnormInt101010";
    case 7: return "SignedInt8";
    case 8: return "SignedInt16";
    case 9: return "SignedInt32";
    case 10: return "UnsignedInt8";
    case 11: return "UnsignedInt16";
    case 12: return "UnsignedInt32";
    case 13: return "HalfFloat";
    case 14: return "Float";
    case 15: return "UnormInt24";
    case 16: return "UnormInt101010_2";

    default:
        return "Bad";
    }
}

const int ImageOperandsCeiling = 17;

const char* ImageOperandsString(int format)
{
    switch (format) {
    case (int)ImageOperandsShift::Bias:                    return "Bias";
    case (int)ImageOperandsShift::Lod:                     return "Lod";
    case (int)ImageOperandsShift::Grad:                    return "Grad";
    case (int)ImageOperandsShift::ConstOffset:             return "ConstOffset";
    case (int)ImageOperandsShift::Offset:                  return "Offset";
    case (int)ImageOperandsShift::ConstOffsets:            return "ConstOffsets";
    case (int)ImageOperandsShift::Sample:                  return "Sample";
    case (int)ImageOperandsShift::MinLod:                  return "MinLod";
    case (int)ImageOperandsShift::MakeTexelAvailableKHR:   return "MakeTexelAvailableKHR";
    case (int)ImageOperandsShift::MakeTexelVisibleKHR:     return "MakeTexelVisibleKHR";
    case (int)ImageOperandsShift::NonPrivateTexelKHR:      return "NonPrivateTexelKHR";
    case (int)ImageOperandsShift::VolatileTexelKHR:        return "VolatileTexelKHR";
    case (int)ImageOperandsShift::SignExtend:              return "SignExtend";
    case (int)ImageOperandsShift::ZeroExtend:              return "ZeroExtend";
    case (int)ImageOperandsShift::Nontemporal:             return "Nontemporal";
    case (int)ImageOperandsShift::Offsets:                 return "Offsets";

    case ImageOperandsCeiling:
    default:
        return "Bad";
    }
}

const char* FPFastMathString(int mode)
{
    switch (mode) {
    case 0: return "NotNaN";
    case 1: return "NotInf";
    case 2: return "NSZ";
    case 3: return "AllowRecip";
    case 4: return "Fast";

    default:     return "Bad";
    }
}

const char* FPRoundingModeString(int mode)
{
    switch (mode) {
    case 0:  return "RTE";
    case 1:  return "RTZ";
    case 2:  return "RTP";
    case 3:  return "RTN";

    default: return "Bad";
    }
}

const char* LinkageTypeString(int type)
{
    switch (type) {
    case 0:  return "Export";
    case 1:  return "Import";

    default: return "Bad";
    }
}

const char* FuncParamAttrString(int attr)
{
    switch (attr) {
    case 0:  return "Zext";
    case 1:  return "Sext";
    case 2:  return "ByVal";
    case 3:  return "Sret";
    case 4:  return "NoAlias";
    case 5:  return "NoCapture";
    case 6:  return "NoWrite";
    case 7:  return "NoReadWrite";

    default: return "Bad";
    }
}

const char* AccessQualifierString(int attr)
{
    switch (attr) {
    case 0:  return "ReadOnly";
    case 1:  return "WriteOnly";
    case 2:  return "ReadWrite";

    default: return "Bad";
    }
}

const int SelectControlCeiling = 2;

const char* SelectControlString(int cont)
{
    switch (cont) {
    case 0:  return "Flatten";
    case 1:  return "DontFlatten";

    case SelectControlCeiling:
    default: return "Bad";
    }
}

const int LoopControlCeiling = (int)LoopControlShift::PartialCount + 1;

const char* LoopControlString(int cont)
{
    switch (cont) {
    case (int)LoopControlShift::Unroll:             return "Unroll";
    case (int)LoopControlShift::DontUnroll:         return "DontUnroll";
    case (int)LoopControlShift::DependencyInfinite: return "DependencyInfinite";
    case (int)LoopControlShift::DependencyLength:   return "DependencyLength";
    case (int)LoopControlShift::MinIterations:      return "MinIterations";
    case (int)LoopControlShift::MaxIterations:      return "MaxIterations";
    case (int)LoopControlShift::IterationMultiple:  return "IterationMultiple";
    case (int)LoopControlShift::PeelCount:          return "PeelCount";
    case (int)LoopControlShift::PartialCount:       return "PartialCount";

    case LoopControlCeiling:
    default: return "Bad";
    }
}

const int FunctionControlCeiling = 4;

const char* FunctionControlString(int cont)
{
    switch (cont) {
    case 0:  return "Inline";
    case 1:  return "DontInline";
    case 2:  return "Pure";
    case 3:  return "Const";

    case FunctionControlCeiling:
    default: return "Bad";
    }
}

const char* MemorySemanticsString(int mem)
{
    // Note: No bits set (None) means "Relaxed"
    switch (mem) {
    case 0: return "Bad"; // Note: this is a placeholder for 'Consume'
    case 1: return "Acquire";
    case 2: return "Release";
    case 3: return "AcquireRelease";
    case 4: return "SequentiallyConsistent";
    case 5: return "Bad"; // Note: reserved for future expansion
    case 6: return "UniformMemory";
    case 7: return "SubgroupMemory";
    case 8: return "WorkgroupMemory";
    case 9: return "CrossWorkgroupMemory";
    case 10: return "AtomicCounterMemory";
    case 11: return "ImageMemory";

    default:     return "Bad";
    }
}

const int MemoryAccessCeiling = 6;

const char* MemoryAccessString(int mem)
{
    switch (mem) {
    case (int)MemoryAccessShift::Volatile:                 return "Volatile";
    case (int)MemoryAccessShift::Aligned:                  return "Aligned";
    case (int)MemoryAccessShift::Nontemporal:              return "Nontemporal";
    case (int)MemoryAccessShift::MakePointerAvailableKHR:  return "MakePointerAvailableKHR";
    case (int)MemoryAccessShift::MakePointerVisibleKHR:    return "MakePointerVisibleKHR";
    case (int)MemoryAccessShift::NonPrivatePointerKHR:     return "NonPrivatePointerKHR";

    default: return "Bad";
    }
}

const int CooperativeMatrixOperandsCeiling = 6;

const char* CooperativeMatrixOperandsString(int op)
{
    switch (op) {
    case (int)CooperativeMatrixOperandsShift::MatrixASignedComponentsKHR:  return "ASignedComponentsKHR";
    case (int)CooperativeMatrixOperandsShift::MatrixBSignedComponentsKHR:  return "BSignedComponentsKHR";
    case (int)CooperativeMatrixOperandsShift::MatrixCSignedComponentsKHR:  return "CSignedComponentsKHR";
    case (int)CooperativeMatrixOperandsShift::MatrixResultSignedComponentsKHR:  return "ResultSignedComponentsKHR";
    case (int)CooperativeMatrixOperandsShift::SaturatingAccumulationKHR:   return "SaturatingAccumulationKHR";

    default: return "Bad";
    }
}

const int TensorAddressingOperandsCeiling = 4;

const char* TensorAddressingOperandsString(int op)
{
    switch (op) {
    case (int)TensorAddressingOperandsShift::TensorView:        return "TensorView";
    case (int)TensorAddressingOperandsShift::DecodeFunc:        return "DecodeFunc";
    case (int)TensorAddressingOperandsShift::DecodeVectorFunc:  return "DecodeVectorFunc";

    default: return "Bad";
    }
}

const char* ScopeString(int mem)
{
    switch (mem) {
    case 0:  return "CrossDevice";
    case 1:  return "Device";
    case 2:  return "Workgroup";
    case 3:  return "Subgroup";
    case 4:  return "Invocation";

    default: return "Bad";
    }
}

const char* GroupOperationString(int gop)
{

    switch (gop)
    {
    case (int)GroupOperation::Reduce:  return "Reduce";
    case (int)GroupOperation::InclusiveScan:  return "InclusiveScan";
    case (int)GroupOperation::ExclusiveScan:  return "ExclusiveScan";
    case (int)GroupOperation::ClusteredReduce:  return "ClusteredReduce";
    case (int)GroupOperation::PartitionedReduceNV:  return "PartitionedReduceNV";
    case (int)GroupOperation::PartitionedInclusiveScanNV:  return "PartitionedInclusiveScanNV";
    case (int)GroupOperation::PartitionedExclusiveScanNV:  return "PartitionedExclusiveScanNV";

    default: return "Bad";
    }
}

const char* KernelEnqueueFlagsString(int flag)
{
    switch (flag)
    {
    case 0:  return "NoWait";
    case 1:  return "WaitKernel";
    case 2:  return "WaitWorkGroup";

    default: return "Bad";
    }
}

const char* KernelProfilingInfoString(int info)
{
    switch (info)
    {
    case 0:  return "CmdExecTime";

    default: return "Bad";
    }
}

const char* CapabilityString(int info)
{
    switch (info)
    {
    case 0:  return "Matrix";
    case 1:  return "Shader";
    case 2:  return "Geometry";
    case 3:  return "Tessellation";
    case 4:  return "Addresses";
    case 5:  return "Linkage";
    case 6:  return "Kernel";
    case 7:  return "Vector16";
    case 8:  return "Float16Buffer";
    case 9:  return "Float16";
    case 10: return "Float64";
    case 11: return "Int64";
    case 12: return "Int64Atomics";
    case 13: return "ImageBasic";
    case 14: return "ImageReadWrite";
    case 15: return "ImageMipmap";
    case 16: return "Bad";
    case 17: return "Pipes";
    case 18: return "Groups";
    case 19: return "DeviceEnqueue";
    case 20: return "LiteralSampler";
    case 21: return "AtomicStorage";
    case 22: return "Int16";
    case 23: return "TessellationPointSize";
    case 24: return "GeometryPointSize";
    case 25: return "ImageGatherExtended";
    case 26: return "Bad";
    case 27: return "StorageImageMultisample";
    case 28: return "UniformBufferArrayDynamicIndexing";
    case 29: return "SampledImageArrayDynamicIndexing";
    case 30: return "StorageBufferArrayDynamicIndexing";
    case 31: return "StorageImageArrayDynamicIndexing";
    case 32: return "ClipDistance";
    case 33: return "CullDistance";
    case 34: return "ImageCubeArray";
    case 35: return "SampleRateShading";
    case 36: return "ImageRect";
    case 37: return "SampledRect";
    case 38: return "GenericPointer";
    case 39: return "Int8";
    case 40: return "InputAttachment";
    case 41: return "SparseResidency";
    case 42: return "MinLod";
    case 43: return "Sampled1D";
    case 44: return "Image1D";
    case 45: return "SampledCubeArray";
    case 46: return "SampledBuffer";
    case 47: return "ImageBuffer";
    case 48: return "ImageMSArray";
    case 49: return "StorageImageExtendedFormats";
    case 50: return "ImageQuery";
    case 51: return "DerivativeControl";
    case 52: return "InterpolationFunction";
    case 53: return "TransformFeedback";
    case 54: return "GeometryStreams";
    case 55: return "StorageImageReadWithoutFormat";
    case 56: return "StorageImageWriteWithoutFormat";
    case 57: return "MultiViewport";
    case 61: return "GroupNonUniform";
    case 62: return "GroupNonUniformVote";
    case 63: return "GroupNonUniformArithmetic";
    case 64: return "GroupNonUniformBallot";
    case 65: return "GroupNonUniformShuffle";
    case 66: return "GroupNonUniformShuffleRelative";
    case 67: return "GroupNonUniformClustered";
    case 68: return "GroupNonUniformQuad";

    case (int)Capability::SubgroupBallotKHR: return "SubgroupBallotKHR";
    case (int)Capability::DrawParameters:    return "DrawParameters";
    case (int)Capability::SubgroupVoteKHR:   return "SubgroupVoteKHR";
    case (int)Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR";

    case (int)Capability::StorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
    case (int)Capability::StorageUniform16:            return "StorageUniform16";
    case (int)Capability::StoragePushConstant16:       return "StoragePushConstant16";
    case (int)Capability::StorageInputOutput16:        return "StorageInputOutput16";

    case (int)Capability::StorageBuffer8BitAccess:             return "StorageBuffer8BitAccess";
    case (int)Capability::UniformAndStorageBuffer8BitAccess:   return "UniformAndStorageBuffer8BitAccess";
    case (int)Capability::StoragePushConstant8:                return "StoragePushConstant8";

    case (int)Capability::DeviceGroup: return "DeviceGroup";
    case (int)Capability::MultiView:   return "MultiView";

    case (int)Capability::DenormPreserve:           return "DenormPreserve";
    case (int)Capability::DenormFlushToZero:        return "DenormFlushToZero";
    case (int)Capability::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
    case (int)Capability::RoundingModeRTE:          return "RoundingModeRTE";
    case (int)Capability::RoundingModeRTZ:          return "RoundingModeRTZ";

    case (int)Capability::StencilExportEXT: return "StencilExportEXT";

    case (int)Capability::Float16ImageAMD:       return "Float16ImageAMD";
    case (int)Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
    case (int)Capability::FragmentMaskAMD:       return "FragmentMaskAMD";
    case (int)Capability::ImageReadWriteLodAMD:  return "ImageReadWriteLodAMD";

    case (int)Capability::AtomicStorageOps:             return "AtomicStorageOps";

    case (int)Capability::SampleMaskPostDepthCoverage:  return "SampleMaskPostDepthCoverage";
    case (int)Capability::GeometryShaderPassthroughNV:     return "GeometryShaderPassthroughNV";
    case (int)Capability::ShaderViewportIndexLayerNV:      return "ShaderViewportIndexLayerNV";
    case (int)Capability::ShaderViewportMaskNV:            return "ShaderViewportMaskNV";
    case (int)Capability::ShaderStereoViewNV:              return "ShaderStereoViewNV";
    case (int)Capability::PerViewAttributesNV:             return "PerViewAttributesNV";
    case (int)Capability::GroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
    case (int)Capability::RayTracingNV:                    return "RayTracingNV";
    case (int)Capability::RayTracingMotionBlurNV:          return "RayTracingMotionBlurNV";
    case (int)Capability::RayTracingKHR:                   return "RayTracingKHR";
    case (int)Capability::RayCullMaskKHR:                  return "RayCullMaskKHR";
    case (int)Capability::RayQueryKHR:                     return "RayQueryKHR";
    case (int)Capability::RayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
    case (int)Capability::RayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
    case (int)Capability::RayTracingPositionFetchKHR:      return "RayTracingPositionFetchKHR";
    case (int)Capability::DisplacementMicromapNV:           return "DisplacementMicromapNV";
    case (int)Capability::RayTracingOpacityMicromapEXT:    return "RayTracingOpacityMicromapEXT";
    case (int)Capability::RayTracingOpacityMicromapExecutionModeKHR: return "RayTracingOpacityMicromapExecutionModeKHR";
    case (int)Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
    case (int)Capability::RayQueryPositionFetchKHR:        return "RayQueryPositionFetchKHR";
    // ComputeDerivativeGroupQuadsKHR is an alias of ComputeDerivativeGroupQuadsNV
    case (int)Capability::ComputeDerivativeGroupQuadsKHR:   return "ComputeDerivativeGroupQuadsKHR";
   // ComputeDerivativeGroupLinearKHR is an alias of ComputeDerivativeGroupLinearNV
    case (int)Capability::ComputeDerivativeGroupLinearKHR:  return "ComputeDerivativeGroupLinearKHR";
    case (int)Capability::FragmentBarycentricKHR:          return "FragmentBarycentricKHR";
    case (int)Capability::MeshShadingNV:                   return "MeshShadingNV";
    case (int)Capability::ImageFootprintNV:                return "ImageFootprintNV";
    case (int)Capability::MeshShadingEXT:                  return "MeshShadingEXT";
//    case (int)Capability::ShadingRateNV:                   return "ShadingRateNV";  // superseded by FragmentDensityEXT
    case (int)Capability::SampleMaskOverrideCoverageNV:    return "SampleMaskOverrideCoverageNV";
    case (int)Capability::FragmentDensityEXT:              return "FragmentDensityEXT";

    case (int)Capability::FragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";

    case (int)Capability::ShaderNonUniformEXT:                          return "ShaderNonUniformEXT";
    case (int)Capability::RuntimeDescriptorArrayEXT:                    return "RuntimeDescriptorArrayEXT";
    case (int)Capability::InputAttachmentArrayDynamicIndexingEXT:       return "InputAttachmentArrayDynamicIndexingEXT";
    case (int)Capability::UniformTexelBufferArrayDynamicIndexingEXT:    return "UniformTexelBufferArrayDynamicIndexingEXT";
    case (int)Capability::StorageTexelBufferArrayDynamicIndexingEXT:    return "StorageTexelBufferArrayDynamicIndexingEXT";
    case (int)Capability::UniformBufferArrayNonUniformIndexingEXT:      return "UniformBufferArrayNonUniformIndexingEXT";
    case (int)Capability::SampledImageArrayNonUniformIndexingEXT:       return "SampledImageArrayNonUniformIndexingEXT";
    case (int)Capability::StorageBufferArrayNonUniformIndexingEXT:      return "StorageBufferArrayNonUniformIndexingEXT";
    case (int)Capability::StorageImageArrayNonUniformIndexingEXT:       return "StorageImageArrayNonUniformIndexingEXT";
    case (int)Capability::InputAttachmentArrayNonUniformIndexingEXT:    return "InputAttachmentArrayNonUniformIndexingEXT";
    case (int)Capability::UniformTexelBufferArrayNonUniformIndexingEXT: return "UniformTexelBufferArrayNonUniformIndexingEXT";
    case (int)Capability::StorageTexelBufferArrayNonUniformIndexingEXT: return "StorageTexelBufferArrayNonUniformIndexingEXT";

    case (int)Capability::VulkanMemoryModelKHR:                return "VulkanMemoryModelKHR";
    case (int)Capability::VulkanMemoryModelDeviceScopeKHR:     return "VulkanMemoryModelDeviceScopeKHR";

    case (int)Capability::PhysicalStorageBufferAddressesEXT:   return "PhysicalStorageBufferAddressesEXT";

    case (int)Capability::VariablePointers:                    return "VariablePointers";

    case (int)Capability::CooperativeMatrixNV:     return "CooperativeMatrixNV";
    case (int)Capability::CooperativeMatrixKHR:    return "CooperativeMatrixKHR";
    case (int)Capability::CooperativeMatrixReductionsNV:           return "CooperativeMatrixReductionsNV";
    case (int)Capability::CooperativeMatrixConversionsNV:          return "CooperativeMatrixConversionsNV";
    case (int)Capability::CooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
    case (int)Capability::CooperativeMatrixTensorAddressingNV:     return "CooperativeMatrixTensorAddressingNV";
    case (int)Capability::CooperativeMatrixBlockLoadsNV:           return "CooperativeMatrixBlockLoadsNV";
    case (int)Capability::CooperativeMatrixDecodeVectorNV:         return "CooperativeMatrixDecodeVectorNV";
    case (int)Capability::TensorAddressingNV:                      return "TensorAddressingNV";

    case (int)Capability::ShaderSMBuiltinsNV:      return "ShaderSMBuiltinsNV";

    case (int)Capability::CooperativeVectorNV:                     return "CooperativeVectorNV";
    case (int)Capability::CooperativeVectorTrainingNV:             return "CooperativeVectorTrainingNV";

    case (int)Capability::FragmentShaderSampleInterlockEXT:        return "FragmentShaderSampleInterlockEXT";
    case (int)Capability::FragmentShaderPixelInterlockEXT:         return "FragmentShaderPixelInterlockEXT";
    case (int)Capability::FragmentShaderShadingRateInterlockEXT:   return "FragmentShaderShadingRateInterlockEXT";

    case (int)Capability::TileImageColorReadAccessEXT:           return "TileImageColorReadAccessEXT";
    case (int)Capability::TileImageDepthReadAccessEXT:           return "TileImageDepthReadAccessEXT";
    case (int)Capability::TileImageStencilReadAccessEXT:         return "TileImageStencilReadAccessEXT";

    case (int)Capability::CooperativeMatrixLayoutsARM:             return "CooperativeMatrixLayoutsARM";
    case (int)Capability::TensorsARM:                              return "TensorsARM";

    case (int)Capability::FragmentShadingRateKHR:                  return "FragmentShadingRateKHR";

    case (int)Capability::DemoteToHelperInvocationEXT:             return "DemoteToHelperInvocationEXT";
    case (int)Capability::AtomicFloat16VectorNV:                   return "AtomicFloat16VectorNV";
    case (int)Capability::ShaderClockKHR:                          return "ShaderClockKHR";
    case (int)Capability::QuadControlKHR:                          return "QuadControlKHR";
    case (int)Capability::Int64ImageEXT:                           return "Int64ImageEXT";
    case (int)Capability::DescriptorHeapEXT:                       return "DescriptorHeapEXT";
    case (int)Capability::UntypedPointersKHR:                      return "UntypedPointersKHR";

    case (int)Capability::IntegerFunctions2INTEL:              return "IntegerFunctions2INTEL";

    case (int)Capability::ExpectAssumeKHR:                         return "ExpectAssumeKHR";
    case (int)Capability::AbortKHR:                                return "AbortKHR";
    case (int)Capability::ConstantDataKHR:                         return "ConstantDataKHR";

    case (int)Capability::AtomicFloat16AddEXT:                     return "AtomicFloat16AddEXT";
    case (int)Capability::AtomicFloat32AddEXT:                     return "AtomicFloat32AddEXT";
    case (int)Capability::AtomicFloat64AddEXT:                     return "AtomicFloat64AddEXT";
    case (int)Capability::AtomicFloat16MinMaxEXT:                  return "AtomicFloat16MinMaxEXT";
    case (int)Capability::AtomicFloat32MinMaxEXT:                  return "AtomicFloat32MinMaxEXT";
    case (int)Capability::AtomicFloat64MinMaxEXT:                  return "AtomicFloat64MinMaxEXT";

    case (int)Capability::WorkgroupMemoryExplicitLayoutKHR:            return "WorkgroupMemoryExplicitLayoutKHR";
    case (int)Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR:  return "WorkgroupMemoryExplicitLayout8BitAccessKHR";
    case (int)Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR";
    case (int)Capability::CoreBuiltinsARM:                             return "CoreBuiltinsARM";

    case (int)Capability::ShaderInvocationReorderNV:                return "ShaderInvocationReorderNV";
    case (int)Capability::ShaderInvocationReorderEXT:               return "ShaderInvocationReorderEXT";

    case (int)Capability::TextureSampleWeightedQCOM:           return "TextureSampleWeightedQCOM";
    case (int)Capability::TextureBoxFilterQCOM:                return "TextureBoxFilterQCOM";
    case (int)Capability::TextureBlockMatchQCOM:               return "TextureBlockMatchQCOM";
    case (int)Capability::TileShadingQCOM:                     return "TileShadingQCOM";
    case (int)Capability::TextureBlockMatch2QCOM:              return "TextureBlockMatch2QCOM";

    case (int)Capability::CooperativeMatrixConversionQCOM:     return "CooperativeMatrixConversionQCOM";

    case (int)Capability::ReplicatedCompositesEXT:             return "ReplicatedCompositesEXT";

    case (int)Capability::DotProductKHR:                       return "DotProductKHR";
    case (int)Capability::DotProductInputAllKHR:               return "DotProductInputAllKHR";
    case (int)Capability::DotProductInput4x8BitKHR:            return "DotProductInput4x8BitKHR";
    case (int)Capability::DotProductInput4x8BitPackedKHR:      return "DotProductInput4x8BitPackedKHR";

    case (int)Capability::RayTracingClusterAccelerationStructureNV:   return "RayTracingClusterAccelerationStructureNV";

    case (int)Capability::RayTracingSpheresGeometryNV:             return "RayTracingSpheresGeometryNV";
    case (int)Capability::RayTracingLinearSweptSpheresGeometryNV:  return "RayTracingLinearSweptSpheresGeometryNV";

    case (int)Capability::BFloat16TypeKHR:                     return "BFloat16TypeKHR";
    case (int)Capability::BFloat16DotProductKHR:               return "BFloat16DotProductKHR";
    case (int)Capability::BFloat16CooperativeMatrixKHR:        return "BFloat16CooperativeMatrixKHR";

    case (int)Capability::Float8EXT:                           return "Float8EXT";
    case (int)Capability::Float8CooperativeMatrixEXT:          return "Float8CooperativeMatrixEXT";

    case (int)Capability::PushConstantBanksNV:                 return "PushConstantBanksNV";
        
    case (int)Capability::Shader64BitIndexingEXT:              return "CapabilityShader64BitIndexingEXT";
    case (int)Capability::LongVectorEXT:                       return "LongVectorEXT";

    case (int)Capability::Float4EXT:                           return "Float4EXT";
    case (int)Capability::Float6EXT:                           return "Float6EXT";
    case (int)Capability::Float8UnsignedE8M0EXT:               return "Float8UnsignedE8M0EXT";
    case (int)Capability::MXInt8EXT:                           return "MXInt8EXT";
    case (int)Capability::BitcastExtractEXT:                   return "BitcastExtractEXT";

    default: return "Bad";
    }
}

const char* OpcodeString(int op)
{
    switch (op) {
    case 0:   return "OpNop";
    case 1:   return "OpUndef";
    case 2:   return "OpSourceContinued";
    case 3:   return "OpSource";
    case 4:   return "OpSourceExtension";
    case 5:   return "OpName";
    case 6:   return "OpMemberName";
    case 7:   return "OpString";
    case 8:   return "OpLine";
    case 9:   return "Bad";
    case 10:  return "OpExtension";
    case 11:  return "OpExtInstImport";
    case 12:  return "OpExtInst";
    case 13:  return "Bad";
    case 14:  return "OpMemoryModel";
    case 15:  return "OpEntryPoint";
    case 16:  return "OpExecutionMode";
    case 17:  return "OpCapability";
    case 18:  return "Bad";
    case 19:  return "OpTypeVoid";
    case 20:  return "OpTypeBool";
    case 21:  return "OpTypeInt";
    case 22:  return "OpTypeFloat";
    case 23:  return "OpTypeVector";
    case 24:  return "OpTypeMatrix";
    case 25:  return "OpTypeImage";
    case 26:  return "OpTypeSampler";
    case 27:  return "OpTypeSampledImage";
    case 28:  return "OpTypeArray";
    case 29:  return "OpTypeRuntimeArray";
    case 30:  return "OpTypeStruct";
    case 31:  return "OpTypeOpaque";
    case 32:  return "OpTypePointer";
    case 33:  return "OpTypeFunction";
    case 34:  return "OpTypeEvent";
    case 35:  return "OpTypeDeviceEvent";
    case 36:  return "OpTypeReserveId";
    case 37:  return "OpTypeQueue";
    case 38:  return "OpTypePipe";
    case 39:  return "OpTypeForwardPointer";
    case 40:  return "Bad";
    case 41:  return "OpConstantTrue";
    case 42:  return "OpConstantFalse";
    case 43:  return "OpConstant";
    case 44:  return "OpConstantComposite";
    case 45:  return "OpConstantSampler";
    case 46:  return "OpConstantNull";
    case 47:  return "Bad";
    case 48:  return "OpSpecConstantTrue";
    case 49:  return "OpSpecConstantFalse";
    case 50:  return "OpSpecConstant";
    case 51:  return "OpSpecConstantComposite";
    case 52:  return "OpSpecConstantOp";
    case 53:  return "Bad";
    case 54:  return "OpFunction";
    case 55:  return "OpFunctionParameter";
    case 56:  return "OpFunctionEnd";
    case 57:  return "OpFunctionCall";
    case 58:  return "Bad";
    case 59:  return "OpVariable";
    case 60:  return "OpImageTexelPointer";
    case 61:  return "OpLoad";
    case 62:  return "OpStore";
    case 63:  return "OpCopyMemory";
    case 64:  return "OpCopyMemorySized";
    case 65:  return "OpAccessChain";
    case 66:  return "OpInBoundsAccessChain";
    case 67:  return "OpPtrAccessChain";
    case 68:  return "OpArrayLength";
    case 69:  return "OpGenericPtrMemSemantics";
    case 70:  return "OpInBoundsPtrAccessChain";
    case 71:  return "OpDecorate";
    case 72:  return "OpMemberDecorate";
    case 73:  return "OpDecorationGroup";
    case 74:  return "OpGroupDecorate";
    case 75:  return "OpGroupMemberDecorate";
    case 76:  return "Bad";
    case 77:  return "OpVectorExtractDynamic";
    case 78:  return "OpVectorInsertDynamic";
    case 79:  return "OpVectorShuffle";
    case 80:  return "OpCompositeConstruct";
    case 81:  return "OpCompositeExtract";
    case 82:  return "OpCompositeInsert";
    case 83:  return "OpCopyObject";
    case 84:  return "OpTranspose";
    case (int)Op::OpCopyLogical: return "OpCopyLogical";
    case 85:  return "Bad";
    case 86:  return "OpSampledImage";
    case 87:  return "OpImageSampleImplicitLod";
    case 88:  return "OpImageSampleExplicitLod";
    case 89:  return "OpImageSampleDrefImplicitLod";
    case 90:  return "OpImageSampleDrefExplicitLod";
    case 91:  return "OpImageSampleProjImplicitLod";
    case 92:  return "OpImageSampleProjExplicitLod";
    case 93:  return "OpImageSampleProjDrefImplicitLod";
    case 94:  return "OpImageSampleProjDrefExplicitLod";
    case 95:  return "OpImageFetch";
    case 96:  return "OpImageGather";
    case 97:  return "OpImageDrefGather";
    case 98:  return "OpImageRead";
    case 99:  return "OpImageWrite";
    case 100: return "OpImage";
    case 101: return "OpImageQueryFormat";
    case 102: return "OpImageQueryOrder";
    case 103: return "OpImageQuerySizeLod";
    case 104: return "OpImageQuerySize";
    case 105: return "OpImageQueryLod";
    case 106: return "OpImageQueryLevels";
    case 107: return "OpImageQuerySamples";
    case 108: return "Bad";
    case 109: return "OpConvertFToU";
    case 110: return "OpConvertFToS";
    case 111: return "OpConvertSToF";
    case 112: return "OpConvertUToF";
    case 113: return "OpUConvert";
    case 114: return "OpSConvert";
    case 115: return "OpFConvert";
    case 116: return "OpQuantizeToF16";
    case 117: return "OpConvertPtrToU";
    case 118: return "OpSatConvertSToU";
    case 119: return "OpSatConvertUToS";
    case 120: return "OpConvertUToPtr";
    case 121: return "OpPtrCastToGeneric";
    case 122: return "OpGenericCastToPtr";
    case 123: return "OpGenericCastToPtrExplicit";
    case 124: return "OpBitcast";
    case 125: return "Bad";
    case 126: return "OpSNegate";
    case 127: return "OpFNegate";
    case 128: return "OpIAdd";
    case 129: return "OpFAdd";
    case 130: return "OpISub";
    case 131: return "OpFSub";
    case 132: return "OpIMul";
    case 133: return "OpFMul";
    case 134: return "OpUDiv";
    case 135: return "OpSDiv";
    case 136: return "OpFDiv";
    case 137: return "OpUMod";
    case 138: return "OpSRem";
    case 139: return "OpSMod";
    case 140: return "OpFRem";
    case 141: return "OpFMod";
    case 142: return "OpVectorTimesScalar";
    case 143: return "OpMatrixTimesScalar";
    case 144: return "OpVectorTimesMatrix";
    case 145: return "OpMatrixTimesVector";
    case 146: return "OpMatrixTimesMatrix";
    case 147: return "OpOuterProduct";
    case 148: return "OpDot";
    case 149: return "OpIAddCarry";
    case 150: return "OpISubBorrow";
    case 151: return "OpUMulExtended";
    case 152: return "OpSMulExtended";
    case 153: return "Bad";
    case 154: return "OpAny";
    case 155: return "OpAll";
    case 156: return "OpIsNan";
    case 157: return "OpIsInf";
    case 158: return "OpIsFinite";
    case 159: return "OpIsNormal";
    case 160: return "OpSignBitSet";
    case 161: return "OpLessOrGreater";
    case 162: return "OpOrdered";
    case 163: return "OpUnordered";
    case 164: return "OpLogicalEqual";
    case 165: return "OpLogicalNotEqual";
    case 166: return "OpLogicalOr";
    case 167: return "OpLogicalAnd";
    case 168: return "OpLogicalNot";
    case 169: return "OpSelect";
    case 170: return "OpIEqual";
    case 171: return "OpINotEqual";
    case 172: return "OpUGreaterThan";
    case 173: return "OpSGreaterThan";
    case 174: return "OpUGreaterThanEqual";
    case 175: return "OpSGreaterThanEqual";
    case 176: return "OpULessThan";
    case 177: return "OpSLessThan";
    case 178: return "OpULessThanEqual";
    case 179: return "OpSLessThanEqual";
    case 180: return "OpFOrdEqual";
    case 181: return "OpFUnordEqual";
    case 182: return "OpFOrdNotEqual";
    case 183: return "OpFUnordNotEqual";
    case 184: return "OpFOrdLessThan";
    case 185: return "OpFUnordLessThan";
    case 186: return "OpFOrdGreaterThan";
    case 187: return "OpFUnordGreaterThan";
    case 188: return "OpFOrdLessThanEqual";
    case 189: return "OpFUnordLessThanEqual";
    case 190: return "OpFOrdGreaterThanEqual";
    case 191: return "OpFUnordGreaterThanEqual";
    case 192: return "Bad";
    case 193: return "Bad";
    case 194: return "OpShiftRightLogical";
    case 195: return "OpShiftRightArithmetic";
    case 196: return "OpShiftLeftLogical";
    case 197: return "OpBitwiseOr";
    case 198: return "OpBitwiseXor";
    case 199: return "OpBitwiseAnd";
    case 200: return "OpNot";
    case 201: return "OpBitFieldInsert";
    case 202: return "OpBitFieldSExtract";
    case 203: return "OpBitFieldUExtract";
    case 204: return "OpBitReverse";
    case 205: return "OpBitCount";
    case 206: return "Bad";
    case 207: return "OpDPdx";
    case 208: return "OpDPdy";
    case 209: return "OpFwidth";
    case 210: return "OpDPdxFine";
    case 211: return "OpDPdyFine";
    case 212: return "OpFwidthFine";
    case 213: return "OpDPdxCoarse";
    case 214: return "OpDPdyCoarse";
    case 215: return "OpFwidthCoarse";
    case 216: return "Bad";
    case 217: return "Bad";
    case 218: return "OpEmitVertex";
    case 219: return "OpEndPrimitive";
    case 220: return "OpEmitStreamVertex";
    case 221: return "OpEndStreamPrimitive";
    case 222: return "Bad";
    case 223: return "Bad";
    case 224: return "OpControlBarrier";
    case 225: return "OpMemoryBarrier";
    case 226: return "Bad";
    case 227: return "OpAtomicLoad";
    case 228: return "OpAtomicStore";
    case 229: return "OpAtomicExchange";
    case 230: return "OpAtomicCompareExchange";
    case 231: return "OpAtomicCompareExchangeWeak";
    case 232: return "OpAtomicIIncrement";
    case 233: return "OpAtomicIDecrement";
    case 234: return "OpAtomicIAdd";
    case 235: return "OpAtomicISub";
    case 236: return "OpAtomicSMin";
    case 237: return "OpAtomicUMin";
    case 238: return "OpAtomicSMax";
    case 239: return "OpAtomicUMax";
    case 240: return "OpAtomicAnd";
    case 241: return "OpAtomicOr";
    case 242: return "OpAtomicXor";
    case 243: return "Bad";
    case 244: return "Bad";
    case 245: return "OpPhi";
    case 246: return "OpLoopMerge";
    case 247: return "OpSelectionMerge";
    case 248: return "OpLabel";
    case 249: return "OpBranch";
    case 250: return "OpBranchConditional";
    case 251: return "OpSwitch";
    case 252: return "OpKill";
    case 253: return "OpReturn";
    case 254: return "OpReturnValue";
    case 255: return "OpUnreachable";
    case 256: return "OpLifetimeStart";
    case 257: return "OpLifetimeStop";
    case 258: return "Bad";
    case 259: return "OpGroupAsyncCopy";
    case 260: return "OpGroupWaitEvents";
    case 261: return "OpGroupAll";
    case 262: return "OpGroupAny";
    case 263: return "OpGroupBroadcast";
    case 264: return "OpGroupIAdd";
    case 265: return "OpGroupFAdd";
    case 266: return "OpGroupFMin";
    case 267: return "OpGroupUMin";
    case 268: return "OpGroupSMin";
    case 269: return "OpGroupFMax";
    case 270: return "OpGroupUMax";
    case 271: return "OpGroupSMax";
    case 272: return "Bad";
    case 273: return "Bad";
    case 274: return "OpReadPipe";
    case 275: return "OpWritePipe";
    case 276: return "OpReservedReadPipe";
    case 277: return "OpReservedWritePipe";
    case 278: return "OpReserveReadPipePackets";
    case 279: return "OpReserveWritePipePackets";
    case 280: return "OpCommitReadPipe";
    case 281: return "OpCommitWritePipe";
    case 282: return "OpIsValidReserveId";
    case 283: return "OpGetNumPipePackets";
    case 284: return "OpGetMaxPipePackets";
    case 285: return "OpGroupReserveReadPipePackets";
    case 286: return "OpGroupReserveWritePipePackets";
    case 287: return "OpGroupCommitReadPipe";
    case 288: return "OpGroupCommitWritePipe";
    case 289: return "Bad";
    case 290: return "Bad";
    case 291: return "OpEnqueueMarker";
    case 292: return "OpEnqueueKernel";
    case 293: return "OpGetKernelNDrangeSubGroupCount";
    case 294: return "OpGetKernelNDrangeMaxSubGroupSize";
    case 295: return "OpGetKernelWorkGroupSize";
    case 296: return "OpGetKernelPreferredWorkGroupSizeMultiple";
    case 297: return "OpRetainEvent";
    case 298: return "OpReleaseEvent";
    case 299: return "OpCreateUserEvent";
    case 300: return "OpIsValidEvent";
    case 301: return "OpSetUserEventStatus";
    case 302: return "OpCaptureEventProfilingInfo";
    case 303: return "OpGetDefaultQueue";
    case 304: return "OpBuildNDRange";
    case 305: return "OpImageSparseSampleImplicitLod";
    case 306: return "OpImageSparseSampleExplicitLod";
    case 307: return "OpImageSparseSampleDrefImplicitLod";
    case 308: return "OpImageSparseSampleDrefExplicitLod";
    case 309: return "OpImageSparseSampleProjImplicitLod";
    case 310: return "OpImageSparseSampleProjExplicitLod";
    case 311: return "OpImageSparseSampleProjDrefImplicitLod";
    case 312: return "OpImageSparseSampleProjDrefExplicitLod";
    case 313: return "OpImageSparseFetch";
    case 314: return "OpImageSparseGather";
    case 315: return "OpImageSparseDrefGather";
    case 316: return "OpImageSparseTexelsResident";
    case 317: return "OpNoLine";
    case 318: return "OpAtomicFlagTestAndSet";
    case 319: return "OpAtomicFlagClear";
    case 320: return "OpImageSparseRead";

    case (int)Op::OpModuleProcessed: return "OpModuleProcessed";
    case (int)Op::OpExecutionModeId: return "OpExecutionModeId";
    case (int)Op::OpDecorateId:      return "OpDecorateId";

    case 333: return "OpGroupNonUniformElect";
    case 334: return "OpGroupNonUniformAll";
    case 335: return "OpGroupNonUniformAny";
    case 336: return "OpGroupNonUniformAllEqual";
    case 337: return "OpGroupNonUniformBroadcast";
    case 338: return "OpGroupNonUniformBroadcastFirst";
    case 339: return "OpGroupNonUniformBallot";
    case 340: return "OpGroupNonUniformInverseBallot";
    case 341: return "OpGroupNonUniformBallotBitExtract";
    case 342: return "OpGroupNonUniformBallotBitCount";
    case 343: return "OpGroupNonUniformBallotFindLSB";
    case 344: return "OpGroupNonUniformBallotFindMSB";
    case 345: return "OpGroupNonUniformShuffle";
    case 346: return "OpGroupNonUniformShuffleXor";
    case 347: return "OpGroupNonUniformShuffleUp";
    case 348: return "OpGroupNonUniformShuffleDown";
    case 349: return "OpGroupNonUniformIAdd";
    case 350: return "OpGroupNonUniformFAdd";
    case 351: return "OpGroupNonUniformIMul";
    case 352: return "OpGroupNonUniformFMul";
    case 353: return "OpGroupNonUniformSMin";
    case 354: return "OpGroupNonUniformUMin";
    case 355: return "OpGroupNonUniformFMin";
    case 356: return "OpGroupNonUniformSMax";
    case 357: return "OpGroupNonUniformUMax";
    case 358: return "OpGroupNonUniformFMax";
    case 359: return "OpGroupNonUniformBitwiseAnd";
    case 360: return "OpGroupNonUniformBitwiseOr";
    case 361: return "OpGroupNonUniformBitwiseXor";
    case 362: return "OpGroupNonUniformLogicalAnd";
    case 363: return "OpGroupNonUniformLogicalOr";
    case 364: return "OpGroupNonUniformLogicalXor";
    case 365: return "OpGroupNonUniformQuadBroadcast";
    case 366: return "OpGroupNonUniformQuadSwap";

    case (int)Op::OpTerminateInvocation: return "OpTerminateInvocation";

    case 4421: return "OpSubgroupBallotKHR";
    case 4422: return "OpSubgroupFirstInvocationKHR";
    case 4428: return "OpSubgroupAllKHR";
    case 4429: return "OpSubgroupAnyKHR";
    case 4430: return "OpSubgroupAllEqualKHR";
    case 4432: return "OpSubgroupReadInvocationKHR";
    case 4433: return "OpExtInstWithForwardRefsKHR";

    case (int)Op::OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
    case (int)Op::OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
    case (int)Op::OpBufferPointerEXT:          return "OpBufferPointerEXT";
    case (int)Op::OpConstantSizeOfEXT:         return "OpConstantSizeOfEXT";
    case (int)Op::OpTypeBufferEXT:             return "OpTypeBufferEXT";
    case (int)Op::OpUntypedAccessChainKHR:     return "OpUntypedAccessChainKHR";
    case (int)Op::OpUntypedVariableKHR:        return "OpUntypedVariableKHR";
    case (int)Op::OpTypeUntypedPointerKHR:     return "OpTypeUntypedPointerKHR";
    case (int)Op::OpMemberDecorateIdEXT:       return "OpMemberDecorateIdEXT";
    case (int)Op::OpUntypedImageTexelPointerEXT:     return "OpUntypedImageTexelPointerEXT";

    case (int)Op::OpAbortKHR:            return "OpAbortKHR";
    case (int)Op::OpConstantDataKHR:     return "OpConstantDataKHR";
    case (int)Op::OpSpecConstantDataKHR: return "OpSpecConstantDataKHR";

    case (int)Op::OpAtomicFAddEXT: return "OpAtomicFAddEXT";
    case (int)Op::OpAtomicFMinEXT: return "OpAtomicFMinEXT";
    case (int)Op::OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";

    case (int)Op::OpAssumeTrueKHR: return "OpAssumeTrueKHR";
    case (int)Op::OpExpectKHR: return "OpExpectKHR";

    case 5000: return "OpGroupIAddNonUniformAMD";
    case 5001: return "OpGroupFAddNonUniformAMD";
    case 5002: return "OpGroupFMinNonUniformAMD";
    case 5003: return "OpGroupUMinNonUniformAMD";
    case 5004: return "OpGroupSMinNonUniformAMD";
    case 5005: return "OpGroupFMaxNonUniformAMD";
    case 5006: return "OpGroupUMaxNonUniformAMD";
    case 5007: return "OpGroupSMaxNonUniformAMD";

    case 5011: return "OpFragmentMaskFetchAMD";
    case 5012: return "OpFragmentFetchAMD";

    case (int)Op::OpReadClockKHR:               return "OpReadClockKHR";

    case (int)Op::OpDecorateStringGOOGLE:       return "OpDecorateStringGOOGLE";
    case (int)Op::OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";

    case (int)Op::OpReportIntersectionKHR:             return "OpReportIntersectionKHR";
    case (int)Op::OpIgnoreIntersectionNV:              return "OpIgnoreIntersectionNV";
    case (int)Op::OpIgnoreIntersectionKHR:             return "OpIgnoreIntersectionKHR";
    case (int)Op::OpTerminateRayNV:                    return "OpTerminateRayNV";
    case (int)Op::OpTerminateRayKHR:                   return "OpTerminateRayKHR";
    case (int)Op::OpTraceNV:                           return "OpTraceNV";
    case (int)Op::OpTraceRayMotionNV:                  return "OpTraceRayMotionNV";
    case (int)Op::OpTraceRayKHR:                       return "OpTraceRayKHR";
    case (int)Op::OpTypeAccelerationStructureKHR:      return "OpTypeAccelerationStructureKHR";
    case (int)Op::OpExecuteCallableNV:                 return "OpExecuteCallableNV";
    case (int)Op::OpExecuteCallableKHR:                return "OpExecuteCallableKHR";
    case (int)Op::OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";

    case (int)Op::OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
    case (int)Op::OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
    case (int)Op::OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
    case (int)Op::OpEmitMeshTasksEXT:                 return "OpEmitMeshTasksEXT";
    case (int)Op::OpSetMeshOutputsEXT:                return "OpSetMeshOutputsEXT";

    case (int)Op::OpGroupNonUniformRotateKHR:         return "OpGroupNonUniformRotateKHR";

    case (int)Op::OpTypeRayQueryKHR:                                                   return "OpTypeRayQueryKHR";
    case (int)Op::OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
    case (int)Op::OpRayQueryTerminateKHR:                                              return "OpRayQueryTerminateKHR";
    case (int)Op::OpRayQueryGenerateIntersectionKHR:                                   return "OpRayQueryGenerateIntersectionKHR";
    case (int)Op::OpRayQueryConfirmIntersectionKHR:                                    return "OpRayQueryConfirmIntersectionKHR";
    case (int)Op::OpRayQueryProceedKHR:                                                return "OpRayQueryProceedKHR";
    case (int)Op::OpRayQueryGetIntersectionTypeKHR:                                    return "OpRayQueryGetIntersectionTypeKHR";
    case (int)Op::OpRayQueryGetRayTMinKHR:                                             return "OpRayQueryGetRayTMinKHR";
    case (int)Op::OpRayQueryGetRayFlagsKHR:                                            return "OpRayQueryGetRayFlagsKHR";
    case (int)Op::OpRayQueryGetIntersectionTKHR:                                       return "OpRayQueryGetIntersectionTKHR";
    case (int)Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR:                     return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
    case (int)Op::OpRayQueryGetIntersectionInstanceIdKHR:                              return "OpRayQueryGetIntersectionInstanceIdKHR";
    case (int)Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:  return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
    case (int)Op::OpRayQueryGetIntersectionGeometryIndexKHR:                           return "OpRayQueryGetIntersectionGeometryIndexKHR";
    case (int)Op::OpRayQueryGetIntersectionPrimitiveIndexKHR:                          return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
    case (int)Op::OpRayQueryGetIntersectionBarycentricsKHR:                            return "OpRayQueryGetIntersectionBarycentricsKHR";
    case (int)Op::OpRayQueryGetIntersectionFrontFaceKHR:                               return "OpRayQueryGetIntersectionFrontFaceKHR";
    case (int)Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:                     return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
    case (int)Op::OpRayQueryGetIntersectionObjectRayDirectionKHR:                      return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
    case (int)Op::OpRayQueryGetIntersectionObjectRayOriginKHR:                         return "OpRayQueryGetIntersectionObjectRayOriginKHR";
    case (int)Op::OpRayQueryGetWorldRayDirectionKHR:                                   return "OpRayQueryGetWorldRayDirectionKHR";
    case (int)Op::OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
    case (int)Op::OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
    case (int)Op::OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
    case (int)Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR:                 return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
    case (int)Op::OpRayQueryGetClusterIdNV:                                            return "OpRayQueryGetIntersectionClusterIdNV";

    case (int)Op::OpRayQueryGetIntersectionSpherePositionNV:                           return "OpRayQueryGetIntersectionSpherePositionNV";
    case (int)Op::OpRayQueryGetIntersectionSphereRadiusNV:                             return "OpRayQueryGetIntersectionSphereRadiusNV";
    case (int)Op::OpRayQueryGetIntersectionLSSHitValueNV:                              return "OpRayQueryGetIntersectionLSSHitValueNV";
    case (int)Op::OpRayQueryGetIntersectionLSSPositionsNV:                             return "OpRayQueryGetIntersectionLSSPositionsNV";
    case (int)Op::OpRayQueryGetIntersectionLSSRadiiNV:                                 return "OpRayQueryGetIntersectionLSSRadiiNV";
    case (int)Op::OpRayQueryIsSphereHitNV:                                             return "OpRayQueryIsSphereHitNV";
    case (int)Op::OpRayQueryIsLSSHitNV:                                                return "OpRayQueryIsLSSHitNV";

    case (int)Op::OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
    case (int)Op::OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
    case (int)Op::OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
    case (int)Op::OpCooperativeMatrixMulAddNV:       return "OpCooperativeMatrixMulAddNV";
    case (int)Op::OpCooperativeMatrixLengthNV:       return "OpCooperativeMatrixLengthNV";
    case (int)Op::OpTypeCooperativeMatrixKHR:        return "OpTypeCooperativeMatrixKHR";
    case (int)Op::OpCooperativeMatrixLoadKHR:        return "OpCooperativeMatrixLoadKHR";
    case (int)Op::OpCooperativeMatrixStoreKHR:       return "OpCooperativeMatrixStoreKHR";
    case (int)Op::OpCooperativeMatrixMulAddKHR:      return "OpCooperativeMatrixMulAddKHR";
    case (int)Op::OpCooperativeMatrixLengthKHR:      return "OpCooperativeMatrixLengthKHR";
    case (int)Op::OpDemoteToHelperInvocationEXT:     return "OpDemoteToHelperInvocationEXT";
    case (int)Op::OpIsHelperInvocationEXT:           return "OpIsHelperInvocationEXT";

    case (int)Op::OpCooperativeMatrixConvertNV:      return "OpCooperativeMatrixConvertNV";
    case (int)Op::OpCooperativeMatrixTransposeNV:    return "OpCooperativeMatrixTransposeNV";
    case (int)Op::OpCooperativeMatrixReduceNV:       return "OpCooperativeMatrixReduceNV";
    case (int)Op::OpCooperativeMatrixLoadTensorNV:   return "OpCooperativeMatrixLoadTensorNV";
    case (int)Op::OpCooperativeMatrixStoreTensorNV:  return "OpCooperativeMatrixStoreTensorNV";
    case (int)Op::OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
    case (int)Op::OpTypeTensorLayoutNV:              return "OpTypeTensorLayoutNV";
    case (int)Op::OpTypeTensorViewNV:                return "OpTypeTensorViewNV";
    case (int)Op::OpCreateTensorLayoutNV:            return "OpCreateTensorLayoutNV";
    case (int)Op::OpTensorLayoutSetBlockSizeNV:      return "OpTensorLayoutSetBlockSizeNV";
    case (int)Op::OpTensorLayoutSetDimensionNV:      return "OpTensorLayoutSetDimensionNV";
    case (int)Op::OpTensorLayoutSetStrideNV:         return "OpTensorLayoutSetStrideNV";
    case (int)Op::OpTensorLayoutSliceNV:             return "OpTensorLayoutSliceNV";
    case (int)Op::OpTensorLayoutSetClampValueNV:     return "OpTensorLayoutSetClampValueNV";
    case (int)Op::OpCreateTensorViewNV:              return "OpCreateTensorViewNV";
    case (int)Op::OpTensorViewSetDimensionNV:        return "OpTensorViewSetDimensionNV";
    case (int)Op::OpTensorViewSetStrideNV:           return "OpTensorViewSetStrideNV";
    case (int)Op::OpTensorViewSetClipNV:             return "OpTensorViewSetClipNV";

    case (int)Op::OpTypeTensorARM:                   return "OpTypeTensorARM";
    case (int)Op::OpTensorReadARM:                   return "OpTensorReadARM";
    case (int)Op::OpTensorWriteARM:                  return "OpTensorWriteARM";
    case (int)Op::OpTensorQuerySizeARM:              return "OpTensorQuerySizeARM";

    case (int)Op::OpTypeCooperativeVectorNV:         return "OpTypeCooperativeVectorNV";
    case (int)Op::OpCooperativeVectorMatrixMulNV:    return "OpCooperativeVectorMatrixMulNV";
    case (int)Op::OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
    case (int)Op::OpCooperativeVectorLoadNV:         return "OpCooperativeVectorLoadNV";
    case (int)Op::OpCooperativeVectorStoreNV:        return "OpCooperativeVectorStoreNV";
    case (int)Op::OpCooperativeVectorOuterProductAccumulateNV:   return "OpCooperativeVectorOuterProductAccumulateNV";
    case (int)Op::OpCooperativeVectorReduceSumAccumulateNV:      return "OpCooperativeVectorReduceSumAccumulateNV";

    case (int)Op::OpBeginInvocationInterlockEXT:     return "OpBeginInvocationInterlockEXT";
    case (int)Op::OpEndInvocationInterlockEXT:       return "OpEndInvocationInterlockEXT";

    case (int)Op::OpTypeHitObjectNV:                     return "OpTypeHitObjectNV";
    case (int)Op::OpHitObjectTraceRayNV:                 return "OpHitObjectTraceRayNV";
    case (int)Op::OpHitObjectTraceRayMotionNV:           return "OpHitObjectTraceRayMotionNV";
    case (int)Op::OpHitObjectRecordHitNV:                return "OpHitObjectRecordHitNV";
    case (int)Op::OpHitObjectRecordHitMotionNV:          return "OpHitObjectRecordHitMotionNV";
    case (int)Op::OpHitObjectRecordHitWithIndexNV:       return "OpHitObjectRecordHitWithIndexNV";
    case (int)Op::OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
    case (int)Op::OpHitObjectRecordMissNV:               return "OpHitObjectRecordMissNV";
    case (int)Op::OpHitObjectRecordMissMotionNV:         return "OpHitObjectRecordMissMotionNV";
    case (int)Op::OpHitObjectRecordEmptyNV:              return "OpHitObjectRecordEmptyNV";
    case (int)Op::OpHitObjectExecuteShaderNV:            return "OpHitObjectExecuteShaderNV";
    case (int)Op::OpReorderThreadWithHintNV:             return "OpReorderThreadWithHintNV";
    case (int)Op::OpReorderThreadWithHitObjectNV:        return "OpReorderThreadWithHitObjectNV";
    case (int)Op::OpHitObjectGetCurrentTimeNV:           return "OpHitObjectGetCurrentTimeNV";
    case (int)Op::OpHitObjectGetAttributesNV:            return "OpHitObjectGetAttributesNV";
    case (int)Op::OpHitObjectGetHitKindNV:               return "OpHitObjectGetFrontFaceNV";
    case (int)Op::OpHitObjectGetPrimitiveIndexNV:        return "OpHitObjectGetPrimitiveIndexNV";
    case (int)Op::OpHitObjectGetGeometryIndexNV:         return "OpHitObjectGetGeometryIndexNV";
    case (int)Op::OpHitObjectGetInstanceIdNV:            return "OpHitObjectGetInstanceIdNV";
    case (int)Op::OpHitObjectGetInstanceCustomIndexNV:   return "OpHitObjectGetInstanceCustomIndexNV";
    case (int)Op::OpHitObjectGetObjectRayDirectionNV:    return "OpHitObjectGetObjectRayDirectionNV";
    case (int)Op::OpHitObjectGetObjectRayOriginNV:       return "OpHitObjectGetObjectRayOriginNV";
    case (int)Op::OpHitObjectGetWorldRayDirectionNV:     return "OpHitObjectGetWorldRayDirectionNV";
    case (int)Op::OpHitObjectGetWorldRayOriginNV:        return "OpHitObjectGetWorldRayOriginNV";
    case (int)Op::OpHitObjectGetWorldToObjectNV:         return "OpHitObjectGetWorldToObjectNV";
    case (int)Op::OpHitObjectGetObjectToWorldNV:         return "OpHitObjectGetObjectToWorldNV";
    case (int)Op::OpHitObjectGetRayTMaxNV:               return "OpHitObjectGetRayTMaxNV";
    case (int)Op::OpHitObjectGetRayTMinNV:               return "OpHitObjectGetRayTMinNV";
    case (int)Op::OpHitObjectIsEmptyNV:                  return "OpHitObjectIsEmptyNV";
    case (int)Op::OpHitObjectIsHitNV:                    return "OpHitObjectIsHitNV";
    case (int)Op::OpHitObjectIsMissNV:                   return "OpHitObjectIsMissNV";
    case (int)Op::OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
    case (int)Op::OpHitObjectGetShaderRecordBufferHandleNV:   return "OpHitObjectGetShaderRecordBufferHandleNV";
    case (int)Op::OpHitObjectGetClusterIdNV:             return "OpHitObjectGetClusterIdNV";
    case (int)Op::OpHitObjectGetSpherePositionNV:        return "OpHitObjectGetSpherePositionNV";
    case (int)Op::OpHitObjectGetSphereRadiusNV:          return "OpHitObjectGetSphereRadiusNV";
    case (int)Op::OpHitObjectGetLSSPositionsNV:          return "OpHitObjectGetLSSPositionsNV";
    case (int)Op::OpHitObjectGetLSSRadiiNV:              return "OpHitObjectGetLSSRadiiNV";
    case (int)Op::OpHitObjectIsSphereHitNV:              return "OpHitObjectIsSphereHitNV";
    case (int)Op::OpHitObjectIsLSSHitNV:                 return "OpHitObjectIsLSSHitNV";

    case (int)Op::OpFetchMicroTriangleVertexBarycentricNV:       return "OpFetchMicroTriangleVertexBarycentricNV";
    case (int)Op::OpFetchMicroTriangleVertexPositionNV:    return "OpFetchMicroTriangleVertexPositionNV";

    case (int)Op::OpColorAttachmentReadEXT:          return "OpColorAttachmentReadEXT";
    case (int)Op::OpDepthAttachmentReadEXT:          return "OpDepthAttachmentReadEXT";
    case (int)Op::OpStencilAttachmentReadEXT:        return "OpStencilAttachmentReadEXT";

    case (int)Op::OpImageSampleWeightedQCOM:         return "OpImageSampleWeightedQCOM";
    case (int)Op::OpImageBoxFilterQCOM:              return "OpImageBoxFilterQCOM";
    case (int)Op::OpImageBlockMatchSADQCOM:          return "OpImageBlockMatchSADQCOM";
    case (int)Op::OpImageBlockMatchSSDQCOM:          return "OpImageBlockMatchSSDQCOM";
    case (int)Op::OpImageBlockMatchWindowSSDQCOM:    return "OpImageBlockMatchWindowSSDQCOM";
    case (int)Op::OpImageBlockMatchWindowSADQCOM:    return "OpImageBlockMatchWindowSADQCOM";
    case (int)Op::OpImageBlockMatchGatherSSDQCOM:    return "OpImageBlockMatchGatherSSDQCOM";
    case (int)Op::OpImageBlockMatchGatherSADQCOM:    return "OpImageBlockMatchGatherSADQCOM";

    case (int)Op::OpBitCastArrayQCOM:                return "OpBitCastArrayQCOM";
    case (int)Op::OpCompositeConstructCoopMatQCOM:   return "OpCompositeConstructCoopMatQCOM";
    case (int)Op::OpCompositeExtractCoopMatQCOM:     return "OpCompositeExtractCoopMatQCOM";
    case (int)Op::OpExtractSubArrayQCOM:             return "OpExtractSubArrayQCOM";

    case (int)Op::OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
    case (int)Op::OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
    case (int)Op::OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";

    case (int)Op::OpSDotKHR: return "OpSDotKHR";
    case (int)Op::OpUDotKHR: return "OpUDotKHR";
    case (int)Op::OpSUDotKHR: return "OpSUDotKHR";
    case (int)Op::OpSDotAccSatKHR: return "OpSDotAccSatKHR";
    case (int)Op::OpUDotAccSatKHR: return "OpUDotAccSatKHR";
    case (int)Op::OpSUDotAccSatKHR: return "OpSUDotAccSatKHR";

    case (int)Op::OpTypeHitObjectEXT:                     return "OpTypeHitObjectEXT";
    case (int)Op::OpHitObjectTraceRayEXT:                 return "OpHitObjectTraceRayEXT";
    case (int)Op::OpHitObjectTraceRayMotionEXT:           return "OpHitObjectTraceRayMotionEXT";
    case (int)Op::OpHitObjectRecordMissEXT:               return "OpHitObjectRecordMissEXT";
    case (int)Op::OpHitObjectRecordMissMotionEXT:         return "OpHitObjectRecordMissMotionEXT";
    case (int)Op::OpHitObjectRecordEmptyEXT:              return "OpHitObjectRecordEmptyEXT";
    case (int)Op::OpHitObjectExecuteShaderEXT:            return "OpHitObjectExecuteShaderEXT";
    case (int)Op::OpReorderThreadWithHintEXT:             return "OpReorderThreadWithHintEXT";
    case (int)Op::OpReorderThreadWithHitObjectEXT:        return "OpReorderThreadWithHitObjectEXT";
    case (int)Op::OpHitObjectGetCurrentTimeEXT:           return "OpHitObjectGetCurrentTimeEXT";
    case (int)Op::OpHitObjectGetAttributesEXT:            return "OpHitObjectGetAttributesEXT";
    case (int)Op::OpHitObjectGetHitKindEXT:               return "OpHitObjectGetHitKindEXT";
    case (int)Op::OpHitObjectGetPrimitiveIndexEXT:        return "OpHitObjectGetPrimitiveIndexEXT";
    case (int)Op::OpHitObjectGetGeometryIndexEXT:         return "OpHitObjectGetGeometryIndexEXT";
    case (int)Op::OpHitObjectGetInstanceIdEXT:            return "OpHitObjectGetInstanceIdEXT";
    case (int)Op::OpHitObjectGetInstanceCustomIndexEXT:   return "OpHitObjectGetInstanceCustomIndexEXT";
    case (int)Op::OpHitObjectGetObjectRayDirectionEXT:    return "OpHitObjectGetObjectRayDirectionEXT";
    case (int)Op::OpHitObjectGetObjectRayOriginEXT:       return "OpHitObjectGetObjectRayOriginEXT";
    case (int)Op::OpHitObjectGetWorldRayDirectionEXT:     return "OpHitObjectGetWorldRayDirectionEXT";
    case (int)Op::OpHitObjectGetWorldRayOriginEXT:        return "OpHitObjectGetWorldRayOriginEXT";
    case (int)Op::OpHitObjectGetWorldToObjectEXT:         return "OpHitObjectGetWorldToObjectEXT";
    case (int)Op::OpHitObjectGetObjectToWorldEXT:         return "OpHitObjectGetObjectToWorldEXT";
    case (int)Op::OpHitObjectGetRayTMaxEXT:               return "OpHitObjectGetRayTMaxEXT";
    case (int)Op::OpHitObjectGetRayTMinEXT:               return "OpHitObjectGetRayTMinEXT";
    case (int)Op::OpHitObjectGetRayFlagsEXT:              return "OpHitObjectGetRayFlagsEXT";
    case (int)Op::OpHitObjectIsEmptyEXT:                  return "OpHitObjectIsEmptyEXT";
    case (int)Op::OpHitObjectIsHitEXT:                    return "OpHitObjectIsHitEXT";
    case (int)Op::OpHitObjectIsMissEXT:                   return "OpHitObjectIsMissEXT";
    case (int)Op::OpHitObjectGetShaderBindingTableRecordIndexEXT: return "OpHitObjectGetShaderBindingTableRecordIndexEXT";
    case (int)Op::OpHitObjectGetShaderRecordBufferHandleEXT:   return "OpHitObjectGetShaderRecordBufferHandleEXT";
    case (int)Op::OpHitObjectSetShaderBindingTableRecordIndexEXT: return "OpHitObjectSetShaderBindingTableRecordIndexEXT";
    case (int)Op::OpHitObjectReorderExecuteShaderEXT:     return "OpHitObjectReorderExecuteEXT";
    case (int)Op::OpHitObjectTraceReorderExecuteEXT:      return "OpHitObjectTraceReorderExecuteEXT";
    case (int)Op::OpHitObjectTraceMotionReorderExecuteEXT: return "OpHitObjectTraceMotionReorderExecuteEXT";
    case (int)Op::OpHitObjectRecordFromQueryEXT:          return "OpHitObjectRecordFromQueryEXT";
    case (int)Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT: return "OpHitObjectGetIntersectionTriangleVertexPositionsEXT";

    case (int)Op::OpBitcastExtractEXT:                    return "OpBitcastExtractEXT";

    default:
        return "Bad";
    }
}

// The set of objects that hold all the instruction/operand
// parameterization information.
InstructionParameters InstructionDesc[OpCodeMask + 1];
OperandParameters ExecutionModeOperands[ExecutionModeCeiling];
OperandParameters DecorationOperands[DecorationCeiling];

EnumDefinition OperandClassParams[OperandCount];
EnumParameters ExecutionModeParams[ExecutionModeCeiling];
EnumParameters ImageOperandsParams[ImageOperandsCeiling];
EnumParameters DecorationParams[DecorationCeiling];
EnumParameters LoopControlParams[FunctionControlCeiling];
EnumParameters SelectionControlParams[SelectControlCeiling];
EnumParameters FunctionControlParams[FunctionControlCeiling];
EnumParameters MemoryAccessParams[MemoryAccessCeiling];
EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling];
EnumParameters TensorAddressingOperandsParams[TensorAddressingOperandsCeiling];

// Set up all the parameterizing descriptions of the opcodes, operands, etc.
void Parameterize()
{
    // only do this once.
    static std::once_flag initialized;
    std::call_once(initialized, [](){

        // Exceptions to having a result <id> and a resulting type <id>.
        // (Everything is initialized to have both).

        InstructionDesc[enumCast(Op::OpNop)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSource)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSourceContinued)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSourceExtension)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpExtension)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpExtInstImport)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpCapability)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemoryModel)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEntryPoint)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpExecutionMode)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpExecutionModeId)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeVoid)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeBool)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeInt)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeFloat)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeVector)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeMatrix)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeImage)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeSampler)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeSampledImage)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeArray)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeRuntimeArray)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeStruct)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeOpaque)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypePointer)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeUntypedPointerKHR)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeFunction)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeEvent)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeDeviceEvent)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeReserveId)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeQueue)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypePipe)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpFunctionEnd)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpStore)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpImageWrite)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpDecorationGroup)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpDecorate)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpDecorateId)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemberDecorate)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpGroupDecorate)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpName)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemberName)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpString)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpLine)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpNoLine)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCopyMemory)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEmitVertex)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEndPrimitive)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEmitStreamVertex)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEndStreamPrimitive)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpControlBarrier)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemoryBarrier)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpAtomicStore)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpLoopMerge)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSelectionMerge)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpLabel)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpBranch)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpBranchConditional)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSwitch)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpKill)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTerminateInvocation)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpReturn)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpReturnValue)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpUnreachable)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpLifetimeStart)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpLifetimeStop)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpRetainEvent)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpReleaseEvent)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpModuleProcessed)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpBeginInvocationInterlockEXT)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpEndInvocationInterlockEXT)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpAssumeTrueKHR)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].setResultAndType(false, false);
        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTypeTensorARM)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTensorReadARM)].setResultAndType(true, true);
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].setResultAndType(false, false);

        // Specific additional context-dependent operands

        ExecutionModeOperands[enumCast(ExecutionMode::Invocations)].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");

        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'x size'");
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'y size'");
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSize)].push(OperandLiteralNumber, "'z size'");

        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'x size'");
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'y size'");
        ExecutionModeOperands[enumCast(ExecutionMode::LocalSizeHint)].push(OperandLiteralNumber, "'z size'");

        ExecutionModeOperands[enumCast(ExecutionMode::OutputVertices)].push(OperandLiteralNumber, "'Vertex count'");
        ExecutionModeOperands[enumCast(ExecutionMode::VecTypeHint)].push(OperandLiteralNumber, "'Vector type'");

        DecorationOperands[enumCast(Decoration::Stream)].push(OperandLiteralNumber, "'Stream Number'");
        DecorationOperands[enumCast(Decoration::Location)].push(OperandLiteralNumber, "'Location'");
        DecorationOperands[enumCast(Decoration::Component)].push(OperandLiteralNumber, "'Component'");
        DecorationOperands[enumCast(Decoration::Index)].push(OperandLiteralNumber, "'Index'");
        DecorationOperands[enumCast(Decoration::Binding)].push(OperandLiteralNumber, "'Binding Point'");
        DecorationOperands[enumCast(Decoration::DescriptorSet)].push(OperandLiteralNumber, "'Descriptor Set'");
        DecorationOperands[enumCast(Decoration::Offset)].push(OperandLiteralNumber, "'Byte Offset'");
        DecorationOperands[enumCast(Decoration::XfbBuffer)].push(OperandLiteralNumber, "'XFB Buffer Number'");
        DecorationOperands[enumCast(Decoration::XfbStride)].push(OperandLiteralNumber, "'XFB Stride'");
        DecorationOperands[enumCast(Decoration::ArrayStride)].push(OperandLiteralNumber, "'Array Stride'");
        DecorationOperands[enumCast(Decoration::MatrixStride)].push(OperandLiteralNumber, "'Matrix Stride'");
        DecorationOperands[enumCast(Decoration::BuiltIn)].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
        DecorationOperands[enumCast(Decoration::FPRoundingMode)].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
        DecorationOperands[enumCast(Decoration::FPFastMathMode)].push(OperandFPFastMath, "'Fast-Math Mode'");
        DecorationOperands[enumCast(Decoration::LinkageAttributes)].push(OperandLiteralString, "'Name'");
        DecorationOperands[enumCast(Decoration::LinkageAttributes)].push(OperandLinkageType, "'Linkage Type'");
        DecorationOperands[enumCast(Decoration::FuncParamAttr)].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
        DecorationOperands[enumCast(Decoration::SpecId)].push(OperandLiteralNumber, "'Specialization Constant ID'");
        DecorationOperands[enumCast(Decoration::InputAttachmentIndex)].push(OperandLiteralNumber, "'Attachment Index'");
        DecorationOperands[enumCast(Decoration::Alignment)].push(OperandLiteralNumber, "'Alignment'");

        OperandClassParams[OperandSource].set(0, SourceString, nullptr);
        OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
        OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
        OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
        OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
        OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
        OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
        OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
        OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
        OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
        OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
        OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
        OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
        OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
        OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
        OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
        OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
        OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
        OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
        OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
        OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
        OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
        OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
        OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
        OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
        OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
        OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
        OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
        OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
        OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
        OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
        OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
        OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true);
        OperandClassParams[OperandTensorAddressingOperands].set(TensorAddressingOperandsCeiling, TensorAddressingOperandsString, TensorAddressingOperandsParams, true);
        OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);

        // set name of operator, an initial set of <id> style operands, and the description

        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandSource, "");
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandLiteralNumber, "'Version'");
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandId, "'File'", true);
        InstructionDesc[enumCast(Op::OpSource)].operands.push(OperandLiteralString, "'Source'", true);

        InstructionDesc[enumCast(Op::OpSourceContinued)].operands.push(OperandLiteralString, "'Continued Source'");

        InstructionDesc[enumCast(Op::OpSourceExtension)].operands.push(OperandLiteralString, "'Extension'");

        InstructionDesc[enumCast(Op::OpName)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpName)].operands.push(OperandLiteralString, "'Name'");

        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandId, "'Type'");
        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandLiteralNumber, "'Member'");
        InstructionDesc[enumCast(Op::OpMemberName)].operands.push(OperandLiteralString, "'Name'");

        InstructionDesc[enumCast(Op::OpString)].operands.push(OperandLiteralString, "'String'");

        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandId, "'File'");
        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandLiteralNumber, "'Line'");
        InstructionDesc[enumCast(Op::OpLine)].operands.push(OperandLiteralNumber, "'Column'");

        InstructionDesc[enumCast(Op::OpExtension)].operands.push(OperandLiteralString, "'Name'");

        InstructionDesc[enumCast(Op::OpExtInstImport)].operands.push(OperandLiteralString, "'Name'");

        InstructionDesc[enumCast(Op::OpCapability)].operands.push(OperandCapability, "'Capability'");

        InstructionDesc[enumCast(Op::OpMemoryModel)].operands.push(OperandAddressing, "");
        InstructionDesc[enumCast(Op::OpMemoryModel)].operands.push(OperandMemory, "");

        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandExecutionModel, "");
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandId, "'Entry Point'");
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandLiteralString, "'Name'");
        InstructionDesc[enumCast(Op::OpEntryPoint)].operands.push(OperandVariableIds, "'Interface'");

        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandId, "'Entry Point'");
        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandExecutionMode, "'Mode'");
        InstructionDesc[enumCast(Op::OpExecutionMode)].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");

        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandId, "'Entry Point'");
        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandExecutionMode, "'Mode'");
        InstructionDesc[enumCast(Op::OpExecutionModeId)].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");

        InstructionDesc[enumCast(Op::OpTypeInt)].operands.push(OperandLiteralNumber, "'Width'");
        InstructionDesc[enumCast(Op::OpTypeInt)].operands.push(OperandLiteralNumber, "'Signedness'");

        InstructionDesc[enumCast(Op::OpTypeFloat)].operands.push(OperandLiteralNumber, "'Width'");
        InstructionDesc[enumCast(Op::OpTypeFloat)].operands.push(OperandOptionalLiteral, "'FP Encoding'");

        InstructionDesc[enumCast(Op::OpTypeVector)].operands.push(OperandId, "'Component Type'");
        InstructionDesc[enumCast(Op::OpTypeVector)].operands.push(OperandLiteralNumber, "'Component Count'");

        InstructionDesc[enumCast(Op::OpTypeMatrix)].operands.push(OperandId, "'Column Type'");
        InstructionDesc[enumCast(Op::OpTypeMatrix)].operands.push(OperandLiteralNumber, "'Column Count'");

        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandId, "'Sampled Type'");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandDimensionality, "");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Depth'");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Arrayed'");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'MS'");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandLiteralNumber, "'Sampled'");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandSamplerImageFormat, "");
        InstructionDesc[enumCast(Op::OpTypeImage)].operands.push(OperandAccessQualifier, "", true);

        InstructionDesc[enumCast(Op::OpTypeSampledImage)].operands.push(OperandId, "'Image Type'");

        InstructionDesc[enumCast(Op::OpTypeArray)].operands.push(OperandId, "'Element Type'");
        InstructionDesc[enumCast(Op::OpTypeArray)].operands.push(OperandId, "'Length'");

        InstructionDesc[enumCast(Op::OpTypeRuntimeArray)].operands.push(OperandId, "'Element Type'");

        InstructionDesc[enumCast(Op::OpTypeStruct)].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");

        InstructionDesc[enumCast(Op::OpTypeOpaque)].operands.push(OperandLiteralString, "The name of the opaque type.");
        InstructionDesc[enumCast(Op::OpTypeUntypedPointerKHR)].operands.push(OperandStorage, "");

        InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandStorage, "");
        InstructionDesc[enumCast(Op::OpTypePointer)].operands.push(OperandId, "'Type'");

        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].operands.push(OperandId, "'Pointer Type'");
        InstructionDesc[enumCast(Op::OpTypeForwardPointer)].operands.push(OperandStorage, "");

        InstructionDesc[enumCast(Op::OpTypePipe)].operands.push(OperandAccessQualifier, "'Qualifier'");

        InstructionDesc[enumCast(Op::OpTypeFunction)].operands.push(OperandId, "'Return Type'");
        InstructionDesc[enumCast(Op::OpTypeFunction)].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");

        InstructionDesc[enumCast(Op::OpConstant)].operands.push(OperandVariableLiterals, "'Value'");

        InstructionDesc[enumCast(Op::OpConstantComposite)].operands.push(OperandVariableIds, "'Constituents'");

        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandSamplerAddressingMode, "");
        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandLiteralNumber, "'Param'");
        InstructionDesc[enumCast(Op::OpConstantSampler)].operands.push(OperandSamplerFilterMode, "");

        InstructionDesc[enumCast(Op::OpSpecConstant)].operands.push(OperandVariableLiterals, "'Value'");

        InstructionDesc[enumCast(Op::OpSpecConstantComposite)].operands.push(OperandVariableIds, "'Constituents'");

        InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandLiteralNumber, "'Opcode'");
        InstructionDesc[enumCast(Op::OpSpecConstantOp)].operands.push(OperandVariableIds, "'Operands'");

        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandStorage, "");
        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandId, "'Type'", true);
        InstructionDesc[enumCast(Op::OpUntypedVariableKHR)].operands.push(OperandId, "'Initializer'", true);
        InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandStorage, "");
        InstructionDesc[enumCast(Op::OpVariable)].operands.push(OperandId, "'Initializer'", true);

        InstructionDesc[enumCast(Op::OpFunction)].operands.push(OperandFunction, "");
        InstructionDesc[enumCast(Op::OpFunction)].operands.push(OperandId, "'Function Type'");

        InstructionDesc[enumCast(Op::OpFunctionCall)].operands.push(OperandId, "'Function'");
        InstructionDesc[enumCast(Op::OpFunctionCall)].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");

        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandId, "'Set'");
        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandLiteralNumber, "'Instruction'");
        InstructionDesc[enumCast(Op::OpExtInst)].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");

        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandId, "'Set'");
        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandLiteralNumber, "'Instruction'");
        InstructionDesc[enumCast(Op::OpExtInstWithForwardRefsKHR)].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");

        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandMemoryAccess, "", true);
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpLoad)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandMemoryAccess, "", true);
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpStore)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpPhi)].operands.push(OperandVariableIds, "'Variable, Parent, ...'");

        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpDecorate)].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");

        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpDecorateId)].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");

        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpDecorateStringGOOGLE)].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");

        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandId, "'Structure Type'");
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandLiteralNumber, "'Member'");
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpMemberDecorate)].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");

        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandId, "'Structure Type'");
        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandLiteralNumber, "'Member'");
        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpMemberDecorateIdEXT)].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");

        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandId, "'Structure Type'");
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandLiteralNumber, "'Member'");
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandDecoration, "");
        InstructionDesc[enumCast(Op::OpMemberDecorateStringGOOGLE)].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");

        InstructionDesc[enumCast(Op::OpGroupDecorate)].operands.push(OperandId, "'Decoration Group'");
        InstructionDesc[enumCast(Op::OpGroupDecorate)].operands.push(OperandVariableIds, "'Targets'");

        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].operands.push(OperandId, "'Decoration Group'");
        InstructionDesc[enumCast(Op::OpGroupMemberDecorate)].operands.push(OperandVariableIdLiteral, "'Targets'");

        InstructionDesc[enumCast(Op::OpVectorExtractDynamic)].operands.push(OperandId, "'Vector'");
        InstructionDesc[enumCast(Op::OpVectorExtractDynamic)].operands.push(OperandId, "'Index'");

        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Vector'");
        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Component'");
        InstructionDesc[enumCast(Op::OpVectorInsertDynamic)].operands.push(OperandId, "'Index'");

        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandId, "'Vector 1'");
        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandId, "'Vector 2'");
        InstructionDesc[enumCast(Op::OpVectorShuffle)].operands.push(OperandVariableLiterals, "'Components'");

        InstructionDesc[enumCast(Op::OpCompositeConstruct)].operands.push(OperandVariableIds, "'Constituents'");

        InstructionDesc[enumCast(Op::OpCompositeExtract)].operands.push(OperandId, "'Composite'");
        InstructionDesc[enumCast(Op::OpCompositeExtract)].operands.push(OperandVariableLiterals, "'Indexes'");

        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandId, "'Composite'");
        InstructionDesc[enumCast(Op::OpCompositeInsert)].operands.push(OperandVariableLiterals, "'Indexes'");

        InstructionDesc[enumCast(Op::OpCopyObject)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandId, "'Source'");
        InstructionDesc[enumCast(Op::OpCopyMemory)].operands.push(OperandMemoryAccess, "", true);

        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Target'");
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Source'");
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandId, "'Size'");
        InstructionDesc[enumCast(Op::OpCopyMemorySized)].operands.push(OperandMemoryAccess, "", true);

        InstructionDesc[enumCast(Op::OpSampledImage)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpSampledImage)].operands.push(OperandId, "'Sampler'");

        InstructionDesc[enumCast(Op::OpImage)].operands.push(OperandId, "'Sampled Image'");

        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageRead)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandId, "'Texel'");
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageWrite)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleDrefImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleDrefExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleProjImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleProjExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleProjDrefExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageFetch)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandId, "'Component'");
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageGather)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageDrefGather)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleDrefExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefImplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseSampleProjDrefExplicitLod)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseFetch)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandId, "'Component'");
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseGather)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandId, "'D~ref~'");
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseDrefGather)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSparseRead)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpImageSparseTexelsResident)].operands.push(OperandId, "'Resident Code'");

        InstructionDesc[enumCast(Op::OpImageQuerySizeLod)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageQuerySizeLod)].operands.push(OperandId, "'Level of Detail'");

        InstructionDesc[enumCast(Op::OpImageQuerySize)].operands.push(OperandId, "'Image'");

        InstructionDesc[enumCast(Op::OpImageQueryLod)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageQueryLod)].operands.push(OperandId, "'Coordinate'");

        InstructionDesc[enumCast(Op::OpImageQueryLevels)].operands.push(OperandId, "'Image'");

        InstructionDesc[enumCast(Op::OpImageQuerySamples)].operands.push(OperandId, "'Image'");

        InstructionDesc[enumCast(Op::OpImageQueryFormat)].operands.push(OperandId, "'Image'");

        InstructionDesc[enumCast(Op::OpImageQueryOrder)].operands.push(OperandId, "'Image'");

        InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpAccessChain)].operands.push(OperandVariableIds, "'Indexes'");

        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandId, "'Base Type'");
        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpUntypedAccessChainKHR)].operands.push(OperandVariableIds, "'Indexes'");
        InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpInBoundsAccessChain)].operands.push(OperandVariableIds, "'Indexes'");

        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandId, "'Element'");
        InstructionDesc[enumCast(Op::OpPtrAccessChain)].operands.push(OperandVariableIds, "'Indexes'");

        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandId, "'Element'");
        InstructionDesc[enumCast(Op::OpInBoundsPtrAccessChain)].operands.push(OperandVariableIds, "'Indexes'");

        InstructionDesc[enumCast(Op::OpSNegate)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpFNegate)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpNot)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpAny)].operands.push(OperandId, "'Vector'");

        InstructionDesc[enumCast(Op::OpAll)].operands.push(OperandId, "'Vector'");

        InstructionDesc[enumCast(Op::OpConvertFToU)].operands.push(OperandId, "'Float Value'");

        InstructionDesc[enumCast(Op::OpConvertFToS)].operands.push(OperandId, "'Float Value'");

        InstructionDesc[enumCast(Op::OpConvertSToF)].operands.push(OperandId, "'Signed Value'");

        InstructionDesc[enumCast(Op::OpConvertUToF)].operands.push(OperandId, "'Unsigned Value'");

        InstructionDesc[enumCast(Op::OpUConvert)].operands.push(OperandId, "'Unsigned Value'");

        InstructionDesc[enumCast(Op::OpSConvert)].operands.push(OperandId, "'Signed Value'");

        InstructionDesc[enumCast(Op::OpFConvert)].operands.push(OperandId, "'Float Value'");

        InstructionDesc[enumCast(Op::OpSatConvertSToU)].operands.push(OperandId, "'Signed Value'");

        InstructionDesc[enumCast(Op::OpSatConvertUToS)].operands.push(OperandId, "'Unsigned Value'");

        InstructionDesc[enumCast(Op::OpConvertPtrToU)].operands.push(OperandId, "'Pointer'");

        InstructionDesc[enumCast(Op::OpConvertUToPtr)].operands.push(OperandId, "'Integer Value'");

        InstructionDesc[enumCast(Op::OpPtrCastToGeneric)].operands.push(OperandId, "'Pointer'");

        InstructionDesc[enumCast(Op::OpGenericCastToPtr)].operands.push(OperandId, "'Pointer'");

        InstructionDesc[enumCast(Op::OpGenericCastToPtrExplicit)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpGenericCastToPtrExplicit)].operands.push(OperandStorage, "'Storage'");

        InstructionDesc[enumCast(Op::OpGenericPtrMemSemantics)].operands.push(OperandId, "'Pointer'");

        InstructionDesc[enumCast(Op::OpBitcast)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpQuantizeToF16)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpTranspose)].operands.push(OperandId, "'Matrix'");

        InstructionDesc[enumCast(Op::OpCopyLogical)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpIsNan)].operands.push(OperandId, "'x'");

        InstructionDesc[enumCast(Op::OpIsInf)].operands.push(OperandId, "'x'");

        InstructionDesc[enumCast(Op::OpIsFinite)].operands.push(OperandId, "'x'");

        InstructionDesc[enumCast(Op::OpIsNormal)].operands.push(OperandId, "'x'");

        InstructionDesc[enumCast(Op::OpSignBitSet)].operands.push(OperandId, "'x'");

        InstructionDesc[enumCast(Op::OpLessOrGreater)].operands.push(OperandId, "'x'");
        InstructionDesc[enumCast(Op::OpLessOrGreater)].operands.push(OperandId, "'y'");

        InstructionDesc[enumCast(Op::OpOrdered)].operands.push(OperandId, "'x'");
        InstructionDesc[enumCast(Op::OpOrdered)].operands.push(OperandId, "'y'");

        InstructionDesc[enumCast(Op::OpUnordered)].operands.push(OperandId, "'x'");
        InstructionDesc[enumCast(Op::OpUnordered)].operands.push(OperandId, "'y'");

        InstructionDesc[enumCast(Op::OpArrayLength)].operands.push(OperandId, "'Structure'");
        InstructionDesc[enumCast(Op::OpArrayLength)].operands.push(OperandLiteralNumber, "'Array member'");

        InstructionDesc[enumCast(Op::OpIAdd)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpIAdd)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFAdd)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFAdd)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpISub)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpISub)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFSub)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFSub)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpIMul)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpIMul)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFMul)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFMul)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpUDiv)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpUDiv)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSDiv)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSDiv)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFDiv)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFDiv)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpUMod)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpUMod)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSRem)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSRem)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSMod)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSMod)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFRem)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFRem)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFMod)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFMod)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpVectorTimesScalar)].operands.push(OperandId, "'Vector'");
        InstructionDesc[enumCast(Op::OpVectorTimesScalar)].operands.push(OperandId, "'Scalar'");

        InstructionDesc[enumCast(Op::OpMatrixTimesScalar)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpMatrixTimesScalar)].operands.push(OperandId, "'Scalar'");

        InstructionDesc[enumCast(Op::OpVectorTimesMatrix)].operands.push(OperandId, "'Vector'");
        InstructionDesc[enumCast(Op::OpVectorTimesMatrix)].operands.push(OperandId, "'Matrix'");

        InstructionDesc[enumCast(Op::OpMatrixTimesVector)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpMatrixTimesVector)].operands.push(OperandId, "'Vector'");

        InstructionDesc[enumCast(Op::OpMatrixTimesMatrix)].operands.push(OperandId, "'LeftMatrix'");
        InstructionDesc[enumCast(Op::OpMatrixTimesMatrix)].operands.push(OperandId, "'RightMatrix'");

        InstructionDesc[enumCast(Op::OpOuterProduct)].operands.push(OperandId, "'Vector 1'");
        InstructionDesc[enumCast(Op::OpOuterProduct)].operands.push(OperandId, "'Vector 2'");

        InstructionDesc[enumCast(Op::OpDot)].operands.push(OperandId, "'Vector 1'");
        InstructionDesc[enumCast(Op::OpDot)].operands.push(OperandId, "'Vector 2'");

        InstructionDesc[enumCast(Op::OpIAddCarry)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpIAddCarry)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpISubBorrow)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpISubBorrow)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpUMulExtended)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpUMulExtended)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSMulExtended)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSMulExtended)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpShiftRightLogical)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpShiftRightLogical)].operands.push(OperandId, "'Shift'");

        InstructionDesc[enumCast(Op::OpShiftRightArithmetic)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpShiftRightArithmetic)].operands.push(OperandId, "'Shift'");

        InstructionDesc[enumCast(Op::OpShiftLeftLogical)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpShiftLeftLogical)].operands.push(OperandId, "'Shift'");

        InstructionDesc[enumCast(Op::OpLogicalOr)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpLogicalOr)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpLogicalAnd)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpLogicalAnd)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpLogicalEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpLogicalEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpLogicalNotEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpLogicalNotEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpLogicalNot)].operands.push(OperandId, "'Operand'");

        InstructionDesc[enumCast(Op::OpBitwiseOr)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpBitwiseOr)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpBitwiseXor)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpBitwiseXor)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpBitwiseAnd)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpBitwiseAnd)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Insert'");
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpBitFieldInsert)].operands.push(OperandId, "'Count'");

        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpBitFieldSExtract)].operands.push(OperandId, "'Count'");

        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpBitFieldUExtract)].operands.push(OperandId, "'Count'");

        InstructionDesc[enumCast(Op::OpBitReverse)].operands.push(OperandId, "'Base'");

        InstructionDesc[enumCast(Op::OpBitCount)].operands.push(OperandId, "'Base'");

        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Condition'");
        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Object 1'");
        InstructionDesc[enumCast(Op::OpSelect)].operands.push(OperandId, "'Object 2'");

        InstructionDesc[enumCast(Op::OpIEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpIEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpINotEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpINotEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdNotEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdNotEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordNotEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordNotEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpULessThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpULessThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSLessThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSLessThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdLessThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdLessThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordLessThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordLessThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpUGreaterThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpUGreaterThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSGreaterThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSGreaterThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdGreaterThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdGreaterThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordGreaterThan)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordGreaterThan)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpULessThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpULessThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSLessThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSLessThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdLessThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdLessThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordLessThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordLessThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpUGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpUGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpSGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpSGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFOrdGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFOrdGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpFUnordGreaterThanEqual)].operands.push(OperandId, "'Operand 1'");
        InstructionDesc[enumCast(Op::OpFUnordGreaterThanEqual)].operands.push(OperandId, "'Operand 2'");

        InstructionDesc[enumCast(Op::OpDPdx)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpDPdy)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpFwidth)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpDPdxFine)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpDPdyFine)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpFwidthFine)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpDPdxCoarse)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpDPdyCoarse)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpFwidthCoarse)].operands.push(OperandId, "'P'");

        InstructionDesc[enumCast(Op::OpEmitStreamVertex)].operands.push(OperandId, "'Stream'");

        InstructionDesc[enumCast(Op::OpEndStreamPrimitive)].operands.push(OperandId, "'Stream'");

        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandScope, "'Memory'");
        InstructionDesc[enumCast(Op::OpControlBarrier)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpMemoryBarrier)].operands.push(OperandScope, "'Memory'");
        InstructionDesc[enumCast(Op::OpMemoryBarrier)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageTexelPointer)].operands.push(OperandId, "'Sample'");

        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicLoad)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicStore)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicExchange)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandMemorySemantics, "'Equal'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandMemorySemantics, "'Unequal'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchange)].operands.push(OperandId, "'Comparator'");

        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandMemorySemantics, "'Equal'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandMemorySemantics, "'Unequal'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpAtomicCompareExchangeWeak)].operands.push(OperandId, "'Comparator'");

        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicIIncrement)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicIDecrement)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicIAdd)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicFAddEXT)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAssumeTrueKHR)].operands.push(OperandId, "'Condition'");

        InstructionDesc[enumCast(Op::OpExpectKHR)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpExpectKHR)].operands.push(OperandId, "'ExpectedValue'");

        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicISub)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicUMin)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicUMax)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicSMin)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicSMax)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicFMinEXT)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicFMaxEXT)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicAnd)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicOr)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandMemorySemantics, "'Semantics'");
        InstructionDesc[enumCast(Op::OpAtomicXor)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicFlagTestAndSet)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandScope, "'Scope'");
        InstructionDesc[enumCast(Op::OpAtomicFlagClear)].operands.push(OperandMemorySemantics, "'Semantics'");

        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandId, "'Merge Block'");
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandId, "'Continue Target'");
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandLoop, "");
        InstructionDesc[enumCast(Op::OpLoopMerge)].operands.push(OperandOptionalLiteral, "");

        InstructionDesc[enumCast(Op::OpSelectionMerge)].operands.push(OperandId, "'Merge Block'");
        InstructionDesc[enumCast(Op::OpSelectionMerge)].operands.push(OperandSelect, "");

        InstructionDesc[enumCast(Op::OpBranch)].operands.push(OperandId, "'Target Label'");

        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'Condition'");
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'True Label'");
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandId, "'False Label'");
        InstructionDesc[enumCast(Op::OpBranchConditional)].operands.push(OperandVariableLiterals, "'Branch weights'");

        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandId, "'Selector'");
        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandId, "'Default'");
        InstructionDesc[enumCast(Op::OpSwitch)].operands.push(OperandVariableLiteralId, "'Target'");


        InstructionDesc[enumCast(Op::OpReturnValue)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpLifetimeStart)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpLifetimeStart)].operands.push(OperandLiteralNumber, "'Size'");

        InstructionDesc[enumCast(Op::OpLifetimeStop)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpLifetimeStop)].operands.push(OperandLiteralNumber, "'Size'");

        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Destination'");
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Source'");
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Num Elements'");
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Stride'");
        InstructionDesc[enumCast(Op::OpGroupAsyncCopy)].operands.push(OperandId, "'Event'");

        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandId, "'Num Events'");
        InstructionDesc[enumCast(Op::OpGroupWaitEvents)].operands.push(OperandId, "'Events List'");

        InstructionDesc[enumCast(Op::OpGroupAll)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupAll)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpGroupAny)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupAny)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpGroupBroadcast)].operands.push(OperandId, "'LocalId'");

        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupIAdd)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFAdd)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupUMin)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupSMin)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFMin)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupUMax)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupSMax)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFMax)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpReadPipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpWritePipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Index'");
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpReservedReadPipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Index'");
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpReservedWritePipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Num Packets'");
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpReserveReadPipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Num Packets'");
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpReserveWritePipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpCommitReadPipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpCommitWritePipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpIsValidReserveId)].operands.push(OperandId, "'Reserve Id'");

        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGetNumPipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGetMaxPipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Num Packets'");
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGroupReserveReadPipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Num Packets'");
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGroupReserveWritePipePackets)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGroupCommitReadPipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Pipe'");
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Reserve Id'");
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Packet Size'");
        InstructionDesc[enumCast(Op::OpGroupCommitWritePipe)].operands.push(OperandId, "'Packet Alignment'");

        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'GlobalWorkSize'");
        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'LocalWorkSize'");
        InstructionDesc[enumCast(Op::OpBuildNDRange)].operands.push(OperandId, "'GlobalWorkOffset'");

        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Event'");
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Profiling Info'");
        InstructionDesc[enumCast(Op::OpCaptureEventProfilingInfo)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].operands.push(OperandId, "'Event'");
        InstructionDesc[enumCast(Op::OpSetUserEventStatus)].operands.push(OperandId, "'Status'");

        InstructionDesc[enumCast(Op::OpIsValidEvent)].operands.push(OperandId, "'Event'");

        InstructionDesc[enumCast(Op::OpRetainEvent)].operands.push(OperandId, "'Event'");

        InstructionDesc[enumCast(Op::OpReleaseEvent)].operands.push(OperandId, "'Event'");

        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Invoke'");
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param'");
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param Size'");
        InstructionDesc[enumCast(Op::OpGetKernelWorkGroupSize)].operands.push(OperandId, "'Param Align'");

        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Invoke'");
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param'");
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param Size'");
        InstructionDesc[enumCast(Op::OpGetKernelPreferredWorkGroupSizeMultiple)].operands.push(OperandId, "'Param Align'");

        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'ND Range'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Invoke'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param Size'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeSubGroupCount)].operands.push(OperandId, "'Param Align'");

        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'ND Range'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Invoke'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param Size'");
        InstructionDesc[enumCast(Op::OpGetKernelNDrangeMaxSubGroupSize)].operands.push(OperandId, "'Param Align'");

        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Queue'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Flags'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'ND Range'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Num Events'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Wait Events'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Ret Event'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Invoke'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param Size'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandId, "'Param Align'");
        InstructionDesc[enumCast(Op::OpEnqueueKernel)].operands.push(OperandVariableIds, "'Local Size'");

        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Queue'");
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Num Events'");
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Wait Events'");
        InstructionDesc[enumCast(Op::OpEnqueueMarker)].operands.push(OperandId, "'Ret Event'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformElect)].operands.push(OperandScope, "'Execution'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformAll)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformAll)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformAny)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformAny)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformAllEqual)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformAllEqual)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcast)].operands.push(OperandId, "ID");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcastFirst)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBroadcastFirst)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBallot)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallot)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformInverseBallot)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformInverseBallot)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitExtract)].operands.push(OperandId, "Bit");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotBitCount)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindLSB)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindLSB)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindMSB)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBallotFindMSB)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffle)].operands.push(OperandId, "'Id'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleXor)].operands.push(OperandId, "Mask");

        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleUp)].operands.push(OperandId, "Offset");

        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformShuffleDown)].operands.push(OperandId, "Offset");

        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIAdd)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFAdd)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformIMul)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMul)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMin)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMin)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMin)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformSMax)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformUMax)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformFMax)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseAnd)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseOr)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformBitwiseXor)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalAnd)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalOr)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformLogicalXor)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadBroadcast)].operands.push(OperandId, "'Id'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandId, "X");
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadSwap)].operands.push(OperandId, "'Direction'");

        InstructionDesc[enumCast(Op::OpSubgroupBallotKHR)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpSubgroupFirstInvocationKHR)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpSubgroupAnyKHR)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpSubgroupAnyKHR)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpSubgroupAllKHR)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpSubgroupAllKHR)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpSubgroupAllEqualKHR)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpSubgroupAllEqualKHR)].operands.push(OperandId, "'Predicate'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'X'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'Delta'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformRotateKHR)].operands.push(OperandId, "'ClusterSize'", true);

        InstructionDesc[enumCast(Op::OpSubgroupReadInvocationKHR)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpSubgroupReadInvocationKHR)].operands.push(OperandId, "'Index'");

        InstructionDesc[enumCast(Op::OpModuleProcessed)].operands.push(OperandLiteralString, "'process'");

        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupIAddNonUniformAMD)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFAddNonUniformAMD)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupUMinNonUniformAMD)].operands.push(OperandId, "'X'");

        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupSMinNonUniformAMD)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFMinNonUniformAMD)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupUMaxNonUniformAMD)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupSMaxNonUniformAMD)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandScope, "'Execution'");
        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandGroupOperation, "'Operation'");
        InstructionDesc[enumCast(Op::OpGroupFMaxNonUniformAMD)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpFragmentMaskFetchAMD)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpFragmentMaskFetchAMD)].operands.push(OperandId, "'Coordinate'");

        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpFragmentFetchAMD)].operands.push(OperandId, "'Fragment Index'");


        InstructionDesc[enumCast(Op::OpTypeBufferEXT)].operands.push(OperandStorage, "");
        InstructionDesc[enumCast(Op::OpTypeBufferEXT)].setResultAndType(true, false);

        InstructionDesc[enumCast(Op::OpConstantSizeOfEXT)].operands.push(OperandId, "'Type'");

        InstructionDesc[enumCast(Op::OpBufferPointerEXT)].operands.push(OperandId, "'Buffer'");

        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'ImageType'");
        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Image'");
        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpUntypedImageTexelPointerEXT)].operands.push(OperandId, "'Sample'");

        InstructionDesc[enumCast(Op::OpGroupNonUniformPartitionNV)].operands.push(OperandId, "X");

        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadAllKHR)].operands.push(OperandId, "'Predicate'");
        InstructionDesc[enumCast(Op::OpGroupNonUniformQuadAnyKHR)].operands.push(OperandId, "'Predicate'");
        InstructionDesc[enumCast(Op::OpTypeAccelerationStructureKHR)].setResultAndType(true, false);

        InstructionDesc[enumCast(Op::OpConstantDataKHR)].operands.push(OperandLiteralString, "'Data'");
        InstructionDesc[enumCast(Op::OpSpecConstantDataKHR)].operands.push(OperandLiteralString, "'Data'");
        InstructionDesc[enumCast(Op::OpAbortKHR)].operands.push(OperandId, "'Message Type'");
        InstructionDesc[enumCast(Op::OpAbortKHR)].operands.push(OperandId, "'Message'");
        InstructionDesc[enumCast(Op::OpAbortKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Flags'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Cull Mask'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Origin'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Ray Direction'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpTraceNV)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpTraceNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Flags'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Cull Mask'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Origin'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Ray Direction'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Time'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpTraceRayMotionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Flags'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Cull Mask'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Origin'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Ray Direction'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpTraceRayKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpReportIntersectionKHR)].operands.push(OperandId, "'Hit Parameter'");
        InstructionDesc[enumCast(Op::OpReportIntersectionKHR)].operands.push(OperandId, "'Hit Kind'");

        InstructionDesc[enumCast(Op::OpIgnoreIntersectionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpIgnoreIntersectionKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTerminateRayNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpTerminateRayKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].operands.push(OperandId, "SBT Record Index");
        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].operands.push(OperandId, "CallableData ID");
        InstructionDesc[enumCast(Op::OpExecuteCallableNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].operands.push(OperandId, "SBT Record Index");
        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].operands.push(OperandId, "CallableData");
        InstructionDesc[enumCast(Op::OpExecuteCallableKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpConvertUToAccelerationStructureKHR)].operands.push(OperandId, "Value");
        InstructionDesc[enumCast(Op::OpConvertUToAccelerationStructureKHR)].setResultAndType(true, true);

        // Ray Query
        InstructionDesc[enumCast(Op::OpTypeAccelerationStructureKHR)].setResultAndType(true, false);
        InstructionDesc[enumCast(Op::OpTypeRayQueryKHR)].setResultAndType(true, false);

        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'AccelerationS'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'CullMask'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Tmin'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].operands.push(OperandId, "'Tmax'");
        InstructionDesc[enumCast(Op::OpRayQueryInitializeKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpRayQueryTerminateKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryTerminateKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].operands.push(OperandId, "'THit'");
        InstructionDesc[enumCast(Op::OpRayQueryGenerateIntersectionKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpRayQueryConfirmIntersectionKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryConfirmIntersectionKHR)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpRayQueryProceedKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryProceedKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTypeKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetRayTMinKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetRayTMinKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetRayFlagsKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetRayFlagsKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceIdKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionGeometryIndexKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionPrimitiveIndexKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionBarycentricsKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionFrontFaceKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayDirectionKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectRayOriginKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayDirectionKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayDirectionKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayOriginKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetWorldRayOriginKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionObjectToWorldKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionWorldToObjectKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetClusterIdNV)].setResultAndType(true, true);
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSpherePositionNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionSphereRadiusNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSHitValueNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSPositionsNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryGetIntersectionLSSRadiiNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryIsSphereHitNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].operands.push(OperandId, "'Committed'");
        InstructionDesc[enumCast(Op::OpRayQueryIsLSSHitNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Sampled Image'");
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Granularity'");
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandId, "'Coarse'");
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleFootprintNV)].operands.push(OperandVariableIds, "", true);

        InstructionDesc[enumCast(Op::OpWritePackedPrimitiveIndices4x8NV)].operands.push(OperandId, "'Index Offset'");
        InstructionDesc[enumCast(Op::OpWritePackedPrimitiveIndices4x8NV)].operands.push(OperandId, "'Packed Indices'");

        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountX'");
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountY'");
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'groupCountZ'");
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpEmitMeshTasksEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].operands.push(OperandId, "'vertexCount'");
        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].operands.push(OperandId, "'primitiveCount'");
        InstructionDesc[enumCast(Op::OpSetMeshOutputsEXT)].setResultAndType(false, false);


        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Component Type'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Scope'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Rows'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixNV)].operands.push(OperandId, "'Columns'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Stride'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "'Column Major'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadNV)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Stride'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "'Column Major'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreNV)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'A'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'B'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddNV)].operands.push(OperandId, "'C'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixLengthNV)].operands.push(OperandId, "'Type'");

        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Component Type'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Scope'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Rows'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Columns'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeMatrixKHR)].operands.push(OperandId, "'Use'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Memory Layout'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "'Stride'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadKHR)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Memory Layout'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "'Stride'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreKHR)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'A'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'B'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandId, "'C'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixMulAddKHR)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);

        InstructionDesc[enumCast(Op::OpCooperativeMatrixLengthKHR)].operands.push(OperandId, "'Type'");

        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].operands.push(OperandId, "'Component Type'");
        InstructionDesc[enumCast(Op::OpTypeCooperativeVectorNV)].operands.push(OperandId, "'Components'");

        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Input'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'InputInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixOffset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'M'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'K'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MemoryLayout'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'Transpose'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandId, "'MatrixStride'", true);
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulNV)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);

        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Input'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'InputInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixOffset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Bias'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'BiasOffset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'BiasInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'M'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'K'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MemoryLayout'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'Transpose'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandId, "'MatrixStride'", true);
        InstructionDesc[enumCast(Op::OpCooperativeVectorMatrixMulAddNV)].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);

        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeVectorLoadNV)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandLiteralNumber, "", true);
        InstructionDesc[enumCast(Op::OpCooperativeVectorStoreNV)].operands.push(OperandId, "", true);

        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'A'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'B'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MemoryLayout'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MatrixInterpretation'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorOuterProductAccumulateNV)].operands.push(OperandId, "'MatrixStride'", true);

        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'Offset'");
        InstructionDesc[enumCast(Op::OpCooperativeVectorReduceSumAccumulateNV)].operands.push(OperandId, "'V'");

        InstructionDesc[enumCast(Op::OpDemoteToHelperInvocationEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpReadClockKHR)].operands.push(OperandScope, "'Scope'");

        InstructionDesc[enumCast(Op::OpTypeHitObjectNV)].setResultAndType(true, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsHitNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsHitNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsMissNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsMissNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].operands.push(OperandId, "'HitObjectAttribute'");
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'InstanceId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'PrimitiveId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'GeometryIndex'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitKind'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].operands.push(OperandId, "'HitObject Attribute'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'InstanceId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'PrimitiveId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'GeometryIndex'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitKind'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'Current Time'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].operands.push(OperandId, "'HitObject Attribute'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitMotionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'InstanceId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'PrimitiveId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'GeometryIndex'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitKind'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'SBT Record Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].operands.push(OperandId, "'HitObject Attribute'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'InstanceId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'PrimitiveId'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'GeometryIndex'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitKind'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'SBT Record Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'Current Time'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].operands.push(OperandId, "'HitObject Attribute'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordHitWithIndexMotionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'SBT Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'SBT Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].operands.push(OperandId, "'Current Time'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Time'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionNV)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetClusterIdNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetClusterIdNV)].setResultAndType(true, true);
        InstructionDesc[enumCast(Op::OpHitObjectGetSpherePositionNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetSpherePositionNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetSphereRadiusNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetSphereRadiusNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetLSSPositionsNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSPositionsNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetLSSRadiiNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetLSSRadiiNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsSphereHitNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsSphereHitNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsLSSHitNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsLSSHitNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Instance ID'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Geometry Index'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Primitive Index'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].operands.push(OperandId, "'Barycentrics'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexBarycentricNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Instance ID'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Geometry Index'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Primitive Index'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].operands.push(OperandId, "'Barycentrics'");
        InstructionDesc[enumCast(Op::OpFetchMicroTriangleVertexPositionNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpColorAttachmentReadEXT)].operands.push(OperandId, "'Attachment'");
        InstructionDesc[enumCast(Op::OpColorAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);
        InstructionDesc[enumCast(Op::OpStencilAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);
        InstructionDesc[enumCast(Op::OpDepthAttachmentReadEXT)].operands.push(OperandId, "'Sample'", true);

        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'source texture'");
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'texture coordinates'");
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandId, "'weights texture'");
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageSampleWeightedQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'source texture'");
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'texture coordinates'");
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandId, "'box size'");
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBoxFilterQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchSADQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchSSDQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSSDQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchWindowSADQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSSDQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'target texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'target coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'reference texture'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'reference coordinates'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandId, "'block size'");
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].operands.push(OperandImageOperands, "", true);
        InstructionDesc[enumCast(Op::OpImageBlockMatchGatherSADQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].operands.push(OperandId, "'source array'");
        InstructionDesc[enumCast(Op::OpBitCastArrayQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].operands.push(OperandId, "'source array'");
        InstructionDesc[enumCast(Op::OpCompositeConstructCoopMatQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].operands.push(OperandId, "'source cooperative matrix'");
        InstructionDesc[enumCast(Op::OpCompositeExtractCoopMatQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'source array'");
        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].operands.push(OperandId, "'start index'");
        InstructionDesc[enumCast(Op::OpExtractSubArrayQCOM)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpSpecConstantCompositeReplicateEXT)].operands.push(OperandId, "'Value'");
        InstructionDesc[enumCast(Op::OpCompositeConstructReplicateEXT)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixConvertNV)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixTransposeNV)].operands.push(OperandId, "'Matrix'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandLiteralNumber, "'ReduceMask'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'CombineFunc'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandId, "'Operation'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixPerElementOpNV)].operands.push(OperandVariableIds, "'Operands'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixLoadTensorNV)].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'Pointer'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandMemoryAccess, "'Memory Access'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixStoreTensorNV)].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");

        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandId, "'Matrix'");
        InstructionDesc[enumCast(Op::OpCooperativeMatrixReduceNV)].operands.push(OperandLiteralNumber, "'ReduceMask'");

        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].operands.push(OperandId, "'Dim'");
        InstructionDesc[enumCast(Op::OpTypeTensorLayoutNV)].operands.push(OperandId, "'ClampMode'");

        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandId, "'Dim'");
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandId, "'HasDimensions'");
        InstructionDesc[enumCast(Op::OpTypeTensorViewNV)].operands.push(OperandVariableIds, "'p'");

        InstructionDesc[enumCast(Op::OpTensorLayoutSetBlockSizeNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpTensorLayoutSetBlockSizeNV)].operands.push(OperandVariableIds, "'BlockSize'");

        InstructionDesc[enumCast(Op::OpTensorLayoutSetDimensionNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpTensorLayoutSetDimensionNV)].operands.push(OperandVariableIds, "'Dim'");

        InstructionDesc[enumCast(Op::OpTensorLayoutSetStrideNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpTensorLayoutSetStrideNV)].operands.push(OperandVariableIds, "'Stride'");

        InstructionDesc[enumCast(Op::OpTensorLayoutSliceNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpTensorLayoutSliceNV)].operands.push(OperandVariableIds, "'Operands'");

        InstructionDesc[enumCast(Op::OpTensorLayoutSetClampValueNV)].operands.push(OperandId, "'TensorLayout'");
        InstructionDesc[enumCast(Op::OpTensorLayoutSetClampValueNV)].operands.push(OperandId, "'Value'");

        InstructionDesc[enumCast(Op::OpTensorViewSetDimensionNV)].operands.push(OperandId, "'TensorView'");
        InstructionDesc[enumCast(Op::OpTensorViewSetDimensionNV)].operands.push(OperandVariableIds, "'Dim'");

        InstructionDesc[enumCast(Op::OpTensorViewSetStrideNV)].operands.push(OperandId, "'TensorView'");
        InstructionDesc[enumCast(Op::OpTensorViewSetStrideNV)].operands.push(OperandVariableIds, "'Stride'");

        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'TensorView'");
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipRowOffset'");
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipRowSpan'");
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipColOffset'");
        InstructionDesc[enumCast(Op::OpTensorViewSetClipNV)].operands.push(OperandId, "'ClipColSpan'");

        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpSDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpUDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpSUDotKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
        InstructionDesc[enumCast(Op::OpSDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
        InstructionDesc[enumCast(Op::OpUDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Vector1'");
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Vector2'");
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandId, "'Accumulator'");
        InstructionDesc[enumCast(Op::OpSUDotAccSatKHR)].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");

        InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Element Type'");
        InstructionDesc[enumCast(Op::OpTypeTensorARM)].operands.push(OperandId, "'Rank'");

        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Tensor'");
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true);
        InstructionDesc[enumCast(Op::OpTensorReadARM)].operands.push(OperandVariableIds, "'Tensor Operands'");

        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Tensor'");
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Coordinate'");
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandId, "'Object'");
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandLiteralNumber, "'Tensor Operand'", true);
        InstructionDesc[enumCast(Op::OpTensorWriteARM)].operands.push(OperandVariableIds, "'Tensor Operands'");

        InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Tensor'");
        InstructionDesc[enumCast(Op::OpTensorQuerySizeARM)].operands.push(OperandId, "'Dimension'", true);

        InstructionDesc[enumCast(Op::OpTypeHitObjectEXT)].setResultAndType(true, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleNV)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderRecordBufferHandleEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHintEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpReorderThreadWithHitObjectEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetCurrentTimeEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetHitKindEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetPrimitiveIndexEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetGeometryIndexEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceIdEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetInstanceCustomIndexEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayDirectionEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectRayOriginEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayDirectionEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldRayOriginEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetWorldToObjectEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetObjectToWorldEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMaxEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetRayTMinEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetRayFlagsEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetRayFlagsEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetShaderBindingTableRecordIndexEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsEmptyEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsHitEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsHitEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectIsMissEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectIsMissEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].operands.push(OperandId, "'HitObjectAttribute'");
        InstructionDesc[enumCast(Op::OpHitObjectGetAttributesEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectExecuteShaderEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'SBT Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'SBT Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].operands.push(OperandId, "'Current Time'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordMissMotionEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordEmptyEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Time'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceRayMotionEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].operands.push(OperandId, "'SBT Record Index'");
        InstructionDesc[enumCast(Op::OpHitObjectSetShaderBindingTableRecordIndexEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpHitObjectReorderExecuteShaderEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceReorderExecuteEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Acceleration Structure'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'RayFlags'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Cullmask'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Offset'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'SBT Record Stride'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Miss Index'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Origin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'TMin'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Direction'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'TMax'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Time'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Payload'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Hint'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].operands.push(OperandId, "'Bits'");
        InstructionDesc[enumCast(Op::OpHitObjectTraceMotionReorderExecuteEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'RayQuery'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'SBT Record Index'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'HitObjectAttribute'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].operands.push(OperandId, "'Hit Kind'");
        InstructionDesc[enumCast(Op::OpHitObjectRecordFromQueryEXT)].setResultAndType(false, false);

        InstructionDesc[enumCast(Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT)].operands.push(OperandId, "'HitObject'");
        InstructionDesc[enumCast(Op::OpHitObjectGetIntersectionTriangleVertexPositionsEXT)].setResultAndType(true, true);

        InstructionDesc[enumCast(Op::OpBitcastExtractEXT)].operands.push(OperandId, "'Base'");
        InstructionDesc[enumCast(Op::OpBitcastExtractEXT)].operands.push(OperandId, "'Offset'");
    });
}

} // end spv namespace
