doc.cpp - mozsearch

++ //

++ // 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";

++

++     case (int)Decoration::CooperativeMatrixTransposeEXT: return "DecorationCooperativeMatrixTransposeEXT";

++     }

++ }

++

++ 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 (int)LoopControlShift::MultipleWaitQueuesQCOM: return "MultipeWaitQueuesQCOM";

++

++     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::CooperativeMatrixConversionsEXT:         return "CooperativeMatrixConversionsEXT";

++     case (int)Capability::CooperativeMatrixGetCoordinateEXT:       return "CooperativeMatrixGetCoordinateEXT";

++

++     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::ImageGatherLinearQCOM:               return "ImageGatherLinearQCOM";

++     case (int)Capability::ImageGatherExtendedModesQCOM:        return "ImageGatherExtendedModesQCOM";

++

++     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::SplitBarrierEXT:                     return "SplitBarrierEXT";

++

++     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::OpCooperativeMatrixGetCoordinateEXT: return "OpCooperativeMatrixGetCoordinateEXT";

++

++     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::OpImageGatherQCOM:                 return "OpImageGatherQCOM";

++

++     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";

++     case (int)Op::OpControlBarrierArriveEXT: return "OpControlBarrierArriveEXT";

++     case (int)Op::OpControlBarrierWaitEXT: return "OpControlBarrierWaitEXT";

++

++     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::OpControlBarrierArriveEXT)].setResultAndType(false, false);

++         InstructionDesc[enumCast(Op::OpControlBarrierWaitEXT)].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::OpImageGatherQCOM)].operands.push(OperandId, "'Sampled Image'");

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

++         InstructionDesc[enumCast(Op::OpImageGatherQCOM)].operands.push(OperandId, "'Component'");

++         InstructionDesc[enumCast(Op::OpImageGatherQCOM)].operands.push(OperandId, "'Mode'");

++         InstructionDesc[enumCast(Op::OpImageGatherQCOM)].operands.push(OperandImageOperands, "", true);

++         InstructionDesc[enumCast(Op::OpImageGatherQCOM)].operands.push(OperandVariableIds, "", true);

++         InstructionDesc[enumCast(Op::OpImageGatherQCOM)].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::OpCooperativeMatrixGetCoordinateEXT)].operands.push(OperandId, "'Matrix'");

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

++

++         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'");

++

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

++         InstructionDesc[enumCast(Op::OpControlBarrierArriveEXT)].operands.push(OperandScope, "'Memory'");

++         InstructionDesc[enumCast(Op::OpControlBarrierArriveEXT)].operands.push(OperandMemorySemantics, "'Semantics'");

++

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

++         InstructionDesc[enumCast(Op::OpControlBarrierWaitEXT)].operands.push(OperandScope, "'Memory'");

++         InstructionDesc[enumCast(Op::OpControlBarrierWaitEXT)].operands.push(OperandMemorySemantics, "'Semantics'");

++     });

++ }

++

++ } // end spv namespace

Revision control