//
// Copyright (C) 2014-2015 LunarG, Inc.
//
// 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 <cstdio>
#include <cstring>
#include <algorithm>

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

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";
#ifdef NV_EXTENSIONS
    case ExecutionModelTaskNV: return "TaskNV";
    case ExecutionModelMeshNV: return "MeshNV";
#endif

    default: return "Bad";

#ifdef NV_EXTENSIONS
    case ExecutionModelRayGenerationNV: return "RayGenerationNV";
    case ExecutionModelIntersectionNV:  return "IntersectionNV";
    case ExecutionModelAnyHitNV:        return "AnyHitNV";
    case ExecutionModelClosestHitNV:    return "ClosestHitNV";
    case ExecutionModelMissNV:          return "MissNV";
    case ExecutionModelCallableNV:      return "CallableNV";
#endif

    }
}

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

    case AddressingModelPhysicalStorageBuffer64EXT: return "PhysicalStorageBuffer64EXT";

    default: return "Bad";
    }
}

const char* MemoryString(int mem)
{
    switch (mem) {
    case MemoryModelSimple:     return "Simple";
    case MemoryModelGLSL450:    return "GLSL450";
    case MemoryModelOpenCL:     return "OpenCL";
    case MemoryModelVulkanKHR:  return "VulkanKHR";

    default: return "Bad";
    }
}

const int ExecutionModeCeiling = 33;

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 4446:  return "PostDepthCoverage";

#ifdef NV_EXTENSIONS
    case ExecutionModeOutputLinesNV:            return "OutputLinesNV";
    case ExecutionModeOutputPrimitivesNV:       return "OutputPrimitivesNV";
    case ExecutionModeOutputTrianglesNV:        return "OutputTrianglesNV";
    case ExecutionModeDerivativeGroupQuadsNV:   return "DerivativeGroupQuadsNV";
    case ExecutionModeDerivativeGroupLinearNV:  return "DerivativeGroupLinearNV";
#endif

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

#ifdef NV_EXTENSIONS
    case StorageClassRayPayloadNV:            return "RayPayloadNV";
    case StorageClassHitAttributeNV:          return "HitAttributeNV";
    case StorageClassIncomingRayPayloadNV:    return "IncomingRayPayloadNV";
    case StorageClassShaderRecordBufferNV:    return "ShaderRecordBufferNV";
    case StorageClassCallableDataNV:          return "CallableDataNV";
    case StorageClassIncomingCallableDataNV:  return "IncomingCallableDataNV";
#endif

    case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";

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

#ifdef AMD_EXTENSIONS
    case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
#endif
#ifdef NV_EXTENSIONS
    case DecorationOverrideCoverageNV:          return "OverrideCoverageNV";
    case DecorationPassthroughNV:               return "PassthroughNV";
    case DecorationViewportRelativeNV:          return "ViewportRelativeNV";
    case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
    case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
    case DecorationPerViewNV:                   return "PerViewNV";
    case DecorationPerTaskNV:                   return "PerTaskNV";
    case DecorationPerVertexNV:                 return "PerVertexNV";
#endif

    case DecorationNonUniformEXT:           return "DecorationNonUniformEXT";
    case DecorationHlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
    case DecorationHlslSemanticGOOGLE:      return "DecorationHlslSemanticGOOGLE";
    case DecorationRestrictPointerEXT:      return "DecorationRestrictPointerEXT";
    case DecorationAliasedPointerEXT:       return "DecorationAliasedPointerEXT";
    }
}

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 5014: return "FragStencilRefEXT";

#ifdef AMD_EXTENSIONS
    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";
#endif

#ifdef NV_EXTENSIONS
    case BuiltInLaunchIdNV:                 return "LaunchIdNV";
    case BuiltInLaunchSizeNV:               return "LaunchSizeNV";
    case BuiltInWorldRayOriginNV:           return "WorldRayOriginNV";
    case BuiltInWorldRayDirectionNV:        return "WorldRayDirectionNV";
    case BuiltInObjectRayOriginNV:          return "ObjectRayOriginNV";
    case BuiltInObjectRayDirectionNV:       return "ObjectRayDirectionNV";
    case BuiltInRayTminNV:                  return "RayTminNV";
    case BuiltInRayTmaxNV:                  return "RayTmaxNV";
    case BuiltInInstanceCustomIndexNV:      return "InstanceCustomIndexNV";
    case BuiltInObjectToWorldNV:            return "ObjectToWorldNV";
    case BuiltInWorldToObjectNV:            return "WorldToObjectNV";
    case BuiltInHitTNV:                     return "HitTNV";
    case BuiltInHitKindNV:                  return "HitKindNV";
    case BuiltInIncomingRayFlagsNV:         return "IncomingRayFlagsNV";
    case BuiltInViewportMaskNV:             return "ViewportMaskNV";
    case BuiltInSecondaryPositionNV:        return "SecondaryPositionNV";
    case BuiltInSecondaryViewportMaskNV:    return "SecondaryViewportMaskNV";
    case BuiltInPositionPerViewNV:          return "PositionPerViewNV";
    case BuiltInViewportMaskPerViewNV:      return "ViewportMaskPerViewNV";
//    case BuiltInFragmentSizeNV:             return "FragmentSizeNV";        // superseded by BuiltInFragSizeEXT
//    case BuiltInInvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
    case BuiltInBaryCoordNV:                return "BaryCoordNV";
    case BuiltInBaryCoordNoPerspNV:         return "BaryCoordNoPerspNV";
#endif

    case BuiltInFragSizeEXT:                return "FragSizeEXT";
    case BuiltInFragInvocationCountEXT:     return "FragInvocationCountEXT";

    case 5264: return "FullyCoveredEXT";


#ifdef NV_EXTENSIONS
    case BuiltInTaskCountNV:           return "TaskCountNV";
    case BuiltInPrimitiveCountNV:      return "PrimitiveCountNV";
    case BuiltInPrimitiveIndicesNV:    return "PrimitiveIndicesNV";
    case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV";
    case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV";
    case BuiltInLayerPerViewNV:        return "LayerPerViewNV";
    case BuiltInMeshViewCountNV:       return "MeshViewCountNV";
    case BuiltInMeshViewIndicesNV:     return "MeshViewIndicesNV";
#endif

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

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

    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 = 12;

const char* ImageOperandsString(int format)
{
    switch (format) {
    case ImageOperandsBiasShift:                    return "Bias";
    case ImageOperandsLodShift:                     return "Lod";
    case ImageOperandsGradShift:                    return "Grad";
    case ImageOperandsConstOffsetShift:             return "ConstOffset";
    case ImageOperandsOffsetShift:                  return "Offset";
    case ImageOperandsConstOffsetsShift:            return "ConstOffsets";
    case ImageOperandsSampleShift:                  return "Sample";
    case ImageOperandsMinLodShift:                  return "MinLod";
    case ImageOperandsMakeTexelAvailableKHRShift:   return "MakeTexelAvailableKHR";
    case ImageOperandsMakeTexelVisibleKHRShift:     return "MakeTexelVisibleKHR";
    case ImageOperandsNonPrivateTexelKHRShift:      return "NonPrivateTexelKHR";
    case ImageOperandsVolatileTexelKHRShift:        return "VolatileTexelKHR";

    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 = 4;

const char* LoopControlString(int cont)
{
    switch (cont) {
    case 0:  return "Unroll";
    case 1:  return "DontUnroll";
    case 2:  return "DependencyInfinite";
    case 3:  return "DependencyLength";

    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 MemoryAccessVolatileShift:                 return "Volatile";
    case MemoryAccessAlignedShift:                  return "Aligned";
    case MemoryAccessNontemporalShift:              return "Nontemporal";
    case MemoryAccessMakePointerAvailableKHRShift:  return "MakePointerAvailableKHR";
    case MemoryAccessMakePointerVisibleKHRShift:    return "MakePointerVisibleKHR";
    case MemoryAccessNonPrivatePointerKHRShift:     return "NonPrivatePointerKHR";

    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 GroupOperationReduce:  return "Reduce";
    case GroupOperationInclusiveScan:  return "InclusiveScan";
    case GroupOperationExclusiveScan:  return "ExclusiveScan";
    case GroupOperationClusteredReduce:  return "ClusteredReduce";
#ifdef NV_EXTENSIONS
    case GroupOperationPartitionedReduceNV:  return "PartitionedReduceNV";
    case GroupOperationPartitionedInclusiveScanNV:  return "PartitionedInclusiveScanNV";
    case GroupOperationPartitionedExclusiveScanNV:  return "PartitionedExclusiveScanNV";
#endif

    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 CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR";
    case CapabilityDrawParameters:    return "DrawParameters";
    case CapabilitySubgroupVoteKHR:   return "SubgroupVoteKHR";

    case CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
    case CapabilityStorageUniform16:            return "StorageUniform16";
    case CapabilityStoragePushConstant16:       return "StoragePushConstant16";
    case CapabilityStorageInputOutput16:        return "StorageInputOutput16";

    case CapabilityStorageBuffer8BitAccess:             return "CapabilityStorageBuffer8BitAccess";
    case CapabilityUniformAndStorageBuffer8BitAccess:   return "CapabilityUniformAndStorageBuffer8BitAccess";
    case CapabilityStoragePushConstant8:                return "CapabilityStoragePushConstant8";

    case CapabilityDeviceGroup: return "DeviceGroup";
    case CapabilityMultiView:   return "MultiView";

    case CapabilityStencilExportEXT: return "StencilExportEXT";

#ifdef AMD_EXTENSIONS
    case CapabilityFloat16ImageAMD:       return "Float16ImageAMD";
    case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
    case CapabilityFragmentMaskAMD:       return "FragmentMaskAMD";
    case CapabilityImageReadWriteLodAMD:  return "ImageReadWriteLodAMD";
#endif

    case CapabilityAtomicStorageOps:             return "AtomicStorageOps";

    case CapabilitySampleMaskPostDepthCoverage:  return "SampleMaskPostDepthCoverage";
#ifdef NV_EXTENSIONS
    case CapabilityGeometryShaderPassthroughNV:     return "GeometryShaderPassthroughNV";
    case CapabilityShaderViewportIndexLayerNV:      return "ShaderViewportIndexLayerNV";
    case CapabilityShaderViewportMaskNV:            return "ShaderViewportMaskNV";
    case CapabilityShaderStereoViewNV:              return "ShaderStereoViewNV";
    case CapabilityPerViewAttributesNV:             return "PerViewAttributesNV";
    case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
    case CapabilityRayTracingNV:                    return "RayTracingNV";
    case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
    case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
    case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
    case CapabilityMeshShadingNV:                   return "MeshShadingNV";
//    case CapabilityShadingRateNV:                   return "ShadingRateNV";  // superseded by CapabilityFragmentDensityEXT
#endif
    case CapabilityFragmentDensityEXT:              return "FragmentDensityEXT";

    case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";

    case CapabilityShaderNonUniformEXT:                          return "CapabilityShaderNonUniformEXT";
    case CapabilityRuntimeDescriptorArrayEXT:                    return "CapabilityRuntimeDescriptorArrayEXT";
    case CapabilityInputAttachmentArrayDynamicIndexingEXT:       return "CapabilityInputAttachmentArrayDynamicIndexingEXT";
    case CapabilityUniformTexelBufferArrayDynamicIndexingEXT:    return "CapabilityUniformTexelBufferArrayDynamicIndexingEXT";
    case CapabilityStorageTexelBufferArrayDynamicIndexingEXT:    return "CapabilityStorageTexelBufferArrayDynamicIndexingEXT";
    case CapabilityUniformBufferArrayNonUniformIndexingEXT:      return "CapabilityUniformBufferArrayNonUniformIndexingEXT";
    case CapabilitySampledImageArrayNonUniformIndexingEXT:       return "CapabilitySampledImageArrayNonUniformIndexingEXT";
    case CapabilityStorageBufferArrayNonUniformIndexingEXT:      return "CapabilityStorageBufferArrayNonUniformIndexingEXT";
    case CapabilityStorageImageArrayNonUniformIndexingEXT:       return "CapabilityStorageImageArrayNonUniformIndexingEXT";
    case CapabilityInputAttachmentArrayNonUniformIndexingEXT:    return "CapabilityInputAttachmentArrayNonUniformIndexingEXT";
    case CapabilityUniformTexelBufferArrayNonUniformIndexingEXT: return "CapabilityUniformTexelBufferArrayNonUniformIndexingEXT";
    case CapabilityStorageTexelBufferArrayNonUniformIndexingEXT: return "CapabilityStorageTexelBufferArrayNonUniformIndexingEXT";

    case CapabilityVulkanMemoryModelKHR:                return "CapabilityVulkanMemoryModelKHR";
    case CapabilityVulkanMemoryModelDeviceScopeKHR:     return "CapabilityVulkanMemoryModelDeviceScopeKHR";

    case CapabilityPhysicalStorageBufferAddressesEXT:   return "CapabilityPhysicalStorageBufferAddressesEXT";

    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 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 OpModuleProcessed: return "OpModuleProcessed";
    case 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 4421: return "OpSubgroupBallotKHR";
    case 4422: return "OpSubgroupFirstInvocationKHR";
    case 4428: return "OpSubgroupAllKHR";
    case 4429: return "OpSubgroupAnyKHR";
    case 4430: return "OpSubgroupAllEqualKHR";
    case 4432: return "OpSubgroupReadInvocationKHR";

#ifdef AMD_EXTENSIONS
    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";
#endif

    case OpDecorateStringGOOGLE:       return "OpDecorateStringGOOGLE";
    case OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";

#ifdef NV_EXTENSIONS
    case OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
    case OpReportIntersectionNV:             return "OpReportIntersectionNV";
    case OpIgnoreIntersectionNV:             return "OpIgnoreIntersectionNV";
    case OpTerminateRayNV:                   return "OpTerminateRayNV";
    case OpTraceNV:                          return "OpTraceNV";
    case OpTypeAccelerationStructureNV:      return "OpTypeAccelerationStructureNV";
    case OpExecuteCallableNV:                return "OpExecuteCallableNV";
    case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
    case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
#endif

    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];

// Set up all the parameterizing descriptions of the opcodes, operands, etc.
void Parameterize()
{
    // only do this once.
    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;

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

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

    // Specific additional context-dependent operands

    ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");

    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'");
    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'");
    ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'");

    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'");
    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'");
    ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'");

    ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'");
    ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'");

    DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'");
    DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'");
    DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'");
    DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'");
    DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'");
    DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'");
    DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'");
    DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'");
    DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'");
    DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'");
    DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'");
    DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
    DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
    DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'");
    DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'");
    DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'");
    DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
    DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'");
    DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
    DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");

    OperandClassParams[OperandSource].set(0, SourceString, 0);
    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[OperandOpcode].set(OpCodeMask + 1, OpcodeString, 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'");

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

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

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

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

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

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

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

    InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type.");

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

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

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

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

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

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

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

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

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

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

    InstructionDesc[OpVariable].operands.push(OperandStorage, "");
    InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true);

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

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

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

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

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

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

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

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

    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandId, "'Target'");
    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandDecoration, "");
    InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandLiteralString, "'Literal String'");

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

    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandId, "'Structure Type'");
    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralNumber, "'Member'");
    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandDecoration, "");
    InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralString, "'Literal String'");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'");
    InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'");
    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'");
    InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'");
    
    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'");
    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'");
    InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'");
    
    InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef AMD_EXTENSIONS
    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
    InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'");

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

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

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

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

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

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

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

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

    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Image'");
    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Coordinate'");
    InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Fragment Index'");
#endif

#ifdef NV_EXTENSIONS
    InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");

    InstructionDesc[OpTypeAccelerationStructureNV].setResultAndType(true, false);

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

    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Parameter'");
    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Kind'");

    InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);

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

    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'");
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true);
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true);
    
    InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
    InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
#endif
}

}; // end spv namespace